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 is required for parameter";
  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;                                                              \
 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;                                                              \
 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;                                                              \
 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;                                                              \
 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;                                                              \
 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__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
1183 static PyObject *_wrap_wxPyGridCellRenderer__setSelf(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__setSelf",_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__setSelf. 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__setSelf(_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__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
2440 static PyObject *_wrap_wxPyGridCellEditor__setSelf(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__setSelf",_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__setSelf. 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__setSelf(_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         const wxColour & _result_ref = wxGridCellAttr_GetTextColour(_arg0);
3770     _result = (wxColour *) &_result_ref;
3771
3772     wxPy_END_ALLOW_THREADS;
3773     if (PyErr_Occurred()) return NULL;
3774 }    if (_result) {
3775         SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p");
3776         _resultobj = Py_BuildValue("s",_ptemp);
3777     } else {
3778         Py_INCREF(Py_None);
3779         _resultobj = Py_None;
3780     }
3781     return _resultobj;
3782 }
3783
3784 #define wxGridCellAttr_GetBackgroundColour(_swigobj)  (_swigobj->GetBackgroundColour())
3785 static PyObject *_wrap_wxGridCellAttr_GetBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3786     PyObject * _resultobj;
3787     wxColour * _result;
3788     wxGridCellAttr * _arg0;
3789     PyObject * _argo0 = 0;
3790     char *_kwnames[] = { "self", NULL };
3791     char _ptemp[128];
3792
3793     self = self;
3794     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetBackgroundColour",_kwnames,&_argo0))
3795         return NULL;
3796     if (_argo0) {
3797         if (_argo0 == Py_None) { _arg0 = NULL; }
3798         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3799             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetBackgroundColour. Expected _wxGridCellAttr_p.");
3800         return NULL;
3801         }
3802     }
3803 {
3804     wxPy_BEGIN_ALLOW_THREADS;
3805         const wxColour & _result_ref = wxGridCellAttr_GetBackgroundColour(_arg0);
3806     _result = (wxColour *) &_result_ref;
3807
3808     wxPy_END_ALLOW_THREADS;
3809     if (PyErr_Occurred()) return NULL;
3810 }    if (_result) {
3811         SWIG_MakePtr(_ptemp, (char *) _result,"_wxColour_p");
3812         _resultobj = Py_BuildValue("s",_ptemp);
3813     } else {
3814         Py_INCREF(Py_None);
3815         _resultobj = Py_None;
3816     }
3817     return _resultobj;
3818 }
3819
3820 #define wxGridCellAttr_GetFont(_swigobj)  (_swigobj->GetFont())
3821 static PyObject *_wrap_wxGridCellAttr_GetFont(PyObject *self, PyObject *args, PyObject *kwargs) {
3822     PyObject * _resultobj;
3823     wxFont * _result;
3824     wxGridCellAttr * _arg0;
3825     PyObject * _argo0 = 0;
3826     char *_kwnames[] = { "self", NULL };
3827     char _ptemp[128];
3828
3829     self = self;
3830     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetFont",_kwnames,&_argo0))
3831         return NULL;
3832     if (_argo0) {
3833         if (_argo0 == Py_None) { _arg0 = NULL; }
3834         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3835             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetFont. Expected _wxGridCellAttr_p.");
3836         return NULL;
3837         }
3838     }
3839 {
3840     wxPy_BEGIN_ALLOW_THREADS;
3841         const wxFont & _result_ref = wxGridCellAttr_GetFont(_arg0);
3842     _result = (wxFont *) &_result_ref;
3843
3844     wxPy_END_ALLOW_THREADS;
3845     if (PyErr_Occurred()) return NULL;
3846 }    if (_result) {
3847         SWIG_MakePtr(_ptemp, (char *) _result,"_wxFont_p");
3848         _resultobj = Py_BuildValue("s",_ptemp);
3849     } else {
3850         Py_INCREF(Py_None);
3851         _resultobj = Py_None;
3852     }
3853     return _resultobj;
3854 }
3855
3856 #define wxGridCellAttr_GetAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetAlignment(_swigarg0,_swigarg1))
3857 static PyObject *_wrap_wxGridCellAttr_GetAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
3858     PyObject * _resultobj;
3859     wxGridCellAttr * _arg0;
3860     int * _arg1;
3861     int  temp;
3862     int * _arg2;
3863     int  temp0;
3864     PyObject * _argo0 = 0;
3865     char *_kwnames[] = { "self", NULL };
3866
3867     self = self;
3868 {
3869   _arg1 = &temp;
3870 }
3871 {
3872   _arg2 = &temp0;
3873 }
3874     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetAlignment",_kwnames,&_argo0))
3875         return NULL;
3876     if (_argo0) {
3877         if (_argo0 == Py_None) { _arg0 = NULL; }
3878         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3879             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetAlignment. Expected _wxGridCellAttr_p.");
3880         return NULL;
3881         }
3882     }
3883 {
3884     wxPy_BEGIN_ALLOW_THREADS;
3885         wxGridCellAttr_GetAlignment(_arg0,_arg1,_arg2);
3886
3887     wxPy_END_ALLOW_THREADS;
3888     if (PyErr_Occurred()) return NULL;
3889 }    Py_INCREF(Py_None);
3890     _resultobj = Py_None;
3891 {
3892     PyObject *o;
3893     o = PyInt_FromLong((long) (*_arg1));
3894     _resultobj = t_output_helper(_resultobj, o);
3895 }
3896 {
3897     PyObject *o;
3898     o = PyInt_FromLong((long) (*_arg2));
3899     _resultobj = t_output_helper(_resultobj, o);
3900 }
3901     return _resultobj;
3902 }
3903
3904 #define wxGridCellAttr_GetRenderer(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetRenderer(_swigarg0,_swigarg1,_swigarg2))
3905 static PyObject *_wrap_wxGridCellAttr_GetRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
3906     PyObject * _resultobj;
3907     wxGridCellRenderer * _result;
3908     wxGridCellAttr * _arg0;
3909     wxGrid * _arg1;
3910     int  _arg2;
3911     int  _arg3;
3912     PyObject * _argo0 = 0;
3913     PyObject * _argo1 = 0;
3914     char *_kwnames[] = { "self","grid","row","col", NULL };
3915     char _ptemp[128];
3916
3917     self = self;
3918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetRenderer",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
3919         return NULL;
3920     if (_argo0) {
3921         if (_argo0 == Py_None) { _arg0 = NULL; }
3922         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3923             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetRenderer. Expected _wxGridCellAttr_p.");
3924         return NULL;
3925         }
3926     }
3927     if (_argo1) {
3928         if (_argo1 == Py_None) { _arg1 = NULL; }
3929         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
3930             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_GetRenderer. Expected _wxGrid_p.");
3931         return NULL;
3932         }
3933     }
3934 {
3935     wxPy_BEGIN_ALLOW_THREADS;
3936         _result = (wxGridCellRenderer *)wxGridCellAttr_GetRenderer(_arg0,_arg1,_arg2,_arg3);
3937
3938     wxPy_END_ALLOW_THREADS;
3939     if (PyErr_Occurred()) return NULL;
3940 }    if (_result) {
3941         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
3942         _resultobj = Py_BuildValue("s",_ptemp);
3943     } else {
3944         Py_INCREF(Py_None);
3945         _resultobj = Py_None;
3946     }
3947     return _resultobj;
3948 }
3949
3950 #define wxGridCellAttr_GetEditor(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetEditor(_swigarg0,_swigarg1,_swigarg2))
3951 static PyObject *_wrap_wxGridCellAttr_GetEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3952     PyObject * _resultobj;
3953     wxGridCellEditor * _result;
3954     wxGridCellAttr * _arg0;
3955     wxGrid * _arg1;
3956     int  _arg2;
3957     int  _arg3;
3958     PyObject * _argo0 = 0;
3959     PyObject * _argo1 = 0;
3960     char *_kwnames[] = { "self","grid","row","col", NULL };
3961     char _ptemp[128];
3962
3963     self = self;
3964     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttr_GetEditor",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
3965         return NULL;
3966     if (_argo0) {
3967         if (_argo0 == Py_None) { _arg0 = NULL; }
3968         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3969             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetEditor. Expected _wxGridCellAttr_p.");
3970         return NULL;
3971         }
3972     }
3973     if (_argo1) {
3974         if (_argo1 == Py_None) { _arg1 = NULL; }
3975         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
3976             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_GetEditor. Expected _wxGrid_p.");
3977         return NULL;
3978         }
3979     }
3980 {
3981     wxPy_BEGIN_ALLOW_THREADS;
3982         _result = (wxGridCellEditor *)wxGridCellAttr_GetEditor(_arg0,_arg1,_arg2,_arg3);
3983
3984     wxPy_END_ALLOW_THREADS;
3985     if (PyErr_Occurred()) return NULL;
3986 }    if (_result) {
3987         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
3988         _resultobj = Py_BuildValue("s",_ptemp);
3989     } else {
3990         Py_INCREF(Py_None);
3991         _resultobj = Py_None;
3992     }
3993     return _resultobj;
3994 }
3995
3996 #define wxGridCellAttr_IsReadOnly(_swigobj)  (_swigobj->IsReadOnly())
3997 static PyObject *_wrap_wxGridCellAttr_IsReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
3998     PyObject * _resultobj;
3999     bool  _result;
4000     wxGridCellAttr * _arg0;
4001     PyObject * _argo0 = 0;
4002     char *_kwnames[] = { "self", NULL };
4003
4004     self = self;
4005     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_IsReadOnly",_kwnames,&_argo0))
4006         return NULL;
4007     if (_argo0) {
4008         if (_argo0 == Py_None) { _arg0 = NULL; }
4009         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
4010             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_IsReadOnly. Expected _wxGridCellAttr_p.");
4011         return NULL;
4012         }
4013     }
4014 {
4015     wxPy_BEGIN_ALLOW_THREADS;
4016         _result = (bool )wxGridCellAttr_IsReadOnly(_arg0);
4017
4018     wxPy_END_ALLOW_THREADS;
4019     if (PyErr_Occurred()) return NULL;
4020 }    _resultobj = Py_BuildValue("i",_result);
4021     return _resultobj;
4022 }
4023
4024 #define wxGridCellAttr_SetDefAttr(_swigobj,_swigarg0)  (_swigobj->SetDefAttr(_swigarg0))
4025 static PyObject *_wrap_wxGridCellAttr_SetDefAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4026     PyObject * _resultobj;
4027     wxGridCellAttr * _arg0;
4028     wxGridCellAttr * _arg1;
4029     PyObject * _argo0 = 0;
4030     PyObject * _argo1 = 0;
4031     char *_kwnames[] = { "self","defAttr", NULL };
4032
4033     self = self;
4034     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetDefAttr",_kwnames,&_argo0,&_argo1))
4035         return NULL;
4036     if (_argo0) {
4037         if (_argo0 == Py_None) { _arg0 = NULL; }
4038         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
4039             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetDefAttr. Expected _wxGridCellAttr_p.");
4040         return NULL;
4041         }
4042     }
4043     if (_argo1) {
4044         if (_argo1 == Py_None) { _arg1 = NULL; }
4045         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4046             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetDefAttr. Expected _wxGridCellAttr_p.");
4047         return NULL;
4048         }
4049     }
4050 {
4051     wxPy_BEGIN_ALLOW_THREADS;
4052         wxGridCellAttr_SetDefAttr(_arg0,_arg1);
4053
4054     wxPy_END_ALLOW_THREADS;
4055     if (PyErr_Occurred()) return NULL;
4056 }    Py_INCREF(Py_None);
4057     _resultobj = Py_None;
4058     return _resultobj;
4059 }
4060
4061 #define new_wxGridCellAttrProvider() (new wxGridCellAttrProvider())
4062 static PyObject *_wrap_new_wxGridCellAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4063     PyObject * _resultobj;
4064     wxGridCellAttrProvider * _result;
4065     char *_kwnames[] = {  NULL };
4066     char _ptemp[128];
4067
4068     self = self;
4069     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttrProvider",_kwnames))
4070         return NULL;
4071 {
4072     wxPy_BEGIN_ALLOW_THREADS;
4073         _result = (wxGridCellAttrProvider *)new_wxGridCellAttrProvider();
4074
4075     wxPy_END_ALLOW_THREADS;
4076     if (PyErr_Occurred()) return NULL;
4077 }    if (_result) {
4078         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
4079         _resultobj = Py_BuildValue("s",_ptemp);
4080     } else {
4081         Py_INCREF(Py_None);
4082         _resultobj = Py_None;
4083     }
4084     return _resultobj;
4085 }
4086
4087 #define wxGridCellAttrProvider_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetAttr(_swigarg0,_swigarg1,_swigarg2))
4088 static PyObject *_wrap_wxGridCellAttrProvider_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4089     PyObject * _resultobj;
4090     wxGridCellAttr * _result;
4091     wxGridCellAttrProvider * _arg0;
4092     int  _arg1;
4093     int  _arg2;
4094     wxGridCellAttr::wxAttrKind  _arg3;
4095     PyObject * _argo0 = 0;
4096     char *_kwnames[] = { "self","row","col","kind", NULL };
4097     char _ptemp[128];
4098
4099     self = self;
4100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridCellAttrProvider_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
4101         return NULL;
4102     if (_argo0) {
4103         if (_argo0 == Py_None) { _arg0 = NULL; }
4104         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4105             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_GetAttr. Expected _wxGridCellAttrProvider_p.");
4106         return NULL;
4107         }
4108     }
4109 {
4110     wxPy_BEGIN_ALLOW_THREADS;
4111         _result = (wxGridCellAttr *)wxGridCellAttrProvider_GetAttr(_arg0,_arg1,_arg2,_arg3);
4112
4113     wxPy_END_ALLOW_THREADS;
4114     if (PyErr_Occurred()) return NULL;
4115 }    if (_result) {
4116         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
4117         _resultobj = Py_BuildValue("s",_ptemp);
4118     } else {
4119         Py_INCREF(Py_None);
4120         _resultobj = Py_None;
4121     }
4122     return _resultobj;
4123 }
4124
4125 #define wxGridCellAttrProvider_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetAttr(_swigarg0,_swigarg1,_swigarg2))
4126 static PyObject *_wrap_wxGridCellAttrProvider_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4127     PyObject * _resultobj;
4128     wxGridCellAttrProvider * _arg0;
4129     wxGridCellAttr * _arg1;
4130     int  _arg2;
4131     int  _arg3;
4132     PyObject * _argo0 = 0;
4133     PyObject * _argo1 = 0;
4134     char *_kwnames[] = { "self","attr","row","col", NULL };
4135
4136     self = self;
4137     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridCellAttrProvider_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
4138         return NULL;
4139     if (_argo0) {
4140         if (_argo0 == Py_None) { _arg0 = NULL; }
4141         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4142             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_SetAttr. Expected _wxGridCellAttrProvider_p.");
4143         return NULL;
4144         }
4145     }
4146     if (_argo1) {
4147         if (_argo1 == Py_None) { _arg1 = NULL; }
4148         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4149             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttrProvider_SetAttr. Expected _wxGridCellAttr_p.");
4150         return NULL;
4151         }
4152     }
4153 {
4154     wxPy_BEGIN_ALLOW_THREADS;
4155         wxGridCellAttrProvider_SetAttr(_arg0,_arg1,_arg2,_arg3);
4156
4157     wxPy_END_ALLOW_THREADS;
4158     if (PyErr_Occurred()) return NULL;
4159 }    Py_INCREF(Py_None);
4160     _resultobj = Py_None;
4161     return _resultobj;
4162 }
4163
4164 #define wxGridCellAttrProvider_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
4165 static PyObject *_wrap_wxGridCellAttrProvider_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4166     PyObject * _resultobj;
4167     wxGridCellAttrProvider * _arg0;
4168     wxGridCellAttr * _arg1;
4169     int  _arg2;
4170     PyObject * _argo0 = 0;
4171     PyObject * _argo1 = 0;
4172     char *_kwnames[] = { "self","attr","row", NULL };
4173
4174     self = self;
4175     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridCellAttrProvider_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4176         return NULL;
4177     if (_argo0) {
4178         if (_argo0 == Py_None) { _arg0 = NULL; }
4179         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4180             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_SetRowAttr. Expected _wxGridCellAttrProvider_p.");
4181         return NULL;
4182         }
4183     }
4184     if (_argo1) {
4185         if (_argo1 == Py_None) { _arg1 = NULL; }
4186         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4187             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttrProvider_SetRowAttr. Expected _wxGridCellAttr_p.");
4188         return NULL;
4189         }
4190     }
4191 {
4192     wxPy_BEGIN_ALLOW_THREADS;
4193         wxGridCellAttrProvider_SetRowAttr(_arg0,_arg1,_arg2);
4194
4195     wxPy_END_ALLOW_THREADS;
4196     if (PyErr_Occurred()) return NULL;
4197 }    Py_INCREF(Py_None);
4198     _resultobj = Py_None;
4199     return _resultobj;
4200 }
4201
4202 #define wxGridCellAttrProvider_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
4203 static PyObject *_wrap_wxGridCellAttrProvider_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4204     PyObject * _resultobj;
4205     wxGridCellAttrProvider * _arg0;
4206     wxGridCellAttr * _arg1;
4207     int  _arg2;
4208     PyObject * _argo0 = 0;
4209     PyObject * _argo1 = 0;
4210     char *_kwnames[] = { "self","attr","col", NULL };
4211
4212     self = self;
4213     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridCellAttrProvider_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4214         return NULL;
4215     if (_argo0) {
4216         if (_argo0 == Py_None) { _arg0 = NULL; }
4217         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4218             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_SetColAttr. Expected _wxGridCellAttrProvider_p.");
4219         return NULL;
4220         }
4221     }
4222     if (_argo1) {
4223         if (_argo1 == Py_None) { _arg1 = NULL; }
4224         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4225             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttrProvider_SetColAttr. Expected _wxGridCellAttr_p.");
4226         return NULL;
4227         }
4228     }
4229 {
4230     wxPy_BEGIN_ALLOW_THREADS;
4231         wxGridCellAttrProvider_SetColAttr(_arg0,_arg1,_arg2);
4232
4233     wxPy_END_ALLOW_THREADS;
4234     if (PyErr_Occurred()) return NULL;
4235 }    Py_INCREF(Py_None);
4236     _resultobj = Py_None;
4237     return _resultobj;
4238 }
4239
4240 #define wxGridCellAttrProvider_UpdateAttrRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->UpdateAttrRows(_swigarg0,_swigarg1))
4241 static PyObject *_wrap_wxGridCellAttrProvider_UpdateAttrRows(PyObject *self, PyObject *args, PyObject *kwargs) {
4242     PyObject * _resultobj;
4243     wxGridCellAttrProvider * _arg0;
4244     size_t  _arg1;
4245     int  _arg2;
4246     PyObject * _argo0 = 0;
4247     char *_kwnames[] = { "self","pos","numRows", NULL };
4248
4249     self = self;
4250     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttrProvider_UpdateAttrRows",_kwnames,&_argo0,&_arg1,&_arg2))
4251         return NULL;
4252     if (_argo0) {
4253         if (_argo0 == Py_None) { _arg0 = NULL; }
4254         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4255             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_UpdateAttrRows. Expected _wxGridCellAttrProvider_p.");
4256         return NULL;
4257         }
4258     }
4259 {
4260     wxPy_BEGIN_ALLOW_THREADS;
4261         wxGridCellAttrProvider_UpdateAttrRows(_arg0,_arg1,_arg2);
4262
4263     wxPy_END_ALLOW_THREADS;
4264     if (PyErr_Occurred()) return NULL;
4265 }    Py_INCREF(Py_None);
4266     _resultobj = Py_None;
4267     return _resultobj;
4268 }
4269
4270 #define wxGridCellAttrProvider_UpdateAttrCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->UpdateAttrCols(_swigarg0,_swigarg1))
4271 static PyObject *_wrap_wxGridCellAttrProvider_UpdateAttrCols(PyObject *self, PyObject *args, PyObject *kwargs) {
4272     PyObject * _resultobj;
4273     wxGridCellAttrProvider * _arg0;
4274     size_t  _arg1;
4275     int  _arg2;
4276     PyObject * _argo0 = 0;
4277     char *_kwnames[] = { "self","pos","numCols", NULL };
4278
4279     self = self;
4280     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttrProvider_UpdateAttrCols",_kwnames,&_argo0,&_arg1,&_arg2))
4281         return NULL;
4282     if (_argo0) {
4283         if (_argo0 == Py_None) { _arg0 = NULL; }
4284         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttrProvider_p")) {
4285             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttrProvider_UpdateAttrCols. Expected _wxGridCellAttrProvider_p.");
4286         return NULL;
4287         }
4288     }
4289 {
4290     wxPy_BEGIN_ALLOW_THREADS;
4291         wxGridCellAttrProvider_UpdateAttrCols(_arg0,_arg1,_arg2);
4292
4293     wxPy_END_ALLOW_THREADS;
4294     if (PyErr_Occurred()) return NULL;
4295 }    Py_INCREF(Py_None);
4296     _resultobj = Py_None;
4297     return _resultobj;
4298 }
4299
4300 static void *SwigwxPyGridCellAttrProviderTowxGridCellAttrProvider(void *ptr) {
4301     wxPyGridCellAttrProvider *src;
4302     wxGridCellAttrProvider *dest;
4303     src = (wxPyGridCellAttrProvider *) ptr;
4304     dest = (wxGridCellAttrProvider *) src;
4305     return (void *) dest;
4306 }
4307
4308 #define new_wxPyGridCellAttrProvider() (new wxPyGridCellAttrProvider())
4309 static PyObject *_wrap_new_wxPyGridCellAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4310     PyObject * _resultobj;
4311     wxPyGridCellAttrProvider * _result;
4312     char *_kwnames[] = {  NULL };
4313     char _ptemp[128];
4314
4315     self = self;
4316     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellAttrProvider",_kwnames))
4317         return NULL;
4318 {
4319     wxPy_BEGIN_ALLOW_THREADS;
4320         _result = (wxPyGridCellAttrProvider *)new_wxPyGridCellAttrProvider();
4321
4322     wxPy_END_ALLOW_THREADS;
4323     if (PyErr_Occurred()) return NULL;
4324 }    if (_result) {
4325         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellAttrProvider_p");
4326         _resultobj = Py_BuildValue("s",_ptemp);
4327     } else {
4328         Py_INCREF(Py_None);
4329         _resultobj = Py_None;
4330     }
4331     return _resultobj;
4332 }
4333
4334 #define wxPyGridCellAttrProvider__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
4335 static PyObject *_wrap_wxPyGridCellAttrProvider__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
4336     PyObject * _resultobj;
4337     wxPyGridCellAttrProvider * _arg0;
4338     PyObject * _arg1;
4339     PyObject * _arg2;
4340     PyObject * _argo0 = 0;
4341     PyObject * _obj1 = 0;
4342     PyObject * _obj2 = 0;
4343     char *_kwnames[] = { "self","self","_class", NULL };
4344
4345     self = self;
4346     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellAttrProvider__setSelf",_kwnames,&_argo0,&_obj1,&_obj2))
4347         return NULL;
4348     if (_argo0) {
4349         if (_argo0 == Py_None) { _arg0 = NULL; }
4350         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4351             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider__setSelf. Expected _wxPyGridCellAttrProvider_p.");
4352         return NULL;
4353         }
4354     }
4355 {
4356   _arg1 = _obj1;
4357 }
4358 {
4359   _arg2 = _obj2;
4360 }
4361 {
4362     wxPy_BEGIN_ALLOW_THREADS;
4363         wxPyGridCellAttrProvider__setSelf(_arg0,_arg1,_arg2);
4364
4365     wxPy_END_ALLOW_THREADS;
4366     if (PyErr_Occurred()) return NULL;
4367 }    Py_INCREF(Py_None);
4368     _resultobj = Py_None;
4369     return _resultobj;
4370 }
4371
4372 #define wxPyGridCellAttrProvider_base_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_GetAttr(_swigarg0,_swigarg1,_swigarg2))
4373 static PyObject *_wrap_wxPyGridCellAttrProvider_base_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4374     PyObject * _resultobj;
4375     wxGridCellAttr * _result;
4376     wxPyGridCellAttrProvider * _arg0;
4377     int  _arg1;
4378     int  _arg2;
4379     wxGridCellAttr::wxAttrKind  _arg3;
4380     PyObject * _argo0 = 0;
4381     char *_kwnames[] = { "self","row","col","kind", NULL };
4382     char _ptemp[128];
4383
4384     self = self;
4385     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridCellAttrProvider_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
4386         return NULL;
4387     if (_argo0) {
4388         if (_argo0 == Py_None) { _arg0 = NULL; }
4389         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4390             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_GetAttr. Expected _wxPyGridCellAttrProvider_p.");
4391         return NULL;
4392         }
4393     }
4394 {
4395     wxPy_BEGIN_ALLOW_THREADS;
4396         _result = (wxGridCellAttr *)wxPyGridCellAttrProvider_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
4397
4398     wxPy_END_ALLOW_THREADS;
4399     if (PyErr_Occurred()) return NULL;
4400 }    if (_result) {
4401         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
4402         _resultobj = Py_BuildValue("s",_ptemp);
4403     } else {
4404         Py_INCREF(Py_None);
4405         _resultobj = Py_None;
4406     }
4407     return _resultobj;
4408 }
4409
4410 #define wxPyGridCellAttrProvider_base_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_SetAttr(_swigarg0,_swigarg1,_swigarg2))
4411 static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4412     PyObject * _resultobj;
4413     wxPyGridCellAttrProvider * _arg0;
4414     wxGridCellAttr * _arg1;
4415     int  _arg2;
4416     int  _arg3;
4417     PyObject * _argo0 = 0;
4418     PyObject * _argo1 = 0;
4419     char *_kwnames[] = { "self","attr","row","col", NULL };
4420
4421     self = self;
4422     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxPyGridCellAttrProvider_base_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
4423         return NULL;
4424     if (_argo0) {
4425         if (_argo0 == Py_None) { _arg0 = NULL; }
4426         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4427             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_SetAttr. Expected _wxPyGridCellAttrProvider_p.");
4428         return NULL;
4429         }
4430     }
4431     if (_argo1) {
4432         if (_argo1 == Py_None) { _arg1 = NULL; }
4433         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4434             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellAttrProvider_base_SetAttr. Expected _wxGridCellAttr_p.");
4435         return NULL;
4436         }
4437     }
4438 {
4439     wxPy_BEGIN_ALLOW_THREADS;
4440         wxPyGridCellAttrProvider_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
4441
4442     wxPy_END_ALLOW_THREADS;
4443     if (PyErr_Occurred()) return NULL;
4444 }    Py_INCREF(Py_None);
4445     _resultobj = Py_None;
4446     return _resultobj;
4447 }
4448
4449 #define wxPyGridCellAttrProvider_base_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetRowAttr(_swigarg0,_swigarg1))
4450 static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4451     PyObject * _resultobj;
4452     wxPyGridCellAttrProvider * _arg0;
4453     wxGridCellAttr * _arg1;
4454     int  _arg2;
4455     PyObject * _argo0 = 0;
4456     PyObject * _argo1 = 0;
4457     char *_kwnames[] = { "self","attr","row", NULL };
4458
4459     self = self;
4460     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridCellAttrProvider_base_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4461         return NULL;
4462     if (_argo0) {
4463         if (_argo0 == Py_None) { _arg0 = NULL; }
4464         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4465             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_SetRowAttr. Expected _wxPyGridCellAttrProvider_p.");
4466         return NULL;
4467         }
4468     }
4469     if (_argo1) {
4470         if (_argo1 == Py_None) { _arg1 = NULL; }
4471         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4472             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellAttrProvider_base_SetRowAttr. Expected _wxGridCellAttr_p.");
4473         return NULL;
4474         }
4475     }
4476 {
4477     wxPy_BEGIN_ALLOW_THREADS;
4478         wxPyGridCellAttrProvider_base_SetRowAttr(_arg0,_arg1,_arg2);
4479
4480     wxPy_END_ALLOW_THREADS;
4481     if (PyErr_Occurred()) return NULL;
4482 }    Py_INCREF(Py_None);
4483     _resultobj = Py_None;
4484     return _resultobj;
4485 }
4486
4487 #define wxPyGridCellAttrProvider_base_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetColAttr(_swigarg0,_swigarg1))
4488 static PyObject *_wrap_wxPyGridCellAttrProvider_base_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
4489     PyObject * _resultobj;
4490     wxPyGridCellAttrProvider * _arg0;
4491     wxGridCellAttr * _arg1;
4492     int  _arg2;
4493     PyObject * _argo0 = 0;
4494     PyObject * _argo1 = 0;
4495     char *_kwnames[] = { "self","attr","col", NULL };
4496
4497     self = self;
4498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridCellAttrProvider_base_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
4499         return NULL;
4500     if (_argo0) {
4501         if (_argo0 == Py_None) { _arg0 = NULL; }
4502         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellAttrProvider_p")) {
4503             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellAttrProvider_base_SetColAttr. Expected _wxPyGridCellAttrProvider_p.");
4504         return NULL;
4505         }
4506     }
4507     if (_argo1) {
4508         if (_argo1 == Py_None) { _arg1 = NULL; }
4509         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
4510             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellAttrProvider_base_SetColAttr. Expected _wxGridCellAttr_p.");
4511         return NULL;
4512         }
4513     }
4514 {
4515     wxPy_BEGIN_ALLOW_THREADS;
4516         wxPyGridCellAttrProvider_base_SetColAttr(_arg0,_arg1,_arg2);
4517
4518     wxPy_END_ALLOW_THREADS;
4519     if (PyErr_Occurred()) return NULL;
4520 }    Py_INCREF(Py_None);
4521     _resultobj = Py_None;
4522     return _resultobj;
4523 }
4524
4525 static void *SwigwxGridTableBaseTowxObject(void *ptr) {
4526     wxGridTableBase *src;
4527     wxObject *dest;
4528     src = (wxGridTableBase *) ptr;
4529     dest = (wxObject *) src;
4530     return (void *) dest;
4531 }
4532
4533 #define wxGridTableBase_SetAttrProvider(_swigobj,_swigarg0)  (_swigobj->SetAttrProvider(_swigarg0))
4534 static PyObject *_wrap_wxGridTableBase_SetAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4535     PyObject * _resultobj;
4536     wxGridTableBase * _arg0;
4537     wxGridCellAttrProvider * _arg1;
4538     PyObject * _argo0 = 0;
4539     PyObject * _argo1 = 0;
4540     char *_kwnames[] = { "self","attrProvider", NULL };
4541
4542     self = self;
4543     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableBase_SetAttrProvider",_kwnames,&_argo0,&_argo1))
4544         return NULL;
4545     if (_argo0) {
4546         if (_argo0 == Py_None) { _arg0 = NULL; }
4547         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4548             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetAttrProvider. Expected _wxGridTableBase_p.");
4549         return NULL;
4550         }
4551     }
4552     if (_argo1) {
4553         if (_argo1 == Py_None) { _arg1 = NULL; }
4554         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttrProvider_p")) {
4555             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetAttrProvider. Expected _wxGridCellAttrProvider_p.");
4556         return NULL;
4557         }
4558     }
4559 {
4560     wxPy_BEGIN_ALLOW_THREADS;
4561         wxGridTableBase_SetAttrProvider(_arg0,_arg1);
4562
4563     wxPy_END_ALLOW_THREADS;
4564     if (PyErr_Occurred()) return NULL;
4565 }    Py_INCREF(Py_None);
4566     _resultobj = Py_None;
4567     return _resultobj;
4568 }
4569
4570 #define wxGridTableBase_GetAttrProvider(_swigobj)  (_swigobj->GetAttrProvider())
4571 static PyObject *_wrap_wxGridTableBase_GetAttrProvider(PyObject *self, PyObject *args, PyObject *kwargs) {
4572     PyObject * _resultobj;
4573     wxGridCellAttrProvider * _result;
4574     wxGridTableBase * _arg0;
4575     PyObject * _argo0 = 0;
4576     char *_kwnames[] = { "self", NULL };
4577     char _ptemp[128];
4578
4579     self = self;
4580     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetAttrProvider",_kwnames,&_argo0))
4581         return NULL;
4582     if (_argo0) {
4583         if (_argo0 == Py_None) { _arg0 = NULL; }
4584         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4585             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetAttrProvider. Expected _wxGridTableBase_p.");
4586         return NULL;
4587         }
4588     }
4589 {
4590     wxPy_BEGIN_ALLOW_THREADS;
4591         _result = (wxGridCellAttrProvider *)wxGridTableBase_GetAttrProvider(_arg0);
4592
4593     wxPy_END_ALLOW_THREADS;
4594     if (PyErr_Occurred()) return NULL;
4595 }    if (_result) {
4596         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttrProvider_p");
4597         _resultobj = Py_BuildValue("s",_ptemp);
4598     } else {
4599         Py_INCREF(Py_None);
4600         _resultobj = Py_None;
4601     }
4602     return _resultobj;
4603 }
4604
4605 #define wxGridTableBase_SetView(_swigobj,_swigarg0)  (_swigobj->SetView(_swigarg0))
4606 static PyObject *_wrap_wxGridTableBase_SetView(PyObject *self, PyObject *args, PyObject *kwargs) {
4607     PyObject * _resultobj;
4608     wxGridTableBase * _arg0;
4609     wxGrid * _arg1;
4610     PyObject * _argo0 = 0;
4611     PyObject * _argo1 = 0;
4612     char *_kwnames[] = { "self","grid", NULL };
4613
4614     self = self;
4615     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableBase_SetView",_kwnames,&_argo0,&_argo1))
4616         return NULL;
4617     if (_argo0) {
4618         if (_argo0 == Py_None) { _arg0 = NULL; }
4619         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4620             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetView. Expected _wxGridTableBase_p.");
4621         return NULL;
4622         }
4623     }
4624     if (_argo1) {
4625         if (_argo1 == Py_None) { _arg1 = NULL; }
4626         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
4627             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetView. Expected _wxGrid_p.");
4628         return NULL;
4629         }
4630     }
4631 {
4632     wxPy_BEGIN_ALLOW_THREADS;
4633         wxGridTableBase_SetView(_arg0,_arg1);
4634
4635     wxPy_END_ALLOW_THREADS;
4636     if (PyErr_Occurred()) return NULL;
4637 }    Py_INCREF(Py_None);
4638     _resultobj = Py_None;
4639     return _resultobj;
4640 }
4641
4642 #define wxGridTableBase_GetView(_swigobj)  (_swigobj->GetView())
4643 static PyObject *_wrap_wxGridTableBase_GetView(PyObject *self, PyObject *args, PyObject *kwargs) {
4644     PyObject * _resultobj;
4645     wxGrid * _result;
4646     wxGridTableBase * _arg0;
4647     PyObject * _argo0 = 0;
4648     char *_kwnames[] = { "self", NULL };
4649
4650     self = self;
4651     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetView",_kwnames,&_argo0))
4652         return NULL;
4653     if (_argo0) {
4654         if (_argo0 == Py_None) { _arg0 = NULL; }
4655         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4656             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetView. Expected _wxGridTableBase_p.");
4657         return NULL;
4658         }
4659     }
4660 {
4661     wxPy_BEGIN_ALLOW_THREADS;
4662         _result = (wxGrid *)wxGridTableBase_GetView(_arg0);
4663
4664     wxPy_END_ALLOW_THREADS;
4665     if (PyErr_Occurred()) return NULL;
4666 }{ _resultobj = wxPyMake_wxObject(_result); }
4667     return _resultobj;
4668 }
4669
4670 #define wxGridTableBase_GetNumberRows(_swigobj)  (_swigobj->GetNumberRows())
4671 static PyObject *_wrap_wxGridTableBase_GetNumberRows(PyObject *self, PyObject *args, PyObject *kwargs) {
4672     PyObject * _resultobj;
4673     int  _result;
4674     wxGridTableBase * _arg0;
4675     PyObject * _argo0 = 0;
4676     char *_kwnames[] = { "self", NULL };
4677
4678     self = self;
4679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetNumberRows",_kwnames,&_argo0))
4680         return NULL;
4681     if (_argo0) {
4682         if (_argo0 == Py_None) { _arg0 = NULL; }
4683         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4684             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetNumberRows. Expected _wxGridTableBase_p.");
4685         return NULL;
4686         }
4687     }
4688 {
4689     wxPy_BEGIN_ALLOW_THREADS;
4690         _result = (int )wxGridTableBase_GetNumberRows(_arg0);
4691
4692     wxPy_END_ALLOW_THREADS;
4693     if (PyErr_Occurred()) return NULL;
4694 }    _resultobj = Py_BuildValue("i",_result);
4695     return _resultobj;
4696 }
4697
4698 #define wxGridTableBase_GetNumberCols(_swigobj)  (_swigobj->GetNumberCols())
4699 static PyObject *_wrap_wxGridTableBase_GetNumberCols(PyObject *self, PyObject *args, PyObject *kwargs) {
4700     PyObject * _resultobj;
4701     int  _result;
4702     wxGridTableBase * _arg0;
4703     PyObject * _argo0 = 0;
4704     char *_kwnames[] = { "self", NULL };
4705
4706     self = self;
4707     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_GetNumberCols",_kwnames,&_argo0))
4708         return NULL;
4709     if (_argo0) {
4710         if (_argo0 == Py_None) { _arg0 = NULL; }
4711         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4712             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetNumberCols. Expected _wxGridTableBase_p.");
4713         return NULL;
4714         }
4715     }
4716 {
4717     wxPy_BEGIN_ALLOW_THREADS;
4718         _result = (int )wxGridTableBase_GetNumberCols(_arg0);
4719
4720     wxPy_END_ALLOW_THREADS;
4721     if (PyErr_Occurred()) return NULL;
4722 }    _resultobj = Py_BuildValue("i",_result);
4723     return _resultobj;
4724 }
4725
4726 #define wxGridTableBase_IsEmptyCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsEmptyCell(_swigarg0,_swigarg1))
4727 static PyObject *_wrap_wxGridTableBase_IsEmptyCell(PyObject *self, PyObject *args, PyObject *kwargs) {
4728     PyObject * _resultobj;
4729     bool  _result;
4730     wxGridTableBase * _arg0;
4731     int  _arg1;
4732     int  _arg2;
4733     PyObject * _argo0 = 0;
4734     char *_kwnames[] = { "self","row","col", NULL };
4735
4736     self = self;
4737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_IsEmptyCell",_kwnames,&_argo0,&_arg1,&_arg2))
4738         return NULL;
4739     if (_argo0) {
4740         if (_argo0 == Py_None) { _arg0 = NULL; }
4741         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4742             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_IsEmptyCell. Expected _wxGridTableBase_p.");
4743         return NULL;
4744         }
4745     }
4746 {
4747     wxPy_BEGIN_ALLOW_THREADS;
4748         _result = (bool )wxGridTableBase_IsEmptyCell(_arg0,_arg1,_arg2);
4749
4750     wxPy_END_ALLOW_THREADS;
4751     if (PyErr_Occurred()) return NULL;
4752 }    _resultobj = Py_BuildValue("i",_result);
4753     return _resultobj;
4754 }
4755
4756 #define wxGridTableBase_GetValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValue(_swigarg0,_swigarg1))
4757 static PyObject *_wrap_wxGridTableBase_GetValue(PyObject *self, PyObject *args, PyObject *kwargs) {
4758     PyObject * _resultobj;
4759     wxString * _result;
4760     wxGridTableBase * _arg0;
4761     int  _arg1;
4762     int  _arg2;
4763     PyObject * _argo0 = 0;
4764     char *_kwnames[] = { "self","row","col", NULL };
4765
4766     self = self;
4767     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValue",_kwnames,&_argo0,&_arg1,&_arg2))
4768         return NULL;
4769     if (_argo0) {
4770         if (_argo0 == Py_None) { _arg0 = NULL; }
4771         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4772             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValue. Expected _wxGridTableBase_p.");
4773         return NULL;
4774         }
4775     }
4776 {
4777     wxPy_BEGIN_ALLOW_THREADS;
4778         _result = new wxString (wxGridTableBase_GetValue(_arg0,_arg1,_arg2));
4779
4780     wxPy_END_ALLOW_THREADS;
4781     if (PyErr_Occurred()) return NULL;
4782 }{
4783     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
4784 }
4785 {
4786     delete _result;
4787 }
4788     return _resultobj;
4789 }
4790
4791 #define wxGridTableBase_SetValue(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValue(_swigarg0,_swigarg1,_swigarg2))
4792 static PyObject *_wrap_wxGridTableBase_SetValue(PyObject *self, PyObject *args, PyObject *kwargs) {
4793     PyObject * _resultobj;
4794     wxGridTableBase * _arg0;
4795     int  _arg1;
4796     int  _arg2;
4797     wxString * _arg3;
4798     PyObject * _argo0 = 0;
4799     PyObject * _obj3 = 0;
4800     char *_kwnames[] = { "self","row","col","value", NULL };
4801
4802     self = self;
4803     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridTableBase_SetValue",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
4804         return NULL;
4805     if (_argo0) {
4806         if (_argo0 == Py_None) { _arg0 = NULL; }
4807         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4808             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValue. Expected _wxGridTableBase_p.");
4809         return NULL;
4810         }
4811     }
4812 {
4813 #if PYTHON_API_VERSION >= 1009
4814     char* tmpPtr; int tmpSize;
4815     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
4816         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4817         return NULL;
4818     }
4819     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
4820         return NULL;
4821     _arg3 = new wxString(tmpPtr, tmpSize);
4822 #else
4823     if (!PyString_Check(_obj3)) {
4824         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4825         return NULL;
4826     }
4827     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
4828 #endif
4829 }
4830 {
4831     wxPy_BEGIN_ALLOW_THREADS;
4832         wxGridTableBase_SetValue(_arg0,_arg1,_arg2,*_arg3);
4833
4834     wxPy_END_ALLOW_THREADS;
4835     if (PyErr_Occurred()) return NULL;
4836 }    Py_INCREF(Py_None);
4837     _resultobj = Py_None;
4838 {
4839     if (_obj3)
4840         delete _arg3;
4841 }
4842     return _resultobj;
4843 }
4844
4845 #define wxGridTableBase_GetTypeName(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetTypeName(_swigarg0,_swigarg1))
4846 static PyObject *_wrap_wxGridTableBase_GetTypeName(PyObject *self, PyObject *args, PyObject *kwargs) {
4847     PyObject * _resultobj;
4848     wxString * _result;
4849     wxGridTableBase * _arg0;
4850     int  _arg1;
4851     int  _arg2;
4852     PyObject * _argo0 = 0;
4853     char *_kwnames[] = { "self","row","col", NULL };
4854
4855     self = self;
4856     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetTypeName",_kwnames,&_argo0,&_arg1,&_arg2))
4857         return NULL;
4858     if (_argo0) {
4859         if (_argo0 == Py_None) { _arg0 = NULL; }
4860         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4861             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetTypeName. Expected _wxGridTableBase_p.");
4862         return NULL;
4863         }
4864     }
4865 {
4866     wxPy_BEGIN_ALLOW_THREADS;
4867         _result = new wxString (wxGridTableBase_GetTypeName(_arg0,_arg1,_arg2));
4868
4869     wxPy_END_ALLOW_THREADS;
4870     if (PyErr_Occurred()) return NULL;
4871 }{
4872     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
4873 }
4874 {
4875     delete _result;
4876 }
4877     return _resultobj;
4878 }
4879
4880 #define wxGridTableBase_CanGetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->CanGetValueAs(_swigarg0,_swigarg1,_swigarg2))
4881 static PyObject *_wrap_wxGridTableBase_CanGetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
4882     PyObject * _resultobj;
4883     bool  _result;
4884     wxGridTableBase * _arg0;
4885     int  _arg1;
4886     int  _arg2;
4887     wxString * _arg3;
4888     PyObject * _argo0 = 0;
4889     PyObject * _obj3 = 0;
4890     char *_kwnames[] = { "self","row","col","typeName", NULL };
4891
4892     self = self;
4893     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridTableBase_CanGetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
4894         return NULL;
4895     if (_argo0) {
4896         if (_argo0 == Py_None) { _arg0 = NULL; }
4897         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4898             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_CanGetValueAs. Expected _wxGridTableBase_p.");
4899         return NULL;
4900         }
4901     }
4902 {
4903 #if PYTHON_API_VERSION >= 1009
4904     char* tmpPtr; int tmpSize;
4905     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
4906         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4907         return NULL;
4908     }
4909     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
4910         return NULL;
4911     _arg3 = new wxString(tmpPtr, tmpSize);
4912 #else
4913     if (!PyString_Check(_obj3)) {
4914         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4915         return NULL;
4916     }
4917     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
4918 #endif
4919 }
4920 {
4921     wxPy_BEGIN_ALLOW_THREADS;
4922         _result = (bool )wxGridTableBase_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
4923
4924     wxPy_END_ALLOW_THREADS;
4925     if (PyErr_Occurred()) return NULL;
4926 }    _resultobj = Py_BuildValue("i",_result);
4927 {
4928     if (_obj3)
4929         delete _arg3;
4930 }
4931     return _resultobj;
4932 }
4933
4934 #define wxGridTableBase_CanSetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->CanSetValueAs(_swigarg0,_swigarg1,_swigarg2))
4935 static PyObject *_wrap_wxGridTableBase_CanSetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
4936     PyObject * _resultobj;
4937     bool  _result;
4938     wxGridTableBase * _arg0;
4939     int  _arg1;
4940     int  _arg2;
4941     wxString * _arg3;
4942     PyObject * _argo0 = 0;
4943     PyObject * _obj3 = 0;
4944     char *_kwnames[] = { "self","row","col","typeName", NULL };
4945
4946     self = self;
4947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridTableBase_CanSetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
4948         return NULL;
4949     if (_argo0) {
4950         if (_argo0 == Py_None) { _arg0 = NULL; }
4951         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
4952             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_CanSetValueAs. Expected _wxGridTableBase_p.");
4953         return NULL;
4954         }
4955     }
4956 {
4957 #if PYTHON_API_VERSION >= 1009
4958     char* tmpPtr; int tmpSize;
4959     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
4960         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4961         return NULL;
4962     }
4963     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
4964         return NULL;
4965     _arg3 = new wxString(tmpPtr, tmpSize);
4966 #else
4967     if (!PyString_Check(_obj3)) {
4968         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
4969         return NULL;
4970     }
4971     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
4972 #endif
4973 }
4974 {
4975     wxPy_BEGIN_ALLOW_THREADS;
4976         _result = (bool )wxGridTableBase_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
4977
4978     wxPy_END_ALLOW_THREADS;
4979     if (PyErr_Occurred()) return NULL;
4980 }    _resultobj = Py_BuildValue("i",_result);
4981 {
4982     if (_obj3)
4983         delete _arg3;
4984 }
4985     return _resultobj;
4986 }
4987
4988 #define wxGridTableBase_GetValueAsLong(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValueAsLong(_swigarg0,_swigarg1))
4989 static PyObject *_wrap_wxGridTableBase_GetValueAsLong(PyObject *self, PyObject *args, PyObject *kwargs) {
4990     PyObject * _resultobj;
4991     long  _result;
4992     wxGridTableBase * _arg0;
4993     int  _arg1;
4994     int  _arg2;
4995     PyObject * _argo0 = 0;
4996     char *_kwnames[] = { "self","row","col", NULL };
4997
4998     self = self;
4999     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValueAsLong",_kwnames,&_argo0,&_arg1,&_arg2))
5000         return NULL;
5001     if (_argo0) {
5002         if (_argo0 == Py_None) { _arg0 = NULL; }
5003         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5004             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValueAsLong. Expected _wxGridTableBase_p.");
5005         return NULL;
5006         }
5007     }
5008 {
5009     wxPy_BEGIN_ALLOW_THREADS;
5010         _result = (long )wxGridTableBase_GetValueAsLong(_arg0,_arg1,_arg2);
5011
5012     wxPy_END_ALLOW_THREADS;
5013     if (PyErr_Occurred()) return NULL;
5014 }    _resultobj = Py_BuildValue("l",_result);
5015     return _resultobj;
5016 }
5017
5018 #define wxGridTableBase_GetValueAsDouble(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValueAsDouble(_swigarg0,_swigarg1))
5019 static PyObject *_wrap_wxGridTableBase_GetValueAsDouble(PyObject *self, PyObject *args, PyObject *kwargs) {
5020     PyObject * _resultobj;
5021     double  _result;
5022     wxGridTableBase * _arg0;
5023     int  _arg1;
5024     int  _arg2;
5025     PyObject * _argo0 = 0;
5026     char *_kwnames[] = { "self","row","col", NULL };
5027
5028     self = self;
5029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValueAsDouble",_kwnames,&_argo0,&_arg1,&_arg2))
5030         return NULL;
5031     if (_argo0) {
5032         if (_argo0 == Py_None) { _arg0 = NULL; }
5033         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5034             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValueAsDouble. Expected _wxGridTableBase_p.");
5035         return NULL;
5036         }
5037     }
5038 {
5039     wxPy_BEGIN_ALLOW_THREADS;
5040         _result = (double )wxGridTableBase_GetValueAsDouble(_arg0,_arg1,_arg2);
5041
5042     wxPy_END_ALLOW_THREADS;
5043     if (PyErr_Occurred()) return NULL;
5044 }    _resultobj = Py_BuildValue("d",_result);
5045     return _resultobj;
5046 }
5047
5048 #define wxGridTableBase_GetValueAsBool(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetValueAsBool(_swigarg0,_swigarg1))
5049 static PyObject *_wrap_wxGridTableBase_GetValueAsBool(PyObject *self, PyObject *args, PyObject *kwargs) {
5050     PyObject * _resultobj;
5051     bool  _result;
5052     wxGridTableBase * _arg0;
5053     int  _arg1;
5054     int  _arg2;
5055     PyObject * _argo0 = 0;
5056     char *_kwnames[] = { "self","row","col", NULL };
5057
5058     self = self;
5059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridTableBase_GetValueAsBool",_kwnames,&_argo0,&_arg1,&_arg2))
5060         return NULL;
5061     if (_argo0) {
5062         if (_argo0 == Py_None) { _arg0 = NULL; }
5063         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5064             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetValueAsBool. Expected _wxGridTableBase_p.");
5065         return NULL;
5066         }
5067     }
5068 {
5069     wxPy_BEGIN_ALLOW_THREADS;
5070         _result = (bool )wxGridTableBase_GetValueAsBool(_arg0,_arg1,_arg2);
5071
5072     wxPy_END_ALLOW_THREADS;
5073     if (PyErr_Occurred()) return NULL;
5074 }    _resultobj = Py_BuildValue("i",_result);
5075     return _resultobj;
5076 }
5077
5078 #define wxGridTableBase_SetValueAsLong(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValueAsLong(_swigarg0,_swigarg1,_swigarg2))
5079 static PyObject *_wrap_wxGridTableBase_SetValueAsLong(PyObject *self, PyObject *args, PyObject *kwargs) {
5080     PyObject * _resultobj;
5081     wxGridTableBase * _arg0;
5082     int  _arg1;
5083     int  _arg2;
5084     long  _arg3;
5085     PyObject * _argo0 = 0;
5086     char *_kwnames[] = { "self","row","col","value", NULL };
5087
5088     self = self;
5089     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiil:wxGridTableBase_SetValueAsLong",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
5090         return NULL;
5091     if (_argo0) {
5092         if (_argo0 == Py_None) { _arg0 = NULL; }
5093         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5094             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValueAsLong. Expected _wxGridTableBase_p.");
5095         return NULL;
5096         }
5097     }
5098 {
5099     wxPy_BEGIN_ALLOW_THREADS;
5100         wxGridTableBase_SetValueAsLong(_arg0,_arg1,_arg2,_arg3);
5101
5102     wxPy_END_ALLOW_THREADS;
5103     if (PyErr_Occurred()) return NULL;
5104 }    Py_INCREF(Py_None);
5105     _resultobj = Py_None;
5106     return _resultobj;
5107 }
5108
5109 #define wxGridTableBase_SetValueAsDouble(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValueAsDouble(_swigarg0,_swigarg1,_swigarg2))
5110 static PyObject *_wrap_wxGridTableBase_SetValueAsDouble(PyObject *self, PyObject *args, PyObject *kwargs) {
5111     PyObject * _resultobj;
5112     wxGridTableBase * _arg0;
5113     int  _arg1;
5114     int  _arg2;
5115     double  _arg3;
5116     PyObject * _argo0 = 0;
5117     char *_kwnames[] = { "self","row","col","value", NULL };
5118
5119     self = self;
5120     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiid:wxGridTableBase_SetValueAsDouble",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
5121         return NULL;
5122     if (_argo0) {
5123         if (_argo0 == Py_None) { _arg0 = NULL; }
5124         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5125             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValueAsDouble. Expected _wxGridTableBase_p.");
5126         return NULL;
5127         }
5128     }
5129 {
5130     wxPy_BEGIN_ALLOW_THREADS;
5131         wxGridTableBase_SetValueAsDouble(_arg0,_arg1,_arg2,_arg3);
5132
5133     wxPy_END_ALLOW_THREADS;
5134     if (PyErr_Occurred()) return NULL;
5135 }    Py_INCREF(Py_None);
5136     _resultobj = Py_None;
5137     return _resultobj;
5138 }
5139
5140 #define wxGridTableBase_SetValueAsBool(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetValueAsBool(_swigarg0,_swigarg1,_swigarg2))
5141 static PyObject *_wrap_wxGridTableBase_SetValueAsBool(PyObject *self, PyObject *args, PyObject *kwargs) {
5142     PyObject * _resultobj;
5143     wxGridTableBase * _arg0;
5144     int  _arg1;
5145     int  _arg2;
5146     bool  _arg3;
5147     PyObject * _argo0 = 0;
5148     int tempbool3;
5149     char *_kwnames[] = { "self","row","col","value", NULL };
5150
5151     self = self;
5152     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridTableBase_SetValueAsBool",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
5153         return NULL;
5154     if (_argo0) {
5155         if (_argo0 == Py_None) { _arg0 = NULL; }
5156         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5157             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetValueAsBool. Expected _wxGridTableBase_p.");
5158         return NULL;
5159         }
5160     }
5161     _arg3 = (bool ) tempbool3;
5162 {
5163     wxPy_BEGIN_ALLOW_THREADS;
5164         wxGridTableBase_SetValueAsBool(_arg0,_arg1,_arg2,_arg3);
5165
5166     wxPy_END_ALLOW_THREADS;
5167     if (PyErr_Occurred()) return NULL;
5168 }    Py_INCREF(Py_None);
5169     _resultobj = Py_None;
5170     return _resultobj;
5171 }
5172
5173 #define wxGridTableBase_Clear(_swigobj)  (_swigobj->Clear())
5174 static PyObject *_wrap_wxGridTableBase_Clear(PyObject *self, PyObject *args, PyObject *kwargs) {
5175     PyObject * _resultobj;
5176     wxGridTableBase * _arg0;
5177     PyObject * _argo0 = 0;
5178     char *_kwnames[] = { "self", NULL };
5179
5180     self = self;
5181     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_Clear",_kwnames,&_argo0))
5182         return NULL;
5183     if (_argo0) {
5184         if (_argo0 == Py_None) { _arg0 = NULL; }
5185         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5186             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_Clear. Expected _wxGridTableBase_p.");
5187         return NULL;
5188         }
5189     }
5190 {
5191     wxPy_BEGIN_ALLOW_THREADS;
5192         wxGridTableBase_Clear(_arg0);
5193
5194     wxPy_END_ALLOW_THREADS;
5195     if (PyErr_Occurred()) return NULL;
5196 }    Py_INCREF(Py_None);
5197     _resultobj = Py_None;
5198     return _resultobj;
5199 }
5200
5201 #define wxGridTableBase_InsertRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->InsertRows(_swigarg0,_swigarg1))
5202 static PyObject *_wrap_wxGridTableBase_InsertRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5203     PyObject * _resultobj;
5204     bool  _result;
5205     wxGridTableBase * _arg0;
5206     size_t  _arg1 = (size_t ) 0;
5207     size_t  _arg2 = (size_t ) 1;
5208     PyObject * _argo0 = 0;
5209     char *_kwnames[] = { "self","pos","numRows", NULL };
5210
5211     self = self;
5212     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_InsertRows",_kwnames,&_argo0,&_arg1,&_arg2))
5213         return NULL;
5214     if (_argo0) {
5215         if (_argo0 == Py_None) { _arg0 = NULL; }
5216         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5217             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_InsertRows. Expected _wxGridTableBase_p.");
5218         return NULL;
5219         }
5220     }
5221 {
5222     wxPy_BEGIN_ALLOW_THREADS;
5223         _result = (bool )wxGridTableBase_InsertRows(_arg0,_arg1,_arg2);
5224
5225     wxPy_END_ALLOW_THREADS;
5226     if (PyErr_Occurred()) return NULL;
5227 }    _resultobj = Py_BuildValue("i",_result);
5228     return _resultobj;
5229 }
5230
5231 #define wxGridTableBase_AppendRows(_swigobj,_swigarg0)  (_swigobj->AppendRows(_swigarg0))
5232 static PyObject *_wrap_wxGridTableBase_AppendRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5233     PyObject * _resultobj;
5234     bool  _result;
5235     wxGridTableBase * _arg0;
5236     size_t  _arg1 = (size_t ) 1;
5237     PyObject * _argo0 = 0;
5238     char *_kwnames[] = { "self","numRows", NULL };
5239
5240     self = self;
5241     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGridTableBase_AppendRows",_kwnames,&_argo0,&_arg1))
5242         return NULL;
5243     if (_argo0) {
5244         if (_argo0 == Py_None) { _arg0 = NULL; }
5245         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5246             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_AppendRows. Expected _wxGridTableBase_p.");
5247         return NULL;
5248         }
5249     }
5250 {
5251     wxPy_BEGIN_ALLOW_THREADS;
5252         _result = (bool )wxGridTableBase_AppendRows(_arg0,_arg1);
5253
5254     wxPy_END_ALLOW_THREADS;
5255     if (PyErr_Occurred()) return NULL;
5256 }    _resultobj = Py_BuildValue("i",_result);
5257     return _resultobj;
5258 }
5259
5260 #define wxGridTableBase_DeleteRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->DeleteRows(_swigarg0,_swigarg1))
5261 static PyObject *_wrap_wxGridTableBase_DeleteRows(PyObject *self, PyObject *args, PyObject *kwargs) {
5262     PyObject * _resultobj;
5263     bool  _result;
5264     wxGridTableBase * _arg0;
5265     size_t  _arg1 = (size_t ) 0;
5266     size_t  _arg2 = (size_t ) 1;
5267     PyObject * _argo0 = 0;
5268     char *_kwnames[] = { "self","pos","numRows", NULL };
5269
5270     self = self;
5271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_DeleteRows",_kwnames,&_argo0,&_arg1,&_arg2))
5272         return NULL;
5273     if (_argo0) {
5274         if (_argo0 == Py_None) { _arg0 = NULL; }
5275         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5276             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_DeleteRows. Expected _wxGridTableBase_p.");
5277         return NULL;
5278         }
5279     }
5280 {
5281     wxPy_BEGIN_ALLOW_THREADS;
5282         _result = (bool )wxGridTableBase_DeleteRows(_arg0,_arg1,_arg2);
5283
5284     wxPy_END_ALLOW_THREADS;
5285     if (PyErr_Occurred()) return NULL;
5286 }    _resultobj = Py_BuildValue("i",_result);
5287     return _resultobj;
5288 }
5289
5290 #define wxGridTableBase_InsertCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->InsertCols(_swigarg0,_swigarg1))
5291 static PyObject *_wrap_wxGridTableBase_InsertCols(PyObject *self, PyObject *args, PyObject *kwargs) {
5292     PyObject * _resultobj;
5293     bool  _result;
5294     wxGridTableBase * _arg0;
5295     size_t  _arg1 = (size_t ) 0;
5296     size_t  _arg2 = (size_t ) 1;
5297     PyObject * _argo0 = 0;
5298     char *_kwnames[] = { "self","pos","numCols", NULL };
5299
5300     self = self;
5301     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_InsertCols",_kwnames,&_argo0,&_arg1,&_arg2))
5302         return NULL;
5303     if (_argo0) {
5304         if (_argo0 == Py_None) { _arg0 = NULL; }
5305         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5306             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_InsertCols. Expected _wxGridTableBase_p.");
5307         return NULL;
5308         }
5309     }
5310 {
5311     wxPy_BEGIN_ALLOW_THREADS;
5312         _result = (bool )wxGridTableBase_InsertCols(_arg0,_arg1,_arg2);
5313
5314     wxPy_END_ALLOW_THREADS;
5315     if (PyErr_Occurred()) return NULL;
5316 }    _resultobj = Py_BuildValue("i",_result);
5317     return _resultobj;
5318 }
5319
5320 #define wxGridTableBase_AppendCols(_swigobj,_swigarg0)  (_swigobj->AppendCols(_swigarg0))
5321 static PyObject *_wrap_wxGridTableBase_AppendCols(PyObject *self, PyObject *args, PyObject *kwargs) {
5322     PyObject * _resultobj;
5323     bool  _result;
5324     wxGridTableBase * _arg0;
5325     size_t  _arg1 = (size_t ) 1;
5326     PyObject * _argo0 = 0;
5327     char *_kwnames[] = { "self","numCols", NULL };
5328
5329     self = self;
5330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGridTableBase_AppendCols",_kwnames,&_argo0,&_arg1))
5331         return NULL;
5332     if (_argo0) {
5333         if (_argo0 == Py_None) { _arg0 = NULL; }
5334         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5335             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_AppendCols. Expected _wxGridTableBase_p.");
5336         return NULL;
5337         }
5338     }
5339 {
5340     wxPy_BEGIN_ALLOW_THREADS;
5341         _result = (bool )wxGridTableBase_AppendCols(_arg0,_arg1);
5342
5343     wxPy_END_ALLOW_THREADS;
5344     if (PyErr_Occurred()) return NULL;
5345 }    _resultobj = Py_BuildValue("i",_result);
5346     return _resultobj;
5347 }
5348
5349 #define wxGridTableBase_DeleteCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->DeleteCols(_swigarg0,_swigarg1))
5350 static PyObject *_wrap_wxGridTableBase_DeleteCols(PyObject *self, PyObject *args, PyObject *kwargs) {
5351     PyObject * _resultobj;
5352     bool  _result;
5353     wxGridTableBase * _arg0;
5354     size_t  _arg1 = (size_t ) 0;
5355     size_t  _arg2 = (size_t ) 1;
5356     PyObject * _argo0 = 0;
5357     char *_kwnames[] = { "self","pos","numCols", NULL };
5358
5359     self = self;
5360     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGridTableBase_DeleteCols",_kwnames,&_argo0,&_arg1,&_arg2))
5361         return NULL;
5362     if (_argo0) {
5363         if (_argo0 == Py_None) { _arg0 = NULL; }
5364         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5365             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_DeleteCols. Expected _wxGridTableBase_p.");
5366         return NULL;
5367         }
5368     }
5369 {
5370     wxPy_BEGIN_ALLOW_THREADS;
5371         _result = (bool )wxGridTableBase_DeleteCols(_arg0,_arg1,_arg2);
5372
5373     wxPy_END_ALLOW_THREADS;
5374     if (PyErr_Occurred()) return NULL;
5375 }    _resultobj = Py_BuildValue("i",_result);
5376     return _resultobj;
5377 }
5378
5379 #define wxGridTableBase_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->GetRowLabelValue(_swigarg0))
5380 static PyObject *_wrap_wxGridTableBase_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5381     PyObject * _resultobj;
5382     wxString * _result;
5383     wxGridTableBase * _arg0;
5384     int  _arg1;
5385     PyObject * _argo0 = 0;
5386     char *_kwnames[] = { "self","row", NULL };
5387
5388     self = self;
5389     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableBase_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
5390         return NULL;
5391     if (_argo0) {
5392         if (_argo0 == Py_None) { _arg0 = NULL; }
5393         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5394             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetRowLabelValue. Expected _wxGridTableBase_p.");
5395         return NULL;
5396         }
5397     }
5398 {
5399     wxPy_BEGIN_ALLOW_THREADS;
5400         _result = new wxString (wxGridTableBase_GetRowLabelValue(_arg0,_arg1));
5401
5402     wxPy_END_ALLOW_THREADS;
5403     if (PyErr_Occurred()) return NULL;
5404 }{
5405     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
5406 }
5407 {
5408     delete _result;
5409 }
5410     return _resultobj;
5411 }
5412
5413 #define wxGridTableBase_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->GetColLabelValue(_swigarg0))
5414 static PyObject *_wrap_wxGridTableBase_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5415     PyObject * _resultobj;
5416     wxString * _result;
5417     wxGridTableBase * _arg0;
5418     int  _arg1;
5419     PyObject * _argo0 = 0;
5420     char *_kwnames[] = { "self","col", NULL };
5421
5422     self = self;
5423     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableBase_GetColLabelValue",_kwnames,&_argo0,&_arg1))
5424         return NULL;
5425     if (_argo0) {
5426         if (_argo0 == Py_None) { _arg0 = NULL; }
5427         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5428             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetColLabelValue. Expected _wxGridTableBase_p.");
5429         return NULL;
5430         }
5431     }
5432 {
5433     wxPy_BEGIN_ALLOW_THREADS;
5434         _result = new wxString (wxGridTableBase_GetColLabelValue(_arg0,_arg1));
5435
5436     wxPy_END_ALLOW_THREADS;
5437     if (PyErr_Occurred()) return NULL;
5438 }{
5439     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
5440 }
5441 {
5442     delete _result;
5443 }
5444     return _resultobj;
5445 }
5446
5447 #define wxGridTableBase_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelValue(_swigarg0,_swigarg1))
5448 static PyObject *_wrap_wxGridTableBase_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5449     PyObject * _resultobj;
5450     wxGridTableBase * _arg0;
5451     int  _arg1;
5452     wxString * _arg2;
5453     PyObject * _argo0 = 0;
5454     PyObject * _obj2 = 0;
5455     char *_kwnames[] = { "self","row","value", NULL };
5456
5457     self = self;
5458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGridTableBase_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
5459         return NULL;
5460     if (_argo0) {
5461         if (_argo0 == Py_None) { _arg0 = NULL; }
5462         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5463             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetRowLabelValue. Expected _wxGridTableBase_p.");
5464         return NULL;
5465         }
5466     }
5467 {
5468 #if PYTHON_API_VERSION >= 1009
5469     char* tmpPtr; int tmpSize;
5470     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
5471         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5472         return NULL;
5473     }
5474     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
5475         return NULL;
5476     _arg2 = new wxString(tmpPtr, tmpSize);
5477 #else
5478     if (!PyString_Check(_obj2)) {
5479         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5480         return NULL;
5481     }
5482     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
5483 #endif
5484 }
5485 {
5486     wxPy_BEGIN_ALLOW_THREADS;
5487         wxGridTableBase_SetRowLabelValue(_arg0,_arg1,*_arg2);
5488
5489     wxPy_END_ALLOW_THREADS;
5490     if (PyErr_Occurred()) return NULL;
5491 }    Py_INCREF(Py_None);
5492     _resultobj = Py_None;
5493 {
5494     if (_obj2)
5495         delete _arg2;
5496 }
5497     return _resultobj;
5498 }
5499
5500 #define wxGridTableBase_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelValue(_swigarg0,_swigarg1))
5501 static PyObject *_wrap_wxGridTableBase_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
5502     PyObject * _resultobj;
5503     wxGridTableBase * _arg0;
5504     int  _arg1;
5505     wxString * _arg2;
5506     PyObject * _argo0 = 0;
5507     PyObject * _obj2 = 0;
5508     char *_kwnames[] = { "self","col","value", NULL };
5509
5510     self = self;
5511     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGridTableBase_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
5512         return NULL;
5513     if (_argo0) {
5514         if (_argo0 == Py_None) { _arg0 = NULL; }
5515         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5516             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetColLabelValue. Expected _wxGridTableBase_p.");
5517         return NULL;
5518         }
5519     }
5520 {
5521 #if PYTHON_API_VERSION >= 1009
5522     char* tmpPtr; int tmpSize;
5523     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
5524         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5525         return NULL;
5526     }
5527     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
5528         return NULL;
5529     _arg2 = new wxString(tmpPtr, tmpSize);
5530 #else
5531     if (!PyString_Check(_obj2)) {
5532         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5533         return NULL;
5534     }
5535     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
5536 #endif
5537 }
5538 {
5539     wxPy_BEGIN_ALLOW_THREADS;
5540         wxGridTableBase_SetColLabelValue(_arg0,_arg1,*_arg2);
5541
5542     wxPy_END_ALLOW_THREADS;
5543     if (PyErr_Occurred()) return NULL;
5544 }    Py_INCREF(Py_None);
5545     _resultobj = Py_None;
5546 {
5547     if (_obj2)
5548         delete _arg2;
5549 }
5550     return _resultobj;
5551 }
5552
5553 #define wxGridTableBase_CanHaveAttributes(_swigobj)  (_swigobj->CanHaveAttributes())
5554 static PyObject *_wrap_wxGridTableBase_CanHaveAttributes(PyObject *self, PyObject *args, PyObject *kwargs) {
5555     PyObject * _resultobj;
5556     bool  _result;
5557     wxGridTableBase * _arg0;
5558     PyObject * _argo0 = 0;
5559     char *_kwnames[] = { "self", NULL };
5560
5561     self = self;
5562     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableBase_CanHaveAttributes",_kwnames,&_argo0))
5563         return NULL;
5564     if (_argo0) {
5565         if (_argo0 == Py_None) { _arg0 = NULL; }
5566         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5567             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_CanHaveAttributes. Expected _wxGridTableBase_p.");
5568         return NULL;
5569         }
5570     }
5571 {
5572     wxPy_BEGIN_ALLOW_THREADS;
5573         _result = (bool )wxGridTableBase_CanHaveAttributes(_arg0);
5574
5575     wxPy_END_ALLOW_THREADS;
5576     if (PyErr_Occurred()) return NULL;
5577 }    _resultobj = Py_BuildValue("i",_result);
5578     return _resultobj;
5579 }
5580
5581 #define wxGridTableBase_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->GetAttr(_swigarg0,_swigarg1,_swigarg2))
5582 static PyObject *_wrap_wxGridTableBase_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5583     PyObject * _resultobj;
5584     wxGridCellAttr * _result;
5585     wxGridTableBase * _arg0;
5586     int  _arg1;
5587     int  _arg2;
5588     wxGridCellAttr::wxAttrKind  _arg3;
5589     PyObject * _argo0 = 0;
5590     char *_kwnames[] = { "self","row","col","kind", NULL };
5591     char _ptemp[128];
5592
5593     self = self;
5594     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxGridTableBase_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
5595         return NULL;
5596     if (_argo0) {
5597         if (_argo0 == Py_None) { _arg0 = NULL; }
5598         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5599             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_GetAttr. Expected _wxGridTableBase_p.");
5600         return NULL;
5601         }
5602     }
5603 {
5604     wxPy_BEGIN_ALLOW_THREADS;
5605         _result = (wxGridCellAttr *)wxGridTableBase_GetAttr(_arg0,_arg1,_arg2,_arg3);
5606
5607     wxPy_END_ALLOW_THREADS;
5608     if (PyErr_Occurred()) return NULL;
5609 }    if (_result) {
5610         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
5611         _resultobj = Py_BuildValue("s",_ptemp);
5612     } else {
5613         Py_INCREF(Py_None);
5614         _resultobj = Py_None;
5615     }
5616     return _resultobj;
5617 }
5618
5619 #define wxGridTableBase_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetAttr(_swigarg0,_swigarg1,_swigarg2))
5620 static PyObject *_wrap_wxGridTableBase_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5621     PyObject * _resultobj;
5622     wxGridTableBase * _arg0;
5623     wxGridCellAttr * _arg1;
5624     int  _arg2;
5625     int  _arg3;
5626     PyObject * _argo0 = 0;
5627     PyObject * _argo1 = 0;
5628     char *_kwnames[] = { "self","attr","row","col", NULL };
5629
5630     self = self;
5631     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxGridTableBase_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
5632         return NULL;
5633     if (_argo0) {
5634         if (_argo0 == Py_None) { _arg0 = NULL; }
5635         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5636             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetAttr. Expected _wxGridTableBase_p.");
5637         return NULL;
5638         }
5639     }
5640     if (_argo1) {
5641         if (_argo1 == Py_None) { _arg1 = NULL; }
5642         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
5643             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetAttr. Expected _wxGridCellAttr_p.");
5644         return NULL;
5645         }
5646     }
5647 {
5648     wxPy_BEGIN_ALLOW_THREADS;
5649         wxGridTableBase_SetAttr(_arg0,_arg1,_arg2,_arg3);
5650
5651     wxPy_END_ALLOW_THREADS;
5652     if (PyErr_Occurred()) return NULL;
5653 }    Py_INCREF(Py_None);
5654     _resultobj = Py_None;
5655     return _resultobj;
5656 }
5657
5658 #define wxGridTableBase_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
5659 static PyObject *_wrap_wxGridTableBase_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5660     PyObject * _resultobj;
5661     wxGridTableBase * _arg0;
5662     wxGridCellAttr * _arg1;
5663     int  _arg2;
5664     PyObject * _argo0 = 0;
5665     PyObject * _argo1 = 0;
5666     char *_kwnames[] = { "self","attr","row", NULL };
5667
5668     self = self;
5669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridTableBase_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
5670         return NULL;
5671     if (_argo0) {
5672         if (_argo0 == Py_None) { _arg0 = NULL; }
5673         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5674             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetRowAttr. Expected _wxGridTableBase_p.");
5675         return NULL;
5676         }
5677     }
5678     if (_argo1) {
5679         if (_argo1 == Py_None) { _arg1 = NULL; }
5680         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
5681             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetRowAttr. Expected _wxGridCellAttr_p.");
5682         return NULL;
5683         }
5684     }
5685 {
5686     wxPy_BEGIN_ALLOW_THREADS;
5687         wxGridTableBase_SetRowAttr(_arg0,_arg1,_arg2);
5688
5689     wxPy_END_ALLOW_THREADS;
5690     if (PyErr_Occurred()) return NULL;
5691 }    Py_INCREF(Py_None);
5692     _resultobj = Py_None;
5693     return _resultobj;
5694 }
5695
5696 #define wxGridTableBase_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
5697 static PyObject *_wrap_wxGridTableBase_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
5698     PyObject * _resultobj;
5699     wxGridTableBase * _arg0;
5700     wxGridCellAttr * _arg1;
5701     int  _arg2;
5702     PyObject * _argo0 = 0;
5703     PyObject * _argo1 = 0;
5704     char *_kwnames[] = { "self","attr","col", NULL };
5705
5706     self = self;
5707     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxGridTableBase_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
5708         return NULL;
5709     if (_argo0) {
5710         if (_argo0 == Py_None) { _arg0 = NULL; }
5711         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
5712             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableBase_SetColAttr. Expected _wxGridTableBase_p.");
5713         return NULL;
5714         }
5715     }
5716     if (_argo1) {
5717         if (_argo1 == Py_None) { _arg1 = NULL; }
5718         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
5719             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableBase_SetColAttr. Expected _wxGridCellAttr_p.");
5720         return NULL;
5721         }
5722     }
5723 {
5724     wxPy_BEGIN_ALLOW_THREADS;
5725         wxGridTableBase_SetColAttr(_arg0,_arg1,_arg2);
5726
5727     wxPy_END_ALLOW_THREADS;
5728     if (PyErr_Occurred()) return NULL;
5729 }    Py_INCREF(Py_None);
5730     _resultobj = Py_None;
5731     return _resultobj;
5732 }
5733
5734 static void *SwigwxPyGridTableBaseTowxGridTableBase(void *ptr) {
5735     wxPyGridTableBase *src;
5736     wxGridTableBase *dest;
5737     src = (wxPyGridTableBase *) ptr;
5738     dest = (wxGridTableBase *) src;
5739     return (void *) dest;
5740 }
5741
5742 static void *SwigwxPyGridTableBaseTowxObject(void *ptr) {
5743     wxPyGridTableBase *src;
5744     wxObject *dest;
5745     src = (wxPyGridTableBase *) ptr;
5746     dest = (wxObject *) src;
5747     return (void *) dest;
5748 }
5749
5750 #define new_wxPyGridTableBase() (new wxPyGridTableBase())
5751 static PyObject *_wrap_new_wxPyGridTableBase(PyObject *self, PyObject *args, PyObject *kwargs) {
5752     PyObject * _resultobj;
5753     wxPyGridTableBase * _result;
5754     char *_kwnames[] = {  NULL };
5755     char _ptemp[128];
5756
5757     self = self;
5758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridTableBase",_kwnames))
5759         return NULL;
5760 {
5761     wxPy_BEGIN_ALLOW_THREADS;
5762         _result = (wxPyGridTableBase *)new_wxPyGridTableBase();
5763
5764     wxPy_END_ALLOW_THREADS;
5765     if (PyErr_Occurred()) return NULL;
5766 }    if (_result) {
5767         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridTableBase_p");
5768         _resultobj = Py_BuildValue("s",_ptemp);
5769     } else {
5770         Py_INCREF(Py_None);
5771         _resultobj = Py_None;
5772     }
5773     return _resultobj;
5774 }
5775
5776 #define wxPyGridTableBase__setSelf(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setSelf(_swigarg0,_swigarg1))
5777 static PyObject *_wrap_wxPyGridTableBase__setSelf(PyObject *self, PyObject *args, PyObject *kwargs) {
5778     PyObject * _resultobj;
5779     wxPyGridTableBase * _arg0;
5780     PyObject * _arg1;
5781     PyObject * _arg2;
5782     PyObject * _argo0 = 0;
5783     PyObject * _obj1 = 0;
5784     PyObject * _obj2 = 0;
5785     char *_kwnames[] = { "self","self","_class", NULL };
5786
5787     self = self;
5788     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridTableBase__setSelf",_kwnames,&_argo0,&_obj1,&_obj2))
5789         return NULL;
5790     if (_argo0) {
5791         if (_argo0 == Py_None) { _arg0 = NULL; }
5792         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5793             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase__setSelf. Expected _wxPyGridTableBase_p.");
5794         return NULL;
5795         }
5796     }
5797 {
5798   _arg1 = _obj1;
5799 }
5800 {
5801   _arg2 = _obj2;
5802 }
5803 {
5804     wxPy_BEGIN_ALLOW_THREADS;
5805         wxPyGridTableBase__setSelf(_arg0,_arg1,_arg2);
5806
5807     wxPy_END_ALLOW_THREADS;
5808     if (PyErr_Occurred()) return NULL;
5809 }    Py_INCREF(Py_None);
5810     _resultobj = Py_None;
5811     return _resultobj;
5812 }
5813
5814 static void  wxPyGridTableBase_Destroy(wxPyGridTableBase *self) { delete self; }
5815 static PyObject *_wrap_wxPyGridTableBase_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
5816     PyObject * _resultobj;
5817     wxPyGridTableBase * _arg0;
5818     PyObject * _argo0 = 0;
5819     char *_kwnames[] = { "self", NULL };
5820
5821     self = self;
5822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridTableBase_Destroy",_kwnames,&_argo0))
5823         return NULL;
5824     if (_argo0) {
5825         if (_argo0 == Py_None) { _arg0 = NULL; }
5826         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5827             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_Destroy. Expected _wxPyGridTableBase_p.");
5828         return NULL;
5829         }
5830     }
5831 {
5832     wxPy_BEGIN_ALLOW_THREADS;
5833         wxPyGridTableBase_Destroy(_arg0);
5834
5835     wxPy_END_ALLOW_THREADS;
5836     if (PyErr_Occurred()) return NULL;
5837 }    Py_INCREF(Py_None);
5838     _resultobj = Py_None;
5839     return _resultobj;
5840 }
5841
5842 #define wxPyGridTableBase_base_GetTypeName(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_GetTypeName(_swigarg0,_swigarg1))
5843 static PyObject *_wrap_wxPyGridTableBase_base_GetTypeName(PyObject *self, PyObject *args, PyObject *kwargs) {
5844     PyObject * _resultobj;
5845     wxString * _result;
5846     wxPyGridTableBase * _arg0;
5847     int  _arg1;
5848     int  _arg2;
5849     PyObject * _argo0 = 0;
5850     char *_kwnames[] = { "self","row","col", NULL };
5851
5852     self = self;
5853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxPyGridTableBase_base_GetTypeName",_kwnames,&_argo0,&_arg1,&_arg2))
5854         return NULL;
5855     if (_argo0) {
5856         if (_argo0 == Py_None) { _arg0 = NULL; }
5857         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5858             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetTypeName. Expected _wxPyGridTableBase_p.");
5859         return NULL;
5860         }
5861     }
5862 {
5863     wxPy_BEGIN_ALLOW_THREADS;
5864         _result = new wxString (wxPyGridTableBase_base_GetTypeName(_arg0,_arg1,_arg2));
5865
5866     wxPy_END_ALLOW_THREADS;
5867     if (PyErr_Occurred()) return NULL;
5868 }{
5869     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
5870 }
5871 {
5872     delete _result;
5873 }
5874     return _resultobj;
5875 }
5876
5877 #define wxPyGridTableBase_base_CanGetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_CanGetValueAs(_swigarg0,_swigarg1,_swigarg2))
5878 static PyObject *_wrap_wxPyGridTableBase_base_CanGetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
5879     PyObject * _resultobj;
5880     bool  _result;
5881     wxPyGridTableBase * _arg0;
5882     int  _arg1;
5883     int  _arg2;
5884     wxString * _arg3;
5885     PyObject * _argo0 = 0;
5886     PyObject * _obj3 = 0;
5887     char *_kwnames[] = { "self","row","col","typeName", NULL };
5888
5889     self = self;
5890     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxPyGridTableBase_base_CanGetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
5891         return NULL;
5892     if (_argo0) {
5893         if (_argo0 == Py_None) { _arg0 = NULL; }
5894         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5895             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_CanGetValueAs. Expected _wxPyGridTableBase_p.");
5896         return NULL;
5897         }
5898     }
5899 {
5900 #if PYTHON_API_VERSION >= 1009
5901     char* tmpPtr; int tmpSize;
5902     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
5903         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5904         return NULL;
5905     }
5906     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
5907         return NULL;
5908     _arg3 = new wxString(tmpPtr, tmpSize);
5909 #else
5910     if (!PyString_Check(_obj3)) {
5911         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5912         return NULL;
5913     }
5914     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
5915 #endif
5916 }
5917 {
5918     wxPy_BEGIN_ALLOW_THREADS;
5919         _result = (bool )wxPyGridTableBase_base_CanGetValueAs(_arg0,_arg1,_arg2,*_arg3);
5920
5921     wxPy_END_ALLOW_THREADS;
5922     if (PyErr_Occurred()) return NULL;
5923 }    _resultobj = Py_BuildValue("i",_result);
5924 {
5925     if (_obj3)
5926         delete _arg3;
5927 }
5928     return _resultobj;
5929 }
5930
5931 #define wxPyGridTableBase_base_CanSetValueAs(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_CanSetValueAs(_swigarg0,_swigarg1,_swigarg2))
5932 static PyObject *_wrap_wxPyGridTableBase_base_CanSetValueAs(PyObject *self, PyObject *args, PyObject *kwargs) {
5933     PyObject * _resultobj;
5934     bool  _result;
5935     wxPyGridTableBase * _arg0;
5936     int  _arg1;
5937     int  _arg2;
5938     wxString * _arg3;
5939     PyObject * _argo0 = 0;
5940     PyObject * _obj3 = 0;
5941     char *_kwnames[] = { "self","row","col","typeName", NULL };
5942
5943     self = self;
5944     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxPyGridTableBase_base_CanSetValueAs",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
5945         return NULL;
5946     if (_argo0) {
5947         if (_argo0 == Py_None) { _arg0 = NULL; }
5948         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5949             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_CanSetValueAs. Expected _wxPyGridTableBase_p.");
5950         return NULL;
5951         }
5952     }
5953 {
5954 #if PYTHON_API_VERSION >= 1009
5955     char* tmpPtr; int tmpSize;
5956     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
5957         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5958         return NULL;
5959     }
5960     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
5961         return NULL;
5962     _arg3 = new wxString(tmpPtr, tmpSize);
5963 #else
5964     if (!PyString_Check(_obj3)) {
5965         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
5966         return NULL;
5967     }
5968     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
5969 #endif
5970 }
5971 {
5972     wxPy_BEGIN_ALLOW_THREADS;
5973         _result = (bool )wxPyGridTableBase_base_CanSetValueAs(_arg0,_arg1,_arg2,*_arg3);
5974
5975     wxPy_END_ALLOW_THREADS;
5976     if (PyErr_Occurred()) return NULL;
5977 }    _resultobj = Py_BuildValue("i",_result);
5978 {
5979     if (_obj3)
5980         delete _arg3;
5981 }
5982     return _resultobj;
5983 }
5984
5985 #define wxPyGridTableBase_base_Clear(_swigobj)  (_swigobj->base_Clear())
5986 static PyObject *_wrap_wxPyGridTableBase_base_Clear(PyObject *self, PyObject *args, PyObject *kwargs) {
5987     PyObject * _resultobj;
5988     wxPyGridTableBase * _arg0;
5989     PyObject * _argo0 = 0;
5990     char *_kwnames[] = { "self", NULL };
5991
5992     self = self;
5993     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridTableBase_base_Clear",_kwnames,&_argo0))
5994         return NULL;
5995     if (_argo0) {
5996         if (_argo0 == Py_None) { _arg0 = NULL; }
5997         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
5998             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_Clear. Expected _wxPyGridTableBase_p.");
5999         return NULL;
6000         }
6001     }
6002 {
6003     wxPy_BEGIN_ALLOW_THREADS;
6004         wxPyGridTableBase_base_Clear(_arg0);
6005
6006     wxPy_END_ALLOW_THREADS;
6007     if (PyErr_Occurred()) return NULL;
6008 }    Py_INCREF(Py_None);
6009     _resultobj = Py_None;
6010     return _resultobj;
6011 }
6012
6013 #define wxPyGridTableBase_base_InsertRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_InsertRows(_swigarg0,_swigarg1))
6014 static PyObject *_wrap_wxPyGridTableBase_base_InsertRows(PyObject *self, PyObject *args, PyObject *kwargs) {
6015     PyObject * _resultobj;
6016     bool  _result;
6017     wxPyGridTableBase * _arg0;
6018     size_t  _arg1 = (size_t ) 0;
6019     size_t  _arg2 = (size_t ) 1;
6020     PyObject * _argo0 = 0;
6021     char *_kwnames[] = { "self","pos","numRows", NULL };
6022
6023     self = self;
6024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_InsertRows",_kwnames,&_argo0,&_arg1,&_arg2))
6025         return NULL;
6026     if (_argo0) {
6027         if (_argo0 == Py_None) { _arg0 = NULL; }
6028         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6029             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_InsertRows. Expected _wxPyGridTableBase_p.");
6030         return NULL;
6031         }
6032     }
6033 {
6034     wxPy_BEGIN_ALLOW_THREADS;
6035         _result = (bool )wxPyGridTableBase_base_InsertRows(_arg0,_arg1,_arg2);
6036
6037     wxPy_END_ALLOW_THREADS;
6038     if (PyErr_Occurred()) return NULL;
6039 }    _resultobj = Py_BuildValue("i",_result);
6040     return _resultobj;
6041 }
6042
6043 #define wxPyGridTableBase_base_AppendRows(_swigobj,_swigarg0)  (_swigobj->base_AppendRows(_swigarg0))
6044 static PyObject *_wrap_wxPyGridTableBase_base_AppendRows(PyObject *self, PyObject *args, PyObject *kwargs) {
6045     PyObject * _resultobj;
6046     bool  _result;
6047     wxPyGridTableBase * _arg0;
6048     size_t  _arg1 = (size_t ) 1;
6049     PyObject * _argo0 = 0;
6050     char *_kwnames[] = { "self","numRows", NULL };
6051
6052     self = self;
6053     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxPyGridTableBase_base_AppendRows",_kwnames,&_argo0,&_arg1))
6054         return NULL;
6055     if (_argo0) {
6056         if (_argo0 == Py_None) { _arg0 = NULL; }
6057         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6058             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_AppendRows. Expected _wxPyGridTableBase_p.");
6059         return NULL;
6060         }
6061     }
6062 {
6063     wxPy_BEGIN_ALLOW_THREADS;
6064         _result = (bool )wxPyGridTableBase_base_AppendRows(_arg0,_arg1);
6065
6066     wxPy_END_ALLOW_THREADS;
6067     if (PyErr_Occurred()) return NULL;
6068 }    _resultobj = Py_BuildValue("i",_result);
6069     return _resultobj;
6070 }
6071
6072 #define wxPyGridTableBase_base_DeleteRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DeleteRows(_swigarg0,_swigarg1))
6073 static PyObject *_wrap_wxPyGridTableBase_base_DeleteRows(PyObject *self, PyObject *args, PyObject *kwargs) {
6074     PyObject * _resultobj;
6075     bool  _result;
6076     wxPyGridTableBase * _arg0;
6077     size_t  _arg1 = (size_t ) 0;
6078     size_t  _arg2 = (size_t ) 1;
6079     PyObject * _argo0 = 0;
6080     char *_kwnames[] = { "self","pos","numRows", NULL };
6081
6082     self = self;
6083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_DeleteRows",_kwnames,&_argo0,&_arg1,&_arg2))
6084         return NULL;
6085     if (_argo0) {
6086         if (_argo0 == Py_None) { _arg0 = NULL; }
6087         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6088             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_DeleteRows. Expected _wxPyGridTableBase_p.");
6089         return NULL;
6090         }
6091     }
6092 {
6093     wxPy_BEGIN_ALLOW_THREADS;
6094         _result = (bool )wxPyGridTableBase_base_DeleteRows(_arg0,_arg1,_arg2);
6095
6096     wxPy_END_ALLOW_THREADS;
6097     if (PyErr_Occurred()) return NULL;
6098 }    _resultobj = Py_BuildValue("i",_result);
6099     return _resultobj;
6100 }
6101
6102 #define wxPyGridTableBase_base_InsertCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_InsertCols(_swigarg0,_swigarg1))
6103 static PyObject *_wrap_wxPyGridTableBase_base_InsertCols(PyObject *self, PyObject *args, PyObject *kwargs) {
6104     PyObject * _resultobj;
6105     bool  _result;
6106     wxPyGridTableBase * _arg0;
6107     size_t  _arg1 = (size_t ) 0;
6108     size_t  _arg2 = (size_t ) 1;
6109     PyObject * _argo0 = 0;
6110     char *_kwnames[] = { "self","pos","numCols", NULL };
6111
6112     self = self;
6113     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_InsertCols",_kwnames,&_argo0,&_arg1,&_arg2))
6114         return NULL;
6115     if (_argo0) {
6116         if (_argo0 == Py_None) { _arg0 = NULL; }
6117         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6118             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_InsertCols. Expected _wxPyGridTableBase_p.");
6119         return NULL;
6120         }
6121     }
6122 {
6123     wxPy_BEGIN_ALLOW_THREADS;
6124         _result = (bool )wxPyGridTableBase_base_InsertCols(_arg0,_arg1,_arg2);
6125
6126     wxPy_END_ALLOW_THREADS;
6127     if (PyErr_Occurred()) return NULL;
6128 }    _resultobj = Py_BuildValue("i",_result);
6129     return _resultobj;
6130 }
6131
6132 #define wxPyGridTableBase_base_AppendCols(_swigobj,_swigarg0)  (_swigobj->base_AppendCols(_swigarg0))
6133 static PyObject *_wrap_wxPyGridTableBase_base_AppendCols(PyObject *self, PyObject *args, PyObject *kwargs) {
6134     PyObject * _resultobj;
6135     bool  _result;
6136     wxPyGridTableBase * _arg0;
6137     size_t  _arg1 = (size_t ) 1;
6138     PyObject * _argo0 = 0;
6139     char *_kwnames[] = { "self","numCols", NULL };
6140
6141     self = self;
6142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxPyGridTableBase_base_AppendCols",_kwnames,&_argo0,&_arg1))
6143         return NULL;
6144     if (_argo0) {
6145         if (_argo0 == Py_None) { _arg0 = NULL; }
6146         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6147             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_AppendCols. Expected _wxPyGridTableBase_p.");
6148         return NULL;
6149         }
6150     }
6151 {
6152     wxPy_BEGIN_ALLOW_THREADS;
6153         _result = (bool )wxPyGridTableBase_base_AppendCols(_arg0,_arg1);
6154
6155     wxPy_END_ALLOW_THREADS;
6156     if (PyErr_Occurred()) return NULL;
6157 }    _resultobj = Py_BuildValue("i",_result);
6158     return _resultobj;
6159 }
6160
6161 #define wxPyGridTableBase_base_DeleteCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_DeleteCols(_swigarg0,_swigarg1))
6162 static PyObject *_wrap_wxPyGridTableBase_base_DeleteCols(PyObject *self, PyObject *args, PyObject *kwargs) {
6163     PyObject * _resultobj;
6164     bool  _result;
6165     wxPyGridTableBase * _arg0;
6166     size_t  _arg1 = (size_t ) 0;
6167     size_t  _arg2 = (size_t ) 1;
6168     PyObject * _argo0 = 0;
6169     char *_kwnames[] = { "self","pos","numCols", NULL };
6170
6171     self = self;
6172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxPyGridTableBase_base_DeleteCols",_kwnames,&_argo0,&_arg1,&_arg2))
6173         return NULL;
6174     if (_argo0) {
6175         if (_argo0 == Py_None) { _arg0 = NULL; }
6176         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6177             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_DeleteCols. Expected _wxPyGridTableBase_p.");
6178         return NULL;
6179         }
6180     }
6181 {
6182     wxPy_BEGIN_ALLOW_THREADS;
6183         _result = (bool )wxPyGridTableBase_base_DeleteCols(_arg0,_arg1,_arg2);
6184
6185     wxPy_END_ALLOW_THREADS;
6186     if (PyErr_Occurred()) return NULL;
6187 }    _resultobj = Py_BuildValue("i",_result);
6188     return _resultobj;
6189 }
6190
6191 #define wxPyGridTableBase_base_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->base_GetRowLabelValue(_swigarg0))
6192 static PyObject *_wrap_wxPyGridTableBase_base_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6193     PyObject * _resultobj;
6194     wxString * _result;
6195     wxPyGridTableBase * _arg0;
6196     int  _arg1;
6197     PyObject * _argo0 = 0;
6198     char *_kwnames[] = { "self","row", NULL };
6199
6200     self = self;
6201     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxPyGridTableBase_base_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
6202         return NULL;
6203     if (_argo0) {
6204         if (_argo0 == Py_None) { _arg0 = NULL; }
6205         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6206             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetRowLabelValue. Expected _wxPyGridTableBase_p.");
6207         return NULL;
6208         }
6209     }
6210 {
6211     wxPy_BEGIN_ALLOW_THREADS;
6212         _result = new wxString (wxPyGridTableBase_base_GetRowLabelValue(_arg0,_arg1));
6213
6214     wxPy_END_ALLOW_THREADS;
6215     if (PyErr_Occurred()) return NULL;
6216 }{
6217     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
6218 }
6219 {
6220     delete _result;
6221 }
6222     return _resultobj;
6223 }
6224
6225 #define wxPyGridTableBase_base_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->base_GetColLabelValue(_swigarg0))
6226 static PyObject *_wrap_wxPyGridTableBase_base_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6227     PyObject * _resultobj;
6228     wxString * _result;
6229     wxPyGridTableBase * _arg0;
6230     int  _arg1;
6231     PyObject * _argo0 = 0;
6232     char *_kwnames[] = { "self","col", NULL };
6233
6234     self = self;
6235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxPyGridTableBase_base_GetColLabelValue",_kwnames,&_argo0,&_arg1))
6236         return NULL;
6237     if (_argo0) {
6238         if (_argo0 == Py_None) { _arg0 = NULL; }
6239         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6240             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetColLabelValue. Expected _wxPyGridTableBase_p.");
6241         return NULL;
6242         }
6243     }
6244 {
6245     wxPy_BEGIN_ALLOW_THREADS;
6246         _result = new wxString (wxPyGridTableBase_base_GetColLabelValue(_arg0,_arg1));
6247
6248     wxPy_END_ALLOW_THREADS;
6249     if (PyErr_Occurred()) return NULL;
6250 }{
6251     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
6252 }
6253 {
6254     delete _result;
6255 }
6256     return _resultobj;
6257 }
6258
6259 #define wxPyGridTableBase_base_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetRowLabelValue(_swigarg0,_swigarg1))
6260 static PyObject *_wrap_wxPyGridTableBase_base_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6261     PyObject * _resultobj;
6262     wxPyGridTableBase * _arg0;
6263     int  _arg1;
6264     wxString * _arg2;
6265     PyObject * _argo0 = 0;
6266     PyObject * _obj2 = 0;
6267     char *_kwnames[] = { "self","row","value", NULL };
6268
6269     self = self;
6270     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxPyGridTableBase_base_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
6271         return NULL;
6272     if (_argo0) {
6273         if (_argo0 == Py_None) { _arg0 = NULL; }
6274         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6275             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetRowLabelValue. Expected _wxPyGridTableBase_p.");
6276         return NULL;
6277         }
6278     }
6279 {
6280 #if PYTHON_API_VERSION >= 1009
6281     char* tmpPtr; int tmpSize;
6282     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
6283         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6284         return NULL;
6285     }
6286     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
6287         return NULL;
6288     _arg2 = new wxString(tmpPtr, tmpSize);
6289 #else
6290     if (!PyString_Check(_obj2)) {
6291         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6292         return NULL;
6293     }
6294     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
6295 #endif
6296 }
6297 {
6298     wxPy_BEGIN_ALLOW_THREADS;
6299         wxPyGridTableBase_base_SetRowLabelValue(_arg0,_arg1,*_arg2);
6300
6301     wxPy_END_ALLOW_THREADS;
6302     if (PyErr_Occurred()) return NULL;
6303 }    Py_INCREF(Py_None);
6304     _resultobj = Py_None;
6305 {
6306     if (_obj2)
6307         delete _arg2;
6308 }
6309     return _resultobj;
6310 }
6311
6312 #define wxPyGridTableBase_base_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetColLabelValue(_swigarg0,_swigarg1))
6313 static PyObject *_wrap_wxPyGridTableBase_base_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
6314     PyObject * _resultobj;
6315     wxPyGridTableBase * _arg0;
6316     int  _arg1;
6317     wxString * _arg2;
6318     PyObject * _argo0 = 0;
6319     PyObject * _obj2 = 0;
6320     char *_kwnames[] = { "self","col","value", NULL };
6321
6322     self = self;
6323     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxPyGridTableBase_base_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
6324         return NULL;
6325     if (_argo0) {
6326         if (_argo0 == Py_None) { _arg0 = NULL; }
6327         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6328             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetColLabelValue. Expected _wxPyGridTableBase_p.");
6329         return NULL;
6330         }
6331     }
6332 {
6333 #if PYTHON_API_VERSION >= 1009
6334     char* tmpPtr; int tmpSize;
6335     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
6336         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6337         return NULL;
6338     }
6339     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
6340         return NULL;
6341     _arg2 = new wxString(tmpPtr, tmpSize);
6342 #else
6343     if (!PyString_Check(_obj2)) {
6344         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
6345         return NULL;
6346     }
6347     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
6348 #endif
6349 }
6350 {
6351     wxPy_BEGIN_ALLOW_THREADS;
6352         wxPyGridTableBase_base_SetColLabelValue(_arg0,_arg1,*_arg2);
6353
6354     wxPy_END_ALLOW_THREADS;
6355     if (PyErr_Occurred()) return NULL;
6356 }    Py_INCREF(Py_None);
6357     _resultobj = Py_None;
6358 {
6359     if (_obj2)
6360         delete _arg2;
6361 }
6362     return _resultobj;
6363 }
6364
6365 #define wxPyGridTableBase_base_CanHaveAttributes(_swigobj)  (_swigobj->base_CanHaveAttributes())
6366 static PyObject *_wrap_wxPyGridTableBase_base_CanHaveAttributes(PyObject *self, PyObject *args, PyObject *kwargs) {
6367     PyObject * _resultobj;
6368     bool  _result;
6369     wxPyGridTableBase * _arg0;
6370     PyObject * _argo0 = 0;
6371     char *_kwnames[] = { "self", NULL };
6372
6373     self = self;
6374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridTableBase_base_CanHaveAttributes",_kwnames,&_argo0))
6375         return NULL;
6376     if (_argo0) {
6377         if (_argo0 == Py_None) { _arg0 = NULL; }
6378         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6379             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_CanHaveAttributes. Expected _wxPyGridTableBase_p.");
6380         return NULL;
6381         }
6382     }
6383 {
6384     wxPy_BEGIN_ALLOW_THREADS;
6385         _result = (bool )wxPyGridTableBase_base_CanHaveAttributes(_arg0);
6386
6387     wxPy_END_ALLOW_THREADS;
6388     if (PyErr_Occurred()) return NULL;
6389 }    _resultobj = Py_BuildValue("i",_result);
6390     return _resultobj;
6391 }
6392
6393 #define wxPyGridTableBase_base_GetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_GetAttr(_swigarg0,_swigarg1,_swigarg2))
6394 static PyObject *_wrap_wxPyGridTableBase_base_GetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6395     PyObject * _resultobj;
6396     wxGridCellAttr * _result;
6397     wxPyGridTableBase * _arg0;
6398     int  _arg1;
6399     int  _arg2;
6400     wxGridCellAttr::wxAttrKind  _arg3;
6401     PyObject * _argo0 = 0;
6402     char *_kwnames[] = { "self","row","col","kind", NULL };
6403     char _ptemp[128];
6404
6405     self = self;
6406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiii:wxPyGridTableBase_base_GetAttr",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
6407         return NULL;
6408     if (_argo0) {
6409         if (_argo0 == Py_None) { _arg0 = NULL; }
6410         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6411             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_GetAttr. Expected _wxPyGridTableBase_p.");
6412         return NULL;
6413         }
6414     }
6415 {
6416     wxPy_BEGIN_ALLOW_THREADS;
6417         _result = (wxGridCellAttr *)wxPyGridTableBase_base_GetAttr(_arg0,_arg1,_arg2,_arg3);
6418
6419     wxPy_END_ALLOW_THREADS;
6420     if (PyErr_Occurred()) return NULL;
6421 }    if (_result) {
6422         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
6423         _resultobj = Py_BuildValue("s",_ptemp);
6424     } else {
6425         Py_INCREF(Py_None);
6426         _resultobj = Py_None;
6427     }
6428     return _resultobj;
6429 }
6430
6431 #define wxPyGridTableBase_base_SetAttr(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->base_SetAttr(_swigarg0,_swigarg1,_swigarg2))
6432 static PyObject *_wrap_wxPyGridTableBase_base_SetAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6433     PyObject * _resultobj;
6434     wxPyGridTableBase * _arg0;
6435     wxGridCellAttr * _arg1;
6436     int  _arg2;
6437     int  _arg3;
6438     PyObject * _argo0 = 0;
6439     PyObject * _argo1 = 0;
6440     char *_kwnames[] = { "self","attr","row","col", NULL };
6441
6442     self = self;
6443     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOii:wxPyGridTableBase_base_SetAttr",_kwnames,&_argo0,&_argo1,&_arg2,&_arg3))
6444         return NULL;
6445     if (_argo0) {
6446         if (_argo0 == Py_None) { _arg0 = NULL; }
6447         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6448             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetAttr. Expected _wxPyGridTableBase_p.");
6449         return NULL;
6450         }
6451     }
6452     if (_argo1) {
6453         if (_argo1 == Py_None) { _arg1 = NULL; }
6454         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
6455             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridTableBase_base_SetAttr. Expected _wxGridCellAttr_p.");
6456         return NULL;
6457         }
6458     }
6459 {
6460     wxPy_BEGIN_ALLOW_THREADS;
6461         wxPyGridTableBase_base_SetAttr(_arg0,_arg1,_arg2,_arg3);
6462
6463     wxPy_END_ALLOW_THREADS;
6464     if (PyErr_Occurred()) return NULL;
6465 }    Py_INCREF(Py_None);
6466     _resultobj = Py_None;
6467     return _resultobj;
6468 }
6469
6470 #define wxPyGridTableBase_base_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetRowAttr(_swigarg0,_swigarg1))
6471 static PyObject *_wrap_wxPyGridTableBase_base_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6472     PyObject * _resultobj;
6473     wxPyGridTableBase * _arg0;
6474     wxGridCellAttr * _arg1;
6475     int  _arg2;
6476     PyObject * _argo0 = 0;
6477     PyObject * _argo1 = 0;
6478     char *_kwnames[] = { "self","attr","row", NULL };
6479
6480     self = self;
6481     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridTableBase_base_SetRowAttr",_kwnames,&_argo0,&_argo1,&_arg2))
6482         return NULL;
6483     if (_argo0) {
6484         if (_argo0 == Py_None) { _arg0 = NULL; }
6485         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6486             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetRowAttr. Expected _wxPyGridTableBase_p.");
6487         return NULL;
6488         }
6489     }
6490     if (_argo1) {
6491         if (_argo1 == Py_None) { _arg1 = NULL; }
6492         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
6493             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridTableBase_base_SetRowAttr. Expected _wxGridCellAttr_p.");
6494         return NULL;
6495         }
6496     }
6497 {
6498     wxPy_BEGIN_ALLOW_THREADS;
6499         wxPyGridTableBase_base_SetRowAttr(_arg0,_arg1,_arg2);
6500
6501     wxPy_END_ALLOW_THREADS;
6502     if (PyErr_Occurred()) return NULL;
6503 }    Py_INCREF(Py_None);
6504     _resultobj = Py_None;
6505     return _resultobj;
6506 }
6507
6508 #define wxPyGridTableBase_base_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_SetColAttr(_swigarg0,_swigarg1))
6509 static PyObject *_wrap_wxPyGridTableBase_base_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
6510     PyObject * _resultobj;
6511     wxPyGridTableBase * _arg0;
6512     wxGridCellAttr * _arg1;
6513     int  _arg2;
6514     PyObject * _argo0 = 0;
6515     PyObject * _argo1 = 0;
6516     char *_kwnames[] = { "self","attr","col", NULL };
6517
6518     self = self;
6519     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOi:wxPyGridTableBase_base_SetColAttr",_kwnames,&_argo0,&_argo1,&_arg2))
6520         return NULL;
6521     if (_argo0) {
6522         if (_argo0 == Py_None) { _arg0 = NULL; }
6523         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridTableBase_p")) {
6524             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridTableBase_base_SetColAttr. Expected _wxPyGridTableBase_p.");
6525         return NULL;
6526         }
6527     }
6528     if (_argo1) {
6529         if (_argo1 == Py_None) { _arg1 = NULL; }
6530         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
6531             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridTableBase_base_SetColAttr. Expected _wxGridCellAttr_p.");
6532         return NULL;
6533         }
6534     }
6535 {
6536     wxPy_BEGIN_ALLOW_THREADS;
6537         wxPyGridTableBase_base_SetColAttr(_arg0,_arg1,_arg2);
6538
6539     wxPy_END_ALLOW_THREADS;
6540     if (PyErr_Occurred()) return NULL;
6541 }    Py_INCREF(Py_None);
6542     _resultobj = Py_None;
6543     return _resultobj;
6544 }
6545
6546 static void *SwigwxGridStringTableTowxGridTableBase(void *ptr) {
6547     wxGridStringTable *src;
6548     wxGridTableBase *dest;
6549     src = (wxGridStringTable *) ptr;
6550     dest = (wxGridTableBase *) src;
6551     return (void *) dest;
6552 }
6553
6554 static void *SwigwxGridStringTableTowxObject(void *ptr) {
6555     wxGridStringTable *src;
6556     wxObject *dest;
6557     src = (wxGridStringTable *) ptr;
6558     dest = (wxObject *) src;
6559     return (void *) dest;
6560 }
6561
6562 #define new_wxGridStringTable(_swigarg0,_swigarg1) (new wxGridStringTable(_swigarg0,_swigarg1))
6563 static PyObject *_wrap_new_wxGridStringTable(PyObject *self, PyObject *args, PyObject *kwargs) {
6564     PyObject * _resultobj;
6565     wxGridStringTable * _result;
6566     int  _arg0 = (int ) 0;
6567     int  _arg1 = (int ) 0;
6568     char *_kwnames[] = { "numRows","numCols", NULL };
6569     char _ptemp[128];
6570
6571     self = self;
6572     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridStringTable",_kwnames,&_arg0,&_arg1))
6573         return NULL;
6574 {
6575     wxPy_BEGIN_ALLOW_THREADS;
6576         _result = (wxGridStringTable *)new_wxGridStringTable(_arg0,_arg1);
6577
6578     wxPy_END_ALLOW_THREADS;
6579     if (PyErr_Occurred()) return NULL;
6580 }    if (_result) {
6581         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridStringTable_p");
6582         _resultobj = Py_BuildValue("s",_ptemp);
6583     } else {
6584         Py_INCREF(Py_None);
6585         _resultobj = Py_None;
6586     }
6587     return _resultobj;
6588 }
6589
6590 #define new_wxGridTableMessage(_swigarg0,_swigarg1,_swigarg2,_swigarg3) (new wxGridTableMessage(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
6591 static PyObject *_wrap_new_wxGridTableMessage(PyObject *self, PyObject *args, PyObject *kwargs) {
6592     PyObject * _resultobj;
6593     wxGridTableMessage * _result;
6594     wxGridTableBase * _arg0;
6595     int  _arg1;
6596     int  _arg2 = (int ) -1;
6597     int  _arg3 = (int ) -1;
6598     PyObject * _argo0 = 0;
6599     char *_kwnames[] = { "table","id","comInt1","comInt2", NULL };
6600     char _ptemp[128];
6601
6602     self = self;
6603     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|ii:new_wxGridTableMessage",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
6604         return NULL;
6605     if (_argo0) {
6606         if (_argo0 == Py_None) { _arg0 = NULL; }
6607         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableBase_p")) {
6608             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGridTableMessage. Expected _wxGridTableBase_p.");
6609         return NULL;
6610         }
6611     }
6612 {
6613     wxPy_BEGIN_ALLOW_THREADS;
6614         _result = (wxGridTableMessage *)new_wxGridTableMessage(_arg0,_arg1,_arg2,_arg3);
6615
6616     wxPy_END_ALLOW_THREADS;
6617     if (PyErr_Occurred()) return NULL;
6618 }    if (_result) {
6619         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridTableMessage_p");
6620         _resultobj = Py_BuildValue("s",_ptemp);
6621     } else {
6622         Py_INCREF(Py_None);
6623         _resultobj = Py_None;
6624     }
6625     return _resultobj;
6626 }
6627
6628 #define delete_wxGridTableMessage(_swigobj) (delete _swigobj)
6629 static PyObject *_wrap_delete_wxGridTableMessage(PyObject *self, PyObject *args, PyObject *kwargs) {
6630     PyObject * _resultobj;
6631     wxGridTableMessage * _arg0;
6632     PyObject * _argo0 = 0;
6633     char *_kwnames[] = { "self", NULL };
6634
6635     self = self;
6636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxGridTableMessage",_kwnames,&_argo0))
6637         return NULL;
6638     if (_argo0) {
6639         if (_argo0 == Py_None) { _arg0 = NULL; }
6640         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6641             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGridTableMessage. Expected _wxGridTableMessage_p.");
6642         return NULL;
6643         }
6644     }
6645 {
6646     wxPy_BEGIN_ALLOW_THREADS;
6647         delete_wxGridTableMessage(_arg0);
6648
6649     wxPy_END_ALLOW_THREADS;
6650     if (PyErr_Occurred()) return NULL;
6651 }    Py_INCREF(Py_None);
6652     _resultobj = Py_None;
6653     return _resultobj;
6654 }
6655
6656 #define wxGridTableMessage_SetTableObject(_swigobj,_swigarg0)  (_swigobj->SetTableObject(_swigarg0))
6657 static PyObject *_wrap_wxGridTableMessage_SetTableObject(PyObject *self, PyObject *args, PyObject *kwargs) {
6658     PyObject * _resultobj;
6659     wxGridTableMessage * _arg0;
6660     wxGridTableBase * _arg1;
6661     PyObject * _argo0 = 0;
6662     PyObject * _argo1 = 0;
6663     char *_kwnames[] = { "self","table", NULL };
6664
6665     self = self;
6666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridTableMessage_SetTableObject",_kwnames,&_argo0,&_argo1))
6667         return NULL;
6668     if (_argo0) {
6669         if (_argo0 == Py_None) { _arg0 = NULL; }
6670         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6671             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetTableObject. Expected _wxGridTableMessage_p.");
6672         return NULL;
6673         }
6674     }
6675     if (_argo1) {
6676         if (_argo1 == Py_None) { _arg1 = NULL; }
6677         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridTableBase_p")) {
6678             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridTableMessage_SetTableObject. Expected _wxGridTableBase_p.");
6679         return NULL;
6680         }
6681     }
6682 {
6683     wxPy_BEGIN_ALLOW_THREADS;
6684         wxGridTableMessage_SetTableObject(_arg0,_arg1);
6685
6686     wxPy_END_ALLOW_THREADS;
6687     if (PyErr_Occurred()) return NULL;
6688 }    Py_INCREF(Py_None);
6689     _resultobj = Py_None;
6690     return _resultobj;
6691 }
6692
6693 #define wxGridTableMessage_GetTableObject(_swigobj)  (_swigobj->GetTableObject())
6694 static PyObject *_wrap_wxGridTableMessage_GetTableObject(PyObject *self, PyObject *args, PyObject *kwargs) {
6695     PyObject * _resultobj;
6696     wxGridTableBase * _result;
6697     wxGridTableMessage * _arg0;
6698     PyObject * _argo0 = 0;
6699     char *_kwnames[] = { "self", NULL };
6700
6701     self = self;
6702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetTableObject",_kwnames,&_argo0))
6703         return NULL;
6704     if (_argo0) {
6705         if (_argo0 == Py_None) { _arg0 = NULL; }
6706         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6707             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetTableObject. Expected _wxGridTableMessage_p.");
6708         return NULL;
6709         }
6710     }
6711 {
6712     wxPy_BEGIN_ALLOW_THREADS;
6713         _result = (wxGridTableBase *)wxGridTableMessage_GetTableObject(_arg0);
6714
6715     wxPy_END_ALLOW_THREADS;
6716     if (PyErr_Occurred()) return NULL;
6717 }{ _resultobj = wxPyMake_wxObject(_result); }
6718     return _resultobj;
6719 }
6720
6721 #define wxGridTableMessage_SetId(_swigobj,_swigarg0)  (_swigobj->SetId(_swigarg0))
6722 static PyObject *_wrap_wxGridTableMessage_SetId(PyObject *self, PyObject *args, PyObject *kwargs) {
6723     PyObject * _resultobj;
6724     wxGridTableMessage * _arg0;
6725     int  _arg1;
6726     PyObject * _argo0 = 0;
6727     char *_kwnames[] = { "self","id", NULL };
6728
6729     self = self;
6730     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableMessage_SetId",_kwnames,&_argo0,&_arg1))
6731         return NULL;
6732     if (_argo0) {
6733         if (_argo0 == Py_None) { _arg0 = NULL; }
6734         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6735             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetId. Expected _wxGridTableMessage_p.");
6736         return NULL;
6737         }
6738     }
6739 {
6740     wxPy_BEGIN_ALLOW_THREADS;
6741         wxGridTableMessage_SetId(_arg0,_arg1);
6742
6743     wxPy_END_ALLOW_THREADS;
6744     if (PyErr_Occurred()) return NULL;
6745 }    Py_INCREF(Py_None);
6746     _resultobj = Py_None;
6747     return _resultobj;
6748 }
6749
6750 #define wxGridTableMessage_GetId(_swigobj)  (_swigobj->GetId())
6751 static PyObject *_wrap_wxGridTableMessage_GetId(PyObject *self, PyObject *args, PyObject *kwargs) {
6752     PyObject * _resultobj;
6753     int  _result;
6754     wxGridTableMessage * _arg0;
6755     PyObject * _argo0 = 0;
6756     char *_kwnames[] = { "self", NULL };
6757
6758     self = self;
6759     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetId",_kwnames,&_argo0))
6760         return NULL;
6761     if (_argo0) {
6762         if (_argo0 == Py_None) { _arg0 = NULL; }
6763         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6764             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetId. Expected _wxGridTableMessage_p.");
6765         return NULL;
6766         }
6767     }
6768 {
6769     wxPy_BEGIN_ALLOW_THREADS;
6770         _result = (int )wxGridTableMessage_GetId(_arg0);
6771
6772     wxPy_END_ALLOW_THREADS;
6773     if (PyErr_Occurred()) return NULL;
6774 }    _resultobj = Py_BuildValue("i",_result);
6775     return _resultobj;
6776 }
6777
6778 #define wxGridTableMessage_SetCommandInt(_swigobj,_swigarg0)  (_swigobj->SetCommandInt(_swigarg0))
6779 static PyObject *_wrap_wxGridTableMessage_SetCommandInt(PyObject *self, PyObject *args, PyObject *kwargs) {
6780     PyObject * _resultobj;
6781     wxGridTableMessage * _arg0;
6782     int  _arg1;
6783     PyObject * _argo0 = 0;
6784     char *_kwnames[] = { "self","comInt1", NULL };
6785
6786     self = self;
6787     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableMessage_SetCommandInt",_kwnames,&_argo0,&_arg1))
6788         return NULL;
6789     if (_argo0) {
6790         if (_argo0 == Py_None) { _arg0 = NULL; }
6791         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6792             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetCommandInt. Expected _wxGridTableMessage_p.");
6793         return NULL;
6794         }
6795     }
6796 {
6797     wxPy_BEGIN_ALLOW_THREADS;
6798         wxGridTableMessage_SetCommandInt(_arg0,_arg1);
6799
6800     wxPy_END_ALLOW_THREADS;
6801     if (PyErr_Occurred()) return NULL;
6802 }    Py_INCREF(Py_None);
6803     _resultobj = Py_None;
6804     return _resultobj;
6805 }
6806
6807 #define wxGridTableMessage_GetCommandInt(_swigobj)  (_swigobj->GetCommandInt())
6808 static PyObject *_wrap_wxGridTableMessage_GetCommandInt(PyObject *self, PyObject *args, PyObject *kwargs) {
6809     PyObject * _resultobj;
6810     int  _result;
6811     wxGridTableMessage * _arg0;
6812     PyObject * _argo0 = 0;
6813     char *_kwnames[] = { "self", NULL };
6814
6815     self = self;
6816     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetCommandInt",_kwnames,&_argo0))
6817         return NULL;
6818     if (_argo0) {
6819         if (_argo0 == Py_None) { _arg0 = NULL; }
6820         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6821             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetCommandInt. Expected _wxGridTableMessage_p.");
6822         return NULL;
6823         }
6824     }
6825 {
6826     wxPy_BEGIN_ALLOW_THREADS;
6827         _result = (int )wxGridTableMessage_GetCommandInt(_arg0);
6828
6829     wxPy_END_ALLOW_THREADS;
6830     if (PyErr_Occurred()) return NULL;
6831 }    _resultobj = Py_BuildValue("i",_result);
6832     return _resultobj;
6833 }
6834
6835 #define wxGridTableMessage_SetCommandInt2(_swigobj,_swigarg0)  (_swigobj->SetCommandInt2(_swigarg0))
6836 static PyObject *_wrap_wxGridTableMessage_SetCommandInt2(PyObject *self, PyObject *args, PyObject *kwargs) {
6837     PyObject * _resultobj;
6838     wxGridTableMessage * _arg0;
6839     int  _arg1;
6840     PyObject * _argo0 = 0;
6841     char *_kwnames[] = { "self","comInt2", NULL };
6842
6843     self = self;
6844     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridTableMessage_SetCommandInt2",_kwnames,&_argo0,&_arg1))
6845         return NULL;
6846     if (_argo0) {
6847         if (_argo0 == Py_None) { _arg0 = NULL; }
6848         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6849             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_SetCommandInt2. Expected _wxGridTableMessage_p.");
6850         return NULL;
6851         }
6852     }
6853 {
6854     wxPy_BEGIN_ALLOW_THREADS;
6855         wxGridTableMessage_SetCommandInt2(_arg0,_arg1);
6856
6857     wxPy_END_ALLOW_THREADS;
6858     if (PyErr_Occurred()) return NULL;
6859 }    Py_INCREF(Py_None);
6860     _resultobj = Py_None;
6861     return _resultobj;
6862 }
6863
6864 #define wxGridTableMessage_GetCommandInt2(_swigobj)  (_swigobj->GetCommandInt2())
6865 static PyObject *_wrap_wxGridTableMessage_GetCommandInt2(PyObject *self, PyObject *args, PyObject *kwargs) {
6866     PyObject * _resultobj;
6867     int  _result;
6868     wxGridTableMessage * _arg0;
6869     PyObject * _argo0 = 0;
6870     char *_kwnames[] = { "self", NULL };
6871
6872     self = self;
6873     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridTableMessage_GetCommandInt2",_kwnames,&_argo0))
6874         return NULL;
6875     if (_argo0) {
6876         if (_argo0 == Py_None) { _arg0 = NULL; }
6877         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridTableMessage_p")) {
6878             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridTableMessage_GetCommandInt2. Expected _wxGridTableMessage_p.");
6879         return NULL;
6880         }
6881     }
6882 {
6883     wxPy_BEGIN_ALLOW_THREADS;
6884         _result = (int )wxGridTableMessage_GetCommandInt2(_arg0);
6885
6886     wxPy_END_ALLOW_THREADS;
6887     if (PyErr_Occurred()) return NULL;
6888 }    _resultobj = Py_BuildValue("i",_result);
6889     return _resultobj;
6890 }
6891
6892 #define new_wxGridCellCoords(_swigarg0,_swigarg1) (new wxGridCellCoords(_swigarg0,_swigarg1))
6893 static PyObject *_wrap_new_wxGridCellCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
6894     PyObject * _resultobj;
6895     wxGridCellCoords * _result;
6896     int  _arg0 = (int ) -1;
6897     int  _arg1 = (int ) -1;
6898     char *_kwnames[] = { "r","c", NULL };
6899     char _ptemp[128];
6900
6901     self = self;
6902     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellCoords",_kwnames,&_arg0,&_arg1))
6903         return NULL;
6904 {
6905     wxPy_BEGIN_ALLOW_THREADS;
6906         _result = (wxGridCellCoords *)new_wxGridCellCoords(_arg0,_arg1);
6907
6908     wxPy_END_ALLOW_THREADS;
6909     if (PyErr_Occurred()) return NULL;
6910 }    if (_result) {
6911         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
6912         _resultobj = Py_BuildValue("s",_ptemp);
6913     } else {
6914         Py_INCREF(Py_None);
6915         _resultobj = Py_None;
6916     }
6917     return _resultobj;
6918 }
6919
6920 #define delete_wxGridCellCoords(_swigobj) (delete _swigobj)
6921 static PyObject *_wrap_delete_wxGridCellCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
6922     PyObject * _resultobj;
6923     wxGridCellCoords * _arg0;
6924     PyObject * _argo0 = 0;
6925     char *_kwnames[] = { "self", NULL };
6926
6927     self = self;
6928     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:delete_wxGridCellCoords",_kwnames,&_argo0))
6929         return NULL;
6930     if (_argo0) {
6931         if (_argo0 == Py_None) { _arg0 = NULL; }
6932         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
6933             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of delete_wxGridCellCoords. Expected _wxGridCellCoords_p.");
6934         return NULL;
6935         }
6936     }
6937 {
6938     wxPy_BEGIN_ALLOW_THREADS;
6939         delete_wxGridCellCoords(_arg0);
6940
6941     wxPy_END_ALLOW_THREADS;
6942     if (PyErr_Occurred()) return NULL;
6943 }    Py_INCREF(Py_None);
6944     _resultobj = Py_None;
6945     return _resultobj;
6946 }
6947
6948 #define wxGridCellCoords_GetRow(_swigobj)  (_swigobj->GetRow())
6949 static PyObject *_wrap_wxGridCellCoords_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
6950     PyObject * _resultobj;
6951     int  _result;
6952     wxGridCellCoords * _arg0;
6953     PyObject * _argo0 = 0;
6954     char *_kwnames[] = { "self", NULL };
6955
6956     self = self;
6957     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellCoords_GetRow",_kwnames,&_argo0))
6958         return NULL;
6959     if (_argo0) {
6960         if (_argo0 == Py_None) { _arg0 = NULL; }
6961         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
6962             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_GetRow. Expected _wxGridCellCoords_p.");
6963         return NULL;
6964         }
6965     }
6966 {
6967     wxPy_BEGIN_ALLOW_THREADS;
6968         _result = (int )wxGridCellCoords_GetRow(_arg0);
6969
6970     wxPy_END_ALLOW_THREADS;
6971     if (PyErr_Occurred()) return NULL;
6972 }    _resultobj = Py_BuildValue("i",_result);
6973     return _resultobj;
6974 }
6975
6976 #define wxGridCellCoords_SetRow(_swigobj,_swigarg0)  (_swigobj->SetRow(_swigarg0))
6977 static PyObject *_wrap_wxGridCellCoords_SetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
6978     PyObject * _resultobj;
6979     wxGridCellCoords * _arg0;
6980     int  _arg1;
6981     PyObject * _argo0 = 0;
6982     char *_kwnames[] = { "self","n", NULL };
6983
6984     self = self;
6985     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellCoords_SetRow",_kwnames,&_argo0,&_arg1))
6986         return NULL;
6987     if (_argo0) {
6988         if (_argo0 == Py_None) { _arg0 = NULL; }
6989         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
6990             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_SetRow. Expected _wxGridCellCoords_p.");
6991         return NULL;
6992         }
6993     }
6994 {
6995     wxPy_BEGIN_ALLOW_THREADS;
6996         wxGridCellCoords_SetRow(_arg0,_arg1);
6997
6998     wxPy_END_ALLOW_THREADS;
6999     if (PyErr_Occurred()) return NULL;
7000 }    Py_INCREF(Py_None);
7001     _resultobj = Py_None;
7002     return _resultobj;
7003 }
7004
7005 #define wxGridCellCoords_GetCol(_swigobj)  (_swigobj->GetCol())
7006 static PyObject *_wrap_wxGridCellCoords_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
7007     PyObject * _resultobj;
7008     int  _result;
7009     wxGridCellCoords * _arg0;
7010     PyObject * _argo0 = 0;
7011     char *_kwnames[] = { "self", NULL };
7012
7013     self = self;
7014     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellCoords_GetCol",_kwnames,&_argo0))
7015         return NULL;
7016     if (_argo0) {
7017         if (_argo0 == Py_None) { _arg0 = NULL; }
7018         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7019             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_GetCol. Expected _wxGridCellCoords_p.");
7020         return NULL;
7021         }
7022     }
7023 {
7024     wxPy_BEGIN_ALLOW_THREADS;
7025         _result = (int )wxGridCellCoords_GetCol(_arg0);
7026
7027     wxPy_END_ALLOW_THREADS;
7028     if (PyErr_Occurred()) return NULL;
7029 }    _resultobj = Py_BuildValue("i",_result);
7030     return _resultobj;
7031 }
7032
7033 #define wxGridCellCoords_SetCol(_swigobj,_swigarg0)  (_swigobj->SetCol(_swigarg0))
7034 static PyObject *_wrap_wxGridCellCoords_SetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
7035     PyObject * _resultobj;
7036     wxGridCellCoords * _arg0;
7037     int  _arg1;
7038     PyObject * _argo0 = 0;
7039     char *_kwnames[] = { "self","n", NULL };
7040
7041     self = self;
7042     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellCoords_SetCol",_kwnames,&_argo0,&_arg1))
7043         return NULL;
7044     if (_argo0) {
7045         if (_argo0 == Py_None) { _arg0 = NULL; }
7046         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7047             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_SetCol. Expected _wxGridCellCoords_p.");
7048         return NULL;
7049         }
7050     }
7051 {
7052     wxPy_BEGIN_ALLOW_THREADS;
7053         wxGridCellCoords_SetCol(_arg0,_arg1);
7054
7055     wxPy_END_ALLOW_THREADS;
7056     if (PyErr_Occurred()) return NULL;
7057 }    Py_INCREF(Py_None);
7058     _resultobj = Py_None;
7059     return _resultobj;
7060 }
7061
7062 #define wxGridCellCoords_Set(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Set(_swigarg0,_swigarg1))
7063 static PyObject *_wrap_wxGridCellCoords_Set(PyObject *self, PyObject *args, PyObject *kwargs) {
7064     PyObject * _resultobj;
7065     wxGridCellCoords * _arg0;
7066     int  _arg1;
7067     int  _arg2;
7068     PyObject * _argo0 = 0;
7069     char *_kwnames[] = { "self","row","col", NULL };
7070
7071     self = self;
7072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellCoords_Set",_kwnames,&_argo0,&_arg1,&_arg2))
7073         return NULL;
7074     if (_argo0) {
7075         if (_argo0 == Py_None) { _arg0 = NULL; }
7076         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7077             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_Set. Expected _wxGridCellCoords_p.");
7078         return NULL;
7079         }
7080     }
7081 {
7082     wxPy_BEGIN_ALLOW_THREADS;
7083         wxGridCellCoords_Set(_arg0,_arg1,_arg2);
7084
7085     wxPy_END_ALLOW_THREADS;
7086     if (PyErr_Occurred()) return NULL;
7087 }    Py_INCREF(Py_None);
7088     _resultobj = Py_None;
7089     return _resultobj;
7090 }
7091
7092 static PyObject * wxGridCellCoords_asTuple(wxGridCellCoords *self) {
7093             PyObject* tup = PyTuple_New(2);
7094             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
7095             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
7096             return tup;
7097         }
7098 static PyObject *_wrap_wxGridCellCoords_asTuple(PyObject *self, PyObject *args, PyObject *kwargs) {
7099     PyObject * _resultobj;
7100     PyObject * _result;
7101     wxGridCellCoords * _arg0;
7102     PyObject * _argo0 = 0;
7103     char *_kwnames[] = { "self", NULL };
7104
7105     self = self;
7106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellCoords_asTuple",_kwnames,&_argo0))
7107         return NULL;
7108     if (_argo0) {
7109         if (_argo0 == Py_None) { _arg0 = NULL; }
7110         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7111             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords_asTuple. Expected _wxGridCellCoords_p.");
7112         return NULL;
7113         }
7114     }
7115 {
7116     wxPy_BEGIN_ALLOW_THREADS;
7117         _result = (PyObject *)wxGridCellCoords_asTuple(_arg0);
7118
7119     wxPy_END_ALLOW_THREADS;
7120     if (PyErr_Occurred()) return NULL;
7121 }{
7122   _resultobj = _result;
7123 }
7124     return _resultobj;
7125 }
7126
7127 static int  wxGridCellCoords___cmp__(wxGridCellCoords *self,const wxGridCellCoords & other) {
7128             return *self != other;
7129         }
7130 static PyObject *_wrap_wxGridCellCoords___cmp__(PyObject *self, PyObject *args, PyObject *kwargs) {
7131     PyObject * _resultobj;
7132     int  _result;
7133     wxGridCellCoords * _arg0;
7134     wxGridCellCoords * _arg1;
7135     PyObject * _argo0 = 0;
7136     PyObject * _argo1 = 0;
7137     char *_kwnames[] = { "self","other", NULL };
7138
7139     self = self;
7140     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellCoords___cmp__",_kwnames,&_argo0,&_argo1))
7141         return NULL;
7142     if (_argo0) {
7143         if (_argo0 == Py_None) { _arg0 = NULL; }
7144         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellCoords_p")) {
7145             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellCoords___cmp__. Expected _wxGridCellCoords_p.");
7146         return NULL;
7147         }
7148     }
7149     if (_argo1) {
7150         if (_argo1 == Py_None) { _arg1 = NULL; }
7151         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellCoords_p")) {
7152             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellCoords___cmp__. Expected _wxGridCellCoords_p.");
7153         return NULL;
7154         }
7155     }
7156 {
7157     wxPy_BEGIN_ALLOW_THREADS;
7158         _result = (int )wxGridCellCoords___cmp__(_arg0,*_arg1);
7159
7160     wxPy_END_ALLOW_THREADS;
7161     if (PyErr_Occurred()) return NULL;
7162 }    _resultobj = Py_BuildValue("i",_result);
7163     return _resultobj;
7164 }
7165
7166 static void *SwigwxGridTowxScrolledWindow(void *ptr) {
7167     wxGrid *src;
7168     wxScrolledWindow *dest;
7169     src = (wxGrid *) ptr;
7170     dest = (wxScrolledWindow *) src;
7171     return (void *) dest;
7172 }
7173
7174 static void *SwigwxGridTowxPanel(void *ptr) {
7175     wxGrid *src;
7176     wxPanel *dest;
7177     src = (wxGrid *) ptr;
7178     dest = (wxPanel *) src;
7179     return (void *) dest;
7180 }
7181
7182 static void *SwigwxGridTowxWindow(void *ptr) {
7183     wxGrid *src;
7184     wxWindow *dest;
7185     src = (wxGrid *) ptr;
7186     dest = (wxWindow *) src;
7187     return (void *) dest;
7188 }
7189
7190 static void *SwigwxGridTowxEvtHandler(void *ptr) {
7191     wxGrid *src;
7192     wxEvtHandler *dest;
7193     src = (wxGrid *) ptr;
7194     dest = (wxEvtHandler *) src;
7195     return (void *) dest;
7196 }
7197
7198 static void *SwigwxGridTowxObject(void *ptr) {
7199     wxGrid *src;
7200     wxObject *dest;
7201     src = (wxGrid *) ptr;
7202     dest = (wxObject *) src;
7203     return (void *) dest;
7204 }
7205
7206 #define new_wxGrid(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (new wxGrid(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
7207 static PyObject *_wrap_new_wxGrid(PyObject *self, PyObject *args, PyObject *kwargs) {
7208     PyObject * _resultobj;
7209     wxGrid * _result;
7210     wxWindow * _arg0;
7211     wxWindowID  _arg1;
7212     wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
7213     wxSize * _arg3 = (wxSize *) &wxDefaultSize;
7214     long  _arg4 = (long ) wxWANTS_CHARS;
7215     char * _arg5 = (char *) wxPanelNameStr;
7216     PyObject * _argo0 = 0;
7217     wxPoint  temp;
7218     PyObject * _obj2 = 0;
7219     wxSize  temp0;
7220     PyObject * _obj3 = 0;
7221     char *_kwnames[] = { "parent","id","pos","size","style","name", NULL };
7222     char _ptemp[128];
7223
7224     self = self;
7225     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOls:new_wxGrid",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4,&_arg5))
7226         return NULL;
7227     if (_argo0) {
7228         if (_argo0 == Py_None) { _arg0 = NULL; }
7229         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
7230             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxGrid. Expected _wxWindow_p.");
7231         return NULL;
7232         }
7233     }
7234     if (_obj2)
7235 {
7236     _arg2 = &temp;
7237     if (! wxPoint_helper(_obj2, &_arg2))
7238         return NULL;
7239 }
7240     if (_obj3)
7241 {
7242     _arg3 = &temp0;
7243     if (! wxSize_helper(_obj3, &_arg3))
7244         return NULL;
7245 }
7246 {
7247     wxPy_BEGIN_ALLOW_THREADS;
7248         _result = (wxGrid *)new_wxGrid(_arg0,_arg1,*_arg2,*_arg3,_arg4,_arg5);
7249
7250     wxPy_END_ALLOW_THREADS;
7251     if (PyErr_Occurred()) return NULL;
7252 }    if (_result) {
7253         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGrid_p");
7254         _resultobj = Py_BuildValue("s",_ptemp);
7255     } else {
7256         Py_INCREF(Py_None);
7257         _resultobj = Py_None;
7258     }
7259     return _resultobj;
7260 }
7261
7262 #define wxGrid_CreateGrid(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->CreateGrid(_swigarg0,_swigarg1,_swigarg2))
7263 static PyObject *_wrap_wxGrid_CreateGrid(PyObject *self, PyObject *args, PyObject *kwargs) {
7264     PyObject * _resultobj;
7265     bool  _result;
7266     wxGrid * _arg0;
7267     int  _arg1;
7268     int  _arg2;
7269     WXGRIDSELECTIONMODES  _arg3 = (WXGRIDSELECTIONMODES ) wxGrid::wxGridSelectCells;
7270     PyObject * _argo0 = 0;
7271     char *_kwnames[] = { "self","numRows","numCols","selmode", NULL };
7272
7273     self = self;
7274     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_CreateGrid",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
7275         return NULL;
7276     if (_argo0) {
7277         if (_argo0 == Py_None) { _arg0 = NULL; }
7278         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7279             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CreateGrid. Expected _wxGrid_p.");
7280         return NULL;
7281         }
7282     }
7283 {
7284     wxPy_BEGIN_ALLOW_THREADS;
7285         _result = (bool )wxGrid_CreateGrid(_arg0,_arg1,_arg2,_arg3);
7286
7287     wxPy_END_ALLOW_THREADS;
7288     if (PyErr_Occurred()) return NULL;
7289 }    _resultobj = Py_BuildValue("i",_result);
7290     return _resultobj;
7291 }
7292
7293 #define wxGrid_SetSelectionMode(_swigobj,_swigarg0)  (_swigobj->SetSelectionMode(_swigarg0))
7294 static PyObject *_wrap_wxGrid_SetSelectionMode(PyObject *self, PyObject *args, PyObject *kwargs) {
7295     PyObject * _resultobj;
7296     wxGrid * _arg0;
7297     WXGRIDSELECTIONMODES  _arg1;
7298     PyObject * _argo0 = 0;
7299     char *_kwnames[] = { "self","selmode", NULL };
7300
7301     self = self;
7302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetSelectionMode",_kwnames,&_argo0,&_arg1))
7303         return NULL;
7304     if (_argo0) {
7305         if (_argo0 == Py_None) { _arg0 = NULL; }
7306         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7307             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionMode. Expected _wxGrid_p.");
7308         return NULL;
7309         }
7310     }
7311 {
7312     wxPy_BEGIN_ALLOW_THREADS;
7313         wxGrid_SetSelectionMode(_arg0,_arg1);
7314
7315     wxPy_END_ALLOW_THREADS;
7316     if (PyErr_Occurred()) return NULL;
7317 }    Py_INCREF(Py_None);
7318     _resultobj = Py_None;
7319     return _resultobj;
7320 }
7321
7322 #define wxGrid_GetNumberRows(_swigobj)  (_swigobj->GetNumberRows())
7323 static PyObject *_wrap_wxGrid_GetNumberRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7324     PyObject * _resultobj;
7325     int  _result;
7326     wxGrid * _arg0;
7327     PyObject * _argo0 = 0;
7328     char *_kwnames[] = { "self", NULL };
7329
7330     self = self;
7331     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetNumberRows",_kwnames,&_argo0))
7332         return NULL;
7333     if (_argo0) {
7334         if (_argo0 == Py_None) { _arg0 = NULL; }
7335         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7336             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetNumberRows. Expected _wxGrid_p.");
7337         return NULL;
7338         }
7339     }
7340 {
7341     wxPy_BEGIN_ALLOW_THREADS;
7342         _result = (int )wxGrid_GetNumberRows(_arg0);
7343
7344     wxPy_END_ALLOW_THREADS;
7345     if (PyErr_Occurred()) return NULL;
7346 }    _resultobj = Py_BuildValue("i",_result);
7347     return _resultobj;
7348 }
7349
7350 #define wxGrid_GetNumberCols(_swigobj)  (_swigobj->GetNumberCols())
7351 static PyObject *_wrap_wxGrid_GetNumberCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7352     PyObject * _resultobj;
7353     int  _result;
7354     wxGrid * _arg0;
7355     PyObject * _argo0 = 0;
7356     char *_kwnames[] = { "self", NULL };
7357
7358     self = self;
7359     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetNumberCols",_kwnames,&_argo0))
7360         return NULL;
7361     if (_argo0) {
7362         if (_argo0 == Py_None) { _arg0 = NULL; }
7363         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7364             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetNumberCols. Expected _wxGrid_p.");
7365         return NULL;
7366         }
7367     }
7368 {
7369     wxPy_BEGIN_ALLOW_THREADS;
7370         _result = (int )wxGrid_GetNumberCols(_arg0);
7371
7372     wxPy_END_ALLOW_THREADS;
7373     if (PyErr_Occurred()) return NULL;
7374 }    _resultobj = Py_BuildValue("i",_result);
7375     return _resultobj;
7376 }
7377
7378 #define wxGrid_ProcessTableMessage(_swigobj,_swigarg0)  (_swigobj->ProcessTableMessage(_swigarg0))
7379 static PyObject *_wrap_wxGrid_ProcessTableMessage(PyObject *self, PyObject *args, PyObject *kwargs) {
7380     PyObject * _resultobj;
7381     bool  _result;
7382     wxGrid * _arg0;
7383     wxGridTableMessage * _arg1;
7384     PyObject * _argo0 = 0;
7385     PyObject * _argo1 = 0;
7386     char *_kwnames[] = { "self","arg2", NULL };
7387
7388     self = self;
7389     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_ProcessTableMessage",_kwnames,&_argo0,&_argo1))
7390         return NULL;
7391     if (_argo0) {
7392         if (_argo0 == Py_None) { _arg0 = NULL; }
7393         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7394             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ProcessTableMessage. Expected _wxGrid_p.");
7395         return NULL;
7396         }
7397     }
7398     if (_argo1) {
7399         if (_argo1 == Py_None) { _arg1 = NULL; }
7400         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridTableMessage_p")) {
7401             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_ProcessTableMessage. Expected _wxGridTableMessage_p.");
7402         return NULL;
7403         }
7404     }
7405 {
7406     wxPy_BEGIN_ALLOW_THREADS;
7407         _result = (bool )wxGrid_ProcessTableMessage(_arg0,*_arg1);
7408
7409     wxPy_END_ALLOW_THREADS;
7410     if (PyErr_Occurred()) return NULL;
7411 }    _resultobj = Py_BuildValue("i",_result);
7412     return _resultobj;
7413 }
7414
7415 #define wxGrid_GetTable(_swigobj)  (_swigobj->GetTable())
7416 static PyObject *_wrap_wxGrid_GetTable(PyObject *self, PyObject *args, PyObject *kwargs) {
7417     PyObject * _resultobj;
7418     wxGridTableBase * _result;
7419     wxGrid * _arg0;
7420     PyObject * _argo0 = 0;
7421     char *_kwnames[] = { "self", NULL };
7422
7423     self = self;
7424     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetTable",_kwnames,&_argo0))
7425         return NULL;
7426     if (_argo0) {
7427         if (_argo0 == Py_None) { _arg0 = NULL; }
7428         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7429             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetTable. Expected _wxGrid_p.");
7430         return NULL;
7431         }
7432     }
7433 {
7434     wxPy_BEGIN_ALLOW_THREADS;
7435         _result = (wxGridTableBase *)wxGrid_GetTable(_arg0);
7436
7437     wxPy_END_ALLOW_THREADS;
7438     if (PyErr_Occurred()) return NULL;
7439 }{ _resultobj = wxPyMake_wxObject(_result); }
7440     return _resultobj;
7441 }
7442
7443 #define wxGrid_SetTable(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetTable(_swigarg0,_swigarg1,_swigarg2))
7444 static PyObject *_wrap_wxGrid_SetTable(PyObject *self, PyObject *args, PyObject *kwargs) {
7445     PyObject * _resultobj;
7446     bool  _result;
7447     wxGrid * _arg0;
7448     wxGridTableBase * _arg1;
7449     bool  _arg2 = (bool ) FALSE;
7450     WXGRIDSELECTIONMODES  _arg3 = (WXGRIDSELECTIONMODES ) wxGrid::wxGridSelectCells;
7451     PyObject * _argo0 = 0;
7452     PyObject * _argo1 = 0;
7453     int tempbool2 = (int) FALSE;
7454     char *_kwnames[] = { "self","table","takeOwnership","selmode", NULL };
7455
7456     self = self;
7457     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO|ii:wxGrid_SetTable",_kwnames,&_argo0,&_argo1,&tempbool2,&_arg3))
7458         return NULL;
7459     if (_argo0) {
7460         if (_argo0 == Py_None) { _arg0 = NULL; }
7461         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7462             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetTable. Expected _wxGrid_p.");
7463         return NULL;
7464         }
7465     }
7466     if (_argo1) {
7467         if (_argo1 == Py_None) { _arg1 = NULL; }
7468         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridTableBase_p")) {
7469             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetTable. Expected _wxGridTableBase_p.");
7470         return NULL;
7471         }
7472     }
7473     _arg2 = (bool ) tempbool2;
7474 {
7475     wxPy_BEGIN_ALLOW_THREADS;
7476         _result = (bool )wxGrid_SetTable(_arg0,_arg1,_arg2,_arg3);
7477
7478     wxPy_END_ALLOW_THREADS;
7479     if (PyErr_Occurred()) return NULL;
7480 }    _resultobj = Py_BuildValue("i",_result);
7481     return _resultobj;
7482 }
7483
7484 #define wxGrid_ClearGrid(_swigobj)  (_swigobj->ClearGrid())
7485 static PyObject *_wrap_wxGrid_ClearGrid(PyObject *self, PyObject *args, PyObject *kwargs) {
7486     PyObject * _resultobj;
7487     wxGrid * _arg0;
7488     PyObject * _argo0 = 0;
7489     char *_kwnames[] = { "self", NULL };
7490
7491     self = self;
7492     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ClearGrid",_kwnames,&_argo0))
7493         return NULL;
7494     if (_argo0) {
7495         if (_argo0 == Py_None) { _arg0 = NULL; }
7496         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7497             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ClearGrid. Expected _wxGrid_p.");
7498         return NULL;
7499         }
7500     }
7501 {
7502     wxPy_BEGIN_ALLOW_THREADS;
7503         wxGrid_ClearGrid(_arg0);
7504
7505     wxPy_END_ALLOW_THREADS;
7506     if (PyErr_Occurred()) return NULL;
7507 }    Py_INCREF(Py_None);
7508     _resultobj = Py_None;
7509     return _resultobj;
7510 }
7511
7512 #define wxGrid_InsertRows(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->InsertRows(_swigarg0,_swigarg1,_swigarg2))
7513 static PyObject *_wrap_wxGrid_InsertRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7514     PyObject * _resultobj;
7515     bool  _result;
7516     wxGrid * _arg0;
7517     int  _arg1 = (int ) 0;
7518     int  _arg2 = (int ) 1;
7519     bool  _arg3 = (bool ) TRUE;
7520     PyObject * _argo0 = 0;
7521     int tempbool3 = (int) TRUE;
7522     char *_kwnames[] = { "self","pos","numRows","updateLabels", NULL };
7523
7524     self = self;
7525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_InsertRows",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7526         return NULL;
7527     if (_argo0) {
7528         if (_argo0 == Py_None) { _arg0 = NULL; }
7529         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7530             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_InsertRows. Expected _wxGrid_p.");
7531         return NULL;
7532         }
7533     }
7534     _arg3 = (bool ) tempbool3;
7535 {
7536     wxPy_BEGIN_ALLOW_THREADS;
7537         _result = (bool )wxGrid_InsertRows(_arg0,_arg1,_arg2,_arg3);
7538
7539     wxPy_END_ALLOW_THREADS;
7540     if (PyErr_Occurred()) return NULL;
7541 }    _resultobj = Py_BuildValue("i",_result);
7542     return _resultobj;
7543 }
7544
7545 #define wxGrid_AppendRows(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AppendRows(_swigarg0,_swigarg1))
7546 static PyObject *_wrap_wxGrid_AppendRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7547     PyObject * _resultobj;
7548     bool  _result;
7549     wxGrid * _arg0;
7550     int  _arg1 = (int ) 1;
7551     bool  _arg2 = (bool ) TRUE;
7552     PyObject * _argo0 = 0;
7553     int tempbool2 = (int) TRUE;
7554     char *_kwnames[] = { "self","numRows","updateLabels", NULL };
7555
7556     self = self;
7557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGrid_AppendRows",_kwnames,&_argo0,&_arg1,&tempbool2))
7558         return NULL;
7559     if (_argo0) {
7560         if (_argo0 == Py_None) { _arg0 = NULL; }
7561         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7562             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AppendRows. Expected _wxGrid_p.");
7563         return NULL;
7564         }
7565     }
7566     _arg2 = (bool ) tempbool2;
7567 {
7568     wxPy_BEGIN_ALLOW_THREADS;
7569         _result = (bool )wxGrid_AppendRows(_arg0,_arg1,_arg2);
7570
7571     wxPy_END_ALLOW_THREADS;
7572     if (PyErr_Occurred()) return NULL;
7573 }    _resultobj = Py_BuildValue("i",_result);
7574     return _resultobj;
7575 }
7576
7577 #define wxGrid_DeleteRows(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->DeleteRows(_swigarg0,_swigarg1,_swigarg2))
7578 static PyObject *_wrap_wxGrid_DeleteRows(PyObject *self, PyObject *args, PyObject *kwargs) {
7579     PyObject * _resultobj;
7580     bool  _result;
7581     wxGrid * _arg0;
7582     int  _arg1 = (int ) 0;
7583     int  _arg2 = (int ) 1;
7584     bool  _arg3 = (bool ) TRUE;
7585     PyObject * _argo0 = 0;
7586     int tempbool3 = (int) TRUE;
7587     char *_kwnames[] = { "self","pos","numRows","updateLabels", NULL };
7588
7589     self = self;
7590     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_DeleteRows",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7591         return NULL;
7592     if (_argo0) {
7593         if (_argo0 == Py_None) { _arg0 = NULL; }
7594         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7595             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DeleteRows. Expected _wxGrid_p.");
7596         return NULL;
7597         }
7598     }
7599     _arg3 = (bool ) tempbool3;
7600 {
7601     wxPy_BEGIN_ALLOW_THREADS;
7602         _result = (bool )wxGrid_DeleteRows(_arg0,_arg1,_arg2,_arg3);
7603
7604     wxPy_END_ALLOW_THREADS;
7605     if (PyErr_Occurred()) return NULL;
7606 }    _resultobj = Py_BuildValue("i",_result);
7607     return _resultobj;
7608 }
7609
7610 #define wxGrid_InsertCols(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->InsertCols(_swigarg0,_swigarg1,_swigarg2))
7611 static PyObject *_wrap_wxGrid_InsertCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7612     PyObject * _resultobj;
7613     bool  _result;
7614     wxGrid * _arg0;
7615     int  _arg1 = (int ) 0;
7616     int  _arg2 = (int ) 1;
7617     bool  _arg3 = (bool ) TRUE;
7618     PyObject * _argo0 = 0;
7619     int tempbool3 = (int) TRUE;
7620     char *_kwnames[] = { "self","pos","numCols","updateLabels", NULL };
7621
7622     self = self;
7623     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_InsertCols",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7624         return NULL;
7625     if (_argo0) {
7626         if (_argo0 == Py_None) { _arg0 = NULL; }
7627         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7628             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_InsertCols. Expected _wxGrid_p.");
7629         return NULL;
7630         }
7631     }
7632     _arg3 = (bool ) tempbool3;
7633 {
7634     wxPy_BEGIN_ALLOW_THREADS;
7635         _result = (bool )wxGrid_InsertCols(_arg0,_arg1,_arg2,_arg3);
7636
7637     wxPy_END_ALLOW_THREADS;
7638     if (PyErr_Occurred()) return NULL;
7639 }    _resultobj = Py_BuildValue("i",_result);
7640     return _resultobj;
7641 }
7642
7643 #define wxGrid_AppendCols(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AppendCols(_swigarg0,_swigarg1))
7644 static PyObject *_wrap_wxGrid_AppendCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7645     PyObject * _resultobj;
7646     bool  _result;
7647     wxGrid * _arg0;
7648     int  _arg1 = (int ) 1;
7649     bool  _arg2 = (bool ) TRUE;
7650     PyObject * _argo0 = 0;
7651     int tempbool2 = (int) TRUE;
7652     char *_kwnames[] = { "self","numCols","updateLabels", NULL };
7653
7654     self = self;
7655     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|ii:wxGrid_AppendCols",_kwnames,&_argo0,&_arg1,&tempbool2))
7656         return NULL;
7657     if (_argo0) {
7658         if (_argo0 == Py_None) { _arg0 = NULL; }
7659         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7660             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AppendCols. Expected _wxGrid_p.");
7661         return NULL;
7662         }
7663     }
7664     _arg2 = (bool ) tempbool2;
7665 {
7666     wxPy_BEGIN_ALLOW_THREADS;
7667         _result = (bool )wxGrid_AppendCols(_arg0,_arg1,_arg2);
7668
7669     wxPy_END_ALLOW_THREADS;
7670     if (PyErr_Occurred()) return NULL;
7671 }    _resultobj = Py_BuildValue("i",_result);
7672     return _resultobj;
7673 }
7674
7675 #define wxGrid_DeleteCols(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->DeleteCols(_swigarg0,_swigarg1,_swigarg2))
7676 static PyObject *_wrap_wxGrid_DeleteCols(PyObject *self, PyObject *args, PyObject *kwargs) {
7677     PyObject * _resultobj;
7678     bool  _result;
7679     wxGrid * _arg0;
7680     int  _arg1 = (int ) 0;
7681     int  _arg2 = (int ) 1;
7682     bool  _arg3 = (bool ) TRUE;
7683     PyObject * _argo0 = 0;
7684     int tempbool3 = (int) TRUE;
7685     char *_kwnames[] = { "self","pos","numCols","updateLabels", NULL };
7686
7687     self = self;
7688     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iii:wxGrid_DeleteCols",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
7689         return NULL;
7690     if (_argo0) {
7691         if (_argo0 == Py_None) { _arg0 = NULL; }
7692         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7693             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DeleteCols. Expected _wxGrid_p.");
7694         return NULL;
7695         }
7696     }
7697     _arg3 = (bool ) tempbool3;
7698 {
7699     wxPy_BEGIN_ALLOW_THREADS;
7700         _result = (bool )wxGrid_DeleteCols(_arg0,_arg1,_arg2,_arg3);
7701
7702     wxPy_END_ALLOW_THREADS;
7703     if (PyErr_Occurred()) return NULL;
7704 }    _resultobj = Py_BuildValue("i",_result);
7705     return _resultobj;
7706 }
7707
7708 #define wxGrid_DrawCellHighlight(_swigobj,_swigarg0,_swigarg1)  (_swigobj->DrawCellHighlight(_swigarg0,_swigarg1))
7709 static PyObject *_wrap_wxGrid_DrawCellHighlight(PyObject *self, PyObject *args, PyObject *kwargs) {
7710     PyObject * _resultobj;
7711     wxGrid * _arg0;
7712     wxDC * _arg1;
7713     wxGridCellAttr * _arg2;
7714     PyObject * _argo0 = 0;
7715     PyObject * _argo1 = 0;
7716     PyObject * _argo2 = 0;
7717     char *_kwnames[] = { "self","dc","attr", NULL };
7718
7719     self = self;
7720     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_DrawCellHighlight",_kwnames,&_argo0,&_argo1,&_argo2))
7721         return NULL;
7722     if (_argo0) {
7723         if (_argo0 == Py_None) { _arg0 = NULL; }
7724         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7725             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DrawCellHighlight. Expected _wxGrid_p.");
7726         return NULL;
7727         }
7728     }
7729     if (_argo1) {
7730         if (_argo1 == Py_None) { _arg1 = NULL; }
7731         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7732             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_DrawCellHighlight. Expected _wxDC_p.");
7733         return NULL;
7734         }
7735     }
7736     if (_argo2) {
7737         if (_argo2 == Py_None) { _arg2 = NULL; }
7738         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
7739             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_DrawCellHighlight. Expected _wxGridCellAttr_p.");
7740         return NULL;
7741         }
7742     }
7743 {
7744     wxPy_BEGIN_ALLOW_THREADS;
7745         wxGrid_DrawCellHighlight(_arg0,*_arg1,_arg2);
7746
7747     wxPy_END_ALLOW_THREADS;
7748     if (PyErr_Occurred()) return NULL;
7749 }    Py_INCREF(Py_None);
7750     _resultobj = Py_None;
7751     return _resultobj;
7752 }
7753
7754 #define wxGrid_DrawTextRectangle(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->DrawTextRectangle(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
7755 static PyObject *_wrap_wxGrid_DrawTextRectangle(PyObject *self, PyObject *args, PyObject *kwargs) {
7756     PyObject * _resultobj;
7757     wxGrid * _arg0;
7758     wxDC * _arg1;
7759     wxString * _arg2;
7760     wxRect * _arg3;
7761     int  _arg4 = (int ) wxLEFT;
7762     int  _arg5 = (int ) wxTOP;
7763     PyObject * _argo0 = 0;
7764     PyObject * _argo1 = 0;
7765     PyObject * _obj2 = 0;
7766     wxRect  temp;
7767     PyObject * _obj3 = 0;
7768     char *_kwnames[] = { "self","dc","arg3","arg4","horizontalAlignment","verticalAlignment", NULL };
7769
7770     self = self;
7771     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO|ii:wxGrid_DrawTextRectangle",_kwnames,&_argo0,&_argo1,&_obj2,&_obj3,&_arg4,&_arg5))
7772         return NULL;
7773     if (_argo0) {
7774         if (_argo0 == Py_None) { _arg0 = NULL; }
7775         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7776             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DrawTextRectangle. Expected _wxGrid_p.");
7777         return NULL;
7778         }
7779     }
7780     if (_argo1) {
7781         if (_argo1 == Py_None) { _arg1 = NULL; }
7782         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7783             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_DrawTextRectangle. Expected _wxDC_p.");
7784         return NULL;
7785         }
7786     }
7787 {
7788 #if PYTHON_API_VERSION >= 1009
7789     char* tmpPtr; int tmpSize;
7790     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
7791         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
7792         return NULL;
7793     }
7794     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
7795         return NULL;
7796     _arg2 = new wxString(tmpPtr, tmpSize);
7797 #else
7798     if (!PyString_Check(_obj2)) {
7799         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
7800         return NULL;
7801     }
7802     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
7803 #endif
7804 }
7805 {
7806     _arg3 = &temp;
7807     if (! wxRect_helper(_obj3, &_arg3))
7808         return NULL;
7809 }
7810 {
7811     wxPy_BEGIN_ALLOW_THREADS;
7812         wxGrid_DrawTextRectangle(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5);
7813
7814     wxPy_END_ALLOW_THREADS;
7815     if (PyErr_Occurred()) return NULL;
7816 }    Py_INCREF(Py_None);
7817     _resultobj = Py_None;
7818 {
7819     if (_obj2)
7820         delete _arg2;
7821 }
7822     return _resultobj;
7823 }
7824
7825 #define wxGrid_StringToLines(_swigobj,_swigarg0,_swigarg1)  (_swigobj->StringToLines(_swigarg0,_swigarg1))
7826 static PyObject *_wrap_wxGrid_StringToLines(PyObject *self, PyObject *args, PyObject *kwargs) {
7827     PyObject * _resultobj;
7828     wxGrid * _arg0;
7829     wxString * _arg1;
7830     wxArrayString * _arg2;
7831     PyObject * _argo0 = 0;
7832     PyObject * _obj1 = 0;
7833     PyObject * _argo2 = 0;
7834     char *_kwnames[] = { "self","value","lines", NULL };
7835
7836     self = self;
7837     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_StringToLines",_kwnames,&_argo0,&_obj1,&_argo2))
7838         return NULL;
7839     if (_argo0) {
7840         if (_argo0 == Py_None) { _arg0 = NULL; }
7841         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7842             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_StringToLines. Expected _wxGrid_p.");
7843         return NULL;
7844         }
7845     }
7846 {
7847 #if PYTHON_API_VERSION >= 1009
7848     char* tmpPtr; int tmpSize;
7849     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
7850         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
7851         return NULL;
7852     }
7853     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
7854         return NULL;
7855     _arg1 = new wxString(tmpPtr, tmpSize);
7856 #else
7857     if (!PyString_Check(_obj1)) {
7858         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
7859         return NULL;
7860     }
7861     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
7862 #endif
7863 }
7864     if (_argo2) {
7865         if (_argo2 == Py_None) { _arg2 = NULL; }
7866         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxArrayString_p")) {
7867             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_StringToLines. Expected _wxArrayString_p.");
7868         return NULL;
7869         }
7870     }
7871 {
7872     wxPy_BEGIN_ALLOW_THREADS;
7873         wxGrid_StringToLines(_arg0,*_arg1,*_arg2);
7874
7875     wxPy_END_ALLOW_THREADS;
7876     if (PyErr_Occurred()) return NULL;
7877 }    Py_INCREF(Py_None);
7878     _resultobj = Py_None;
7879 {
7880     if (_obj1)
7881         delete _arg1;
7882 }
7883     return _resultobj;
7884 }
7885
7886 #define wxGrid_GetTextBoxSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetTextBoxSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
7887 static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
7888     PyObject * _resultobj;
7889     wxGrid * _arg0;
7890     wxDC * _arg1;
7891     wxArrayString * _arg2;
7892     long * _arg3;
7893     long  temp;
7894     long * _arg4;
7895     long  temp0;
7896     PyObject * _argo0 = 0;
7897     PyObject * _argo1 = 0;
7898     PyObject * _argo2 = 0;
7899     char *_kwnames[] = { "self","dc","lines", NULL };
7900
7901     self = self;
7902 {
7903   _arg3 = &temp;
7904 }
7905 {
7906   _arg4 = &temp0;
7907 }
7908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetTextBoxSize",_kwnames,&_argo0,&_argo1,&_argo2))
7909         return NULL;
7910     if (_argo0) {
7911         if (_argo0 == Py_None) { _arg0 = NULL; }
7912         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7913             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetTextBoxSize. Expected _wxGrid_p.");
7914         return NULL;
7915         }
7916     }
7917     if (_argo1) {
7918         if (_argo1 == Py_None) { _arg1 = NULL; }
7919         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7920             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_GetTextBoxSize. Expected _wxDC_p.");
7921         return NULL;
7922         }
7923     }
7924     if (_argo2) {
7925         if (_argo2 == Py_None) { _arg2 = NULL; }
7926         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxArrayString_p")) {
7927             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_GetTextBoxSize. Expected _wxArrayString_p.");
7928         return NULL;
7929         }
7930     }
7931 {
7932     wxPy_BEGIN_ALLOW_THREADS;
7933         wxGrid_GetTextBoxSize(_arg0,*_arg1,*_arg2,_arg3,_arg4);
7934
7935     wxPy_END_ALLOW_THREADS;
7936     if (PyErr_Occurred()) return NULL;
7937 }    Py_INCREF(Py_None);
7938     _resultobj = Py_None;
7939 {
7940     PyObject *o;
7941     o = PyInt_FromLong((long) (*_arg3));
7942     _resultobj = t_output_helper(_resultobj, o);
7943 }
7944 {
7945     PyObject *o;
7946     o = PyInt_FromLong((long) (*_arg4));
7947     _resultobj = t_output_helper(_resultobj, o);
7948 }
7949     return _resultobj;
7950 }
7951
7952 #define wxGrid_BeginBatch(_swigobj)  (_swigobj->BeginBatch())
7953 static PyObject *_wrap_wxGrid_BeginBatch(PyObject *self, PyObject *args, PyObject *kwargs) {
7954     PyObject * _resultobj;
7955     wxGrid * _arg0;
7956     PyObject * _argo0 = 0;
7957     char *_kwnames[] = { "self", NULL };
7958
7959     self = self;
7960     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_BeginBatch",_kwnames,&_argo0))
7961         return NULL;
7962     if (_argo0) {
7963         if (_argo0 == Py_None) { _arg0 = NULL; }
7964         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7965             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_BeginBatch. Expected _wxGrid_p.");
7966         return NULL;
7967         }
7968     }
7969 {
7970     wxPy_BEGIN_ALLOW_THREADS;
7971         wxGrid_BeginBatch(_arg0);
7972
7973     wxPy_END_ALLOW_THREADS;
7974     if (PyErr_Occurred()) return NULL;
7975 }    Py_INCREF(Py_None);
7976     _resultobj = Py_None;
7977     return _resultobj;
7978 }
7979
7980 #define wxGrid_EndBatch(_swigobj)  (_swigobj->EndBatch())
7981 static PyObject *_wrap_wxGrid_EndBatch(PyObject *self, PyObject *args, PyObject *kwargs) {
7982     PyObject * _resultobj;
7983     wxGrid * _arg0;
7984     PyObject * _argo0 = 0;
7985     char *_kwnames[] = { "self", NULL };
7986
7987     self = self;
7988     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_EndBatch",_kwnames,&_argo0))
7989         return NULL;
7990     if (_argo0) {
7991         if (_argo0 == Py_None) { _arg0 = NULL; }
7992         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7993             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EndBatch. Expected _wxGrid_p.");
7994         return NULL;
7995         }
7996     }
7997 {
7998     wxPy_BEGIN_ALLOW_THREADS;
7999         wxGrid_EndBatch(_arg0);
8000
8001     wxPy_END_ALLOW_THREADS;
8002     if (PyErr_Occurred()) return NULL;
8003 }    Py_INCREF(Py_None);
8004     _resultobj = Py_None;
8005     return _resultobj;
8006 }
8007
8008 #define wxGrid_GetBatchCount(_swigobj)  (_swigobj->GetBatchCount())
8009 static PyObject *_wrap_wxGrid_GetBatchCount(PyObject *self, PyObject *args, PyObject *kwargs) {
8010     PyObject * _resultobj;
8011     int  _result;
8012     wxGrid * _arg0;
8013     PyObject * _argo0 = 0;
8014     char *_kwnames[] = { "self", NULL };
8015
8016     self = self;
8017     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetBatchCount",_kwnames,&_argo0))
8018         return NULL;
8019     if (_argo0) {
8020         if (_argo0 == Py_None) { _arg0 = NULL; }
8021         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8022             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetBatchCount. Expected _wxGrid_p.");
8023         return NULL;
8024         }
8025     }
8026 {
8027     wxPy_BEGIN_ALLOW_THREADS;
8028         _result = (int )wxGrid_GetBatchCount(_arg0);
8029
8030     wxPy_END_ALLOW_THREADS;
8031     if (PyErr_Occurred()) return NULL;
8032 }    _resultobj = Py_BuildValue("i",_result);
8033     return _resultobj;
8034 }
8035
8036 #define wxGrid_ForceRefresh(_swigobj)  (_swigobj->ForceRefresh())
8037 static PyObject *_wrap_wxGrid_ForceRefresh(PyObject *self, PyObject *args, PyObject *kwargs) {
8038     PyObject * _resultobj;
8039     wxGrid * _arg0;
8040     PyObject * _argo0 = 0;
8041     char *_kwnames[] = { "self", NULL };
8042
8043     self = self;
8044     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ForceRefresh",_kwnames,&_argo0))
8045         return NULL;
8046     if (_argo0) {
8047         if (_argo0 == Py_None) { _arg0 = NULL; }
8048         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8049             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ForceRefresh. Expected _wxGrid_p.");
8050         return NULL;
8051         }
8052     }
8053 {
8054     wxPy_BEGIN_ALLOW_THREADS;
8055         wxGrid_ForceRefresh(_arg0);
8056
8057     wxPy_END_ALLOW_THREADS;
8058     if (PyErr_Occurred()) return NULL;
8059 }    Py_INCREF(Py_None);
8060     _resultobj = Py_None;
8061     return _resultobj;
8062 }
8063
8064 #define wxGrid_IsEditable(_swigobj)  (_swigobj->IsEditable())
8065 static PyObject *_wrap_wxGrid_IsEditable(PyObject *self, PyObject *args, PyObject *kwargs) {
8066     PyObject * _resultobj;
8067     bool  _result;
8068     wxGrid * _arg0;
8069     PyObject * _argo0 = 0;
8070     char *_kwnames[] = { "self", NULL };
8071
8072     self = self;
8073     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsEditable",_kwnames,&_argo0))
8074         return NULL;
8075     if (_argo0) {
8076         if (_argo0 == Py_None) { _arg0 = NULL; }
8077         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8078             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsEditable. Expected _wxGrid_p.");
8079         return NULL;
8080         }
8081     }
8082 {
8083     wxPy_BEGIN_ALLOW_THREADS;
8084         _result = (bool )wxGrid_IsEditable(_arg0);
8085
8086     wxPy_END_ALLOW_THREADS;
8087     if (PyErr_Occurred()) return NULL;
8088 }    _resultobj = Py_BuildValue("i",_result);
8089     return _resultobj;
8090 }
8091
8092 #define wxGrid_EnableEditing(_swigobj,_swigarg0)  (_swigobj->EnableEditing(_swigarg0))
8093 static PyObject *_wrap_wxGrid_EnableEditing(PyObject *self, PyObject *args, PyObject *kwargs) {
8094     PyObject * _resultobj;
8095     wxGrid * _arg0;
8096     bool  _arg1;
8097     PyObject * _argo0 = 0;
8098     int tempbool1;
8099     char *_kwnames[] = { "self","edit", NULL };
8100
8101     self = self;
8102     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_EnableEditing",_kwnames,&_argo0,&tempbool1))
8103         return NULL;
8104     if (_argo0) {
8105         if (_argo0 == Py_None) { _arg0 = NULL; }
8106         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8107             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableEditing. Expected _wxGrid_p.");
8108         return NULL;
8109         }
8110     }
8111     _arg1 = (bool ) tempbool1;
8112 {
8113     wxPy_BEGIN_ALLOW_THREADS;
8114         wxGrid_EnableEditing(_arg0,_arg1);
8115
8116     wxPy_END_ALLOW_THREADS;
8117     if (PyErr_Occurred()) return NULL;
8118 }    Py_INCREF(Py_None);
8119     _resultobj = Py_None;
8120     return _resultobj;
8121 }
8122
8123 #define wxGrid_EnableCellEditControl(_swigobj,_swigarg0)  (_swigobj->EnableCellEditControl(_swigarg0))
8124 static PyObject *_wrap_wxGrid_EnableCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8125     PyObject * _resultobj;
8126     wxGrid * _arg0;
8127     bool  _arg1 = (bool ) TRUE;
8128     PyObject * _argo0 = 0;
8129     int tempbool1 = (int) TRUE;
8130     char *_kwnames[] = { "self","enable", NULL };
8131
8132     self = self;
8133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableCellEditControl",_kwnames,&_argo0,&tempbool1))
8134         return NULL;
8135     if (_argo0) {
8136         if (_argo0 == Py_None) { _arg0 = NULL; }
8137         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8138             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableCellEditControl. Expected _wxGrid_p.");
8139         return NULL;
8140         }
8141     }
8142     _arg1 = (bool ) tempbool1;
8143 {
8144     wxPy_BEGIN_ALLOW_THREADS;
8145         wxGrid_EnableCellEditControl(_arg0,_arg1);
8146
8147     wxPy_END_ALLOW_THREADS;
8148     if (PyErr_Occurred()) return NULL;
8149 }    Py_INCREF(Py_None);
8150     _resultobj = Py_None;
8151     return _resultobj;
8152 }
8153
8154 #define wxGrid_DisableCellEditControl(_swigobj)  (_swigobj->DisableCellEditControl())
8155 static PyObject *_wrap_wxGrid_DisableCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8156     PyObject * _resultobj;
8157     wxGrid * _arg0;
8158     PyObject * _argo0 = 0;
8159     char *_kwnames[] = { "self", NULL };
8160
8161     self = self;
8162     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableCellEditControl",_kwnames,&_argo0))
8163         return NULL;
8164     if (_argo0) {
8165         if (_argo0 == Py_None) { _arg0 = NULL; }
8166         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8167             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableCellEditControl. Expected _wxGrid_p.");
8168         return NULL;
8169         }
8170     }
8171 {
8172     wxPy_BEGIN_ALLOW_THREADS;
8173         wxGrid_DisableCellEditControl(_arg0);
8174
8175     wxPy_END_ALLOW_THREADS;
8176     if (PyErr_Occurred()) return NULL;
8177 }    Py_INCREF(Py_None);
8178     _resultobj = Py_None;
8179     return _resultobj;
8180 }
8181
8182 #define wxGrid_CanEnableCellControl(_swigobj)  (_swigobj->CanEnableCellControl())
8183 static PyObject *_wrap_wxGrid_CanEnableCellControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8184     PyObject * _resultobj;
8185     bool  _result;
8186     wxGrid * _arg0;
8187     PyObject * _argo0 = 0;
8188     char *_kwnames[] = { "self", NULL };
8189
8190     self = self;
8191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanEnableCellControl",_kwnames,&_argo0))
8192         return NULL;
8193     if (_argo0) {
8194         if (_argo0 == Py_None) { _arg0 = NULL; }
8195         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8196             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanEnableCellControl. Expected _wxGrid_p.");
8197         return NULL;
8198         }
8199     }
8200 {
8201     wxPy_BEGIN_ALLOW_THREADS;
8202         _result = (bool )wxGrid_CanEnableCellControl(_arg0);
8203
8204     wxPy_END_ALLOW_THREADS;
8205     if (PyErr_Occurred()) return NULL;
8206 }    _resultobj = Py_BuildValue("i",_result);
8207     return _resultobj;
8208 }
8209
8210 #define wxGrid_IsCellEditControlEnabled(_swigobj)  (_swigobj->IsCellEditControlEnabled())
8211 static PyObject *_wrap_wxGrid_IsCellEditControlEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
8212     PyObject * _resultobj;
8213     bool  _result;
8214     wxGrid * _arg0;
8215     PyObject * _argo0 = 0;
8216     char *_kwnames[] = { "self", NULL };
8217
8218     self = self;
8219     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCellEditControlEnabled",_kwnames,&_argo0))
8220         return NULL;
8221     if (_argo0) {
8222         if (_argo0 == Py_None) { _arg0 = NULL; }
8223         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8224             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCellEditControlEnabled. Expected _wxGrid_p.");
8225         return NULL;
8226         }
8227     }
8228 {
8229     wxPy_BEGIN_ALLOW_THREADS;
8230         _result = (bool )wxGrid_IsCellEditControlEnabled(_arg0);
8231
8232     wxPy_END_ALLOW_THREADS;
8233     if (PyErr_Occurred()) return NULL;
8234 }    _resultobj = Py_BuildValue("i",_result);
8235     return _resultobj;
8236 }
8237
8238 #define wxGrid_IsCellEditControlShown(_swigobj)  (_swigobj->IsCellEditControlShown())
8239 static PyObject *_wrap_wxGrid_IsCellEditControlShown(PyObject *self, PyObject *args, PyObject *kwargs) {
8240     PyObject * _resultobj;
8241     bool  _result;
8242     wxGrid * _arg0;
8243     PyObject * _argo0 = 0;
8244     char *_kwnames[] = { "self", NULL };
8245
8246     self = self;
8247     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCellEditControlShown",_kwnames,&_argo0))
8248         return NULL;
8249     if (_argo0) {
8250         if (_argo0 == Py_None) { _arg0 = NULL; }
8251         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8252             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCellEditControlShown. Expected _wxGrid_p.");
8253         return NULL;
8254         }
8255     }
8256 {
8257     wxPy_BEGIN_ALLOW_THREADS;
8258         _result = (bool )wxGrid_IsCellEditControlShown(_arg0);
8259
8260     wxPy_END_ALLOW_THREADS;
8261     if (PyErr_Occurred()) return NULL;
8262 }    _resultobj = Py_BuildValue("i",_result);
8263     return _resultobj;
8264 }
8265
8266 #define wxGrid_IsCurrentCellReadOnly(_swigobj)  (_swigobj->IsCurrentCellReadOnly())
8267 static PyObject *_wrap_wxGrid_IsCurrentCellReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
8268     PyObject * _resultobj;
8269     bool  _result;
8270     wxGrid * _arg0;
8271     PyObject * _argo0 = 0;
8272     char *_kwnames[] = { "self", NULL };
8273
8274     self = self;
8275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCurrentCellReadOnly",_kwnames,&_argo0))
8276         return NULL;
8277     if (_argo0) {
8278         if (_argo0 == Py_None) { _arg0 = NULL; }
8279         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8280             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCurrentCellReadOnly. Expected _wxGrid_p.");
8281         return NULL;
8282         }
8283     }
8284 {
8285     wxPy_BEGIN_ALLOW_THREADS;
8286         _result = (bool )wxGrid_IsCurrentCellReadOnly(_arg0);
8287
8288     wxPy_END_ALLOW_THREADS;
8289     if (PyErr_Occurred()) return NULL;
8290 }    _resultobj = Py_BuildValue("i",_result);
8291     return _resultobj;
8292 }
8293
8294 #define wxGrid_ShowCellEditControl(_swigobj)  (_swigobj->ShowCellEditControl())
8295 static PyObject *_wrap_wxGrid_ShowCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8296     PyObject * _resultobj;
8297     wxGrid * _arg0;
8298     PyObject * _argo0 = 0;
8299     char *_kwnames[] = { "self", NULL };
8300
8301     self = self;
8302     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ShowCellEditControl",_kwnames,&_argo0))
8303         return NULL;
8304     if (_argo0) {
8305         if (_argo0 == Py_None) { _arg0 = NULL; }
8306         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8307             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ShowCellEditControl. Expected _wxGrid_p.");
8308         return NULL;
8309         }
8310     }
8311 {
8312     wxPy_BEGIN_ALLOW_THREADS;
8313         wxGrid_ShowCellEditControl(_arg0);
8314
8315     wxPy_END_ALLOW_THREADS;
8316     if (PyErr_Occurred()) return NULL;
8317 }    Py_INCREF(Py_None);
8318     _resultobj = Py_None;
8319     return _resultobj;
8320 }
8321
8322 #define wxGrid_HideCellEditControl(_swigobj)  (_swigobj->HideCellEditControl())
8323 static PyObject *_wrap_wxGrid_HideCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8324     PyObject * _resultobj;
8325     wxGrid * _arg0;
8326     PyObject * _argo0 = 0;
8327     char *_kwnames[] = { "self", NULL };
8328
8329     self = self;
8330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_HideCellEditControl",_kwnames,&_argo0))
8331         return NULL;
8332     if (_argo0) {
8333         if (_argo0 == Py_None) { _arg0 = NULL; }
8334         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8335             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_HideCellEditControl. Expected _wxGrid_p.");
8336         return NULL;
8337         }
8338     }
8339 {
8340     wxPy_BEGIN_ALLOW_THREADS;
8341         wxGrid_HideCellEditControl(_arg0);
8342
8343     wxPy_END_ALLOW_THREADS;
8344     if (PyErr_Occurred()) return NULL;
8345 }    Py_INCREF(Py_None);
8346     _resultobj = Py_None;
8347     return _resultobj;
8348 }
8349
8350 #define wxGrid_SaveEditControlValue(_swigobj)  (_swigobj->SaveEditControlValue())
8351 static PyObject *_wrap_wxGrid_SaveEditControlValue(PyObject *self, PyObject *args, PyObject *kwargs) {
8352     PyObject * _resultobj;
8353     wxGrid * _arg0;
8354     PyObject * _argo0 = 0;
8355     char *_kwnames[] = { "self", NULL };
8356
8357     self = self;
8358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_SaveEditControlValue",_kwnames,&_argo0))
8359         return NULL;
8360     if (_argo0) {
8361         if (_argo0 == Py_None) { _arg0 = NULL; }
8362         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8363             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SaveEditControlValue. Expected _wxGrid_p.");
8364         return NULL;
8365         }
8366     }
8367 {
8368     wxPy_BEGIN_ALLOW_THREADS;
8369         wxGrid_SaveEditControlValue(_arg0);
8370
8371     wxPy_END_ALLOW_THREADS;
8372     if (PyErr_Occurred()) return NULL;
8373 }    Py_INCREF(Py_None);
8374     _resultobj = Py_None;
8375     return _resultobj;
8376 }
8377
8378 static wxGridCellCoords * wxGrid_XYToCell(wxGrid *self,int  x,int  y) {
8379             wxGridCellCoords rv;
8380             self->XYToCell(x, y, rv);
8381             return new wxGridCellCoords(rv);
8382         }
8383 static PyObject *_wrap_wxGrid_XYToCell(PyObject *self, PyObject *args, PyObject *kwargs) {
8384     PyObject * _resultobj;
8385     wxGridCellCoords * _result;
8386     wxGrid * _arg0;
8387     int  _arg1;
8388     int  _arg2;
8389     PyObject * _argo0 = 0;
8390     char *_kwnames[] = { "self","x","y", NULL };
8391     char _ptemp[128];
8392
8393     self = self;
8394     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_XYToCell",_kwnames,&_argo0,&_arg1,&_arg2))
8395         return NULL;
8396     if (_argo0) {
8397         if (_argo0 == Py_None) { _arg0 = NULL; }
8398         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8399             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XYToCell. Expected _wxGrid_p.");
8400         return NULL;
8401         }
8402     }
8403 {
8404     wxPy_BEGIN_ALLOW_THREADS;
8405         _result = (wxGridCellCoords *)wxGrid_XYToCell(_arg0,_arg1,_arg2);
8406
8407     wxPy_END_ALLOW_THREADS;
8408     if (PyErr_Occurred()) return NULL;
8409 }    if (_result) {
8410         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
8411         _resultobj = Py_BuildValue("s",_ptemp);
8412     } else {
8413         Py_INCREF(Py_None);
8414         _resultobj = Py_None;
8415     }
8416     return _resultobj;
8417 }
8418
8419 #define wxGrid_YToRow(_swigobj,_swigarg0)  (_swigobj->YToRow(_swigarg0))
8420 static PyObject *_wrap_wxGrid_YToRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8421     PyObject * _resultobj;
8422     int  _result;
8423     wxGrid * _arg0;
8424     int  _arg1;
8425     PyObject * _argo0 = 0;
8426     char *_kwnames[] = { "self","y", NULL };
8427
8428     self = self;
8429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_YToRow",_kwnames,&_argo0,&_arg1))
8430         return NULL;
8431     if (_argo0) {
8432         if (_argo0 == Py_None) { _arg0 = NULL; }
8433         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8434             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_YToRow. Expected _wxGrid_p.");
8435         return NULL;
8436         }
8437     }
8438 {
8439     wxPy_BEGIN_ALLOW_THREADS;
8440         _result = (int )wxGrid_YToRow(_arg0,_arg1);
8441
8442     wxPy_END_ALLOW_THREADS;
8443     if (PyErr_Occurred()) return NULL;
8444 }    _resultobj = Py_BuildValue("i",_result);
8445     return _resultobj;
8446 }
8447
8448 #define wxGrid_XToCol(_swigobj,_swigarg0)  (_swigobj->XToCol(_swigarg0))
8449 static PyObject *_wrap_wxGrid_XToCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8450     PyObject * _resultobj;
8451     int  _result;
8452     wxGrid * _arg0;
8453     int  _arg1;
8454     PyObject * _argo0 = 0;
8455     char *_kwnames[] = { "self","x", NULL };
8456
8457     self = self;
8458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_XToCol",_kwnames,&_argo0,&_arg1))
8459         return NULL;
8460     if (_argo0) {
8461         if (_argo0 == Py_None) { _arg0 = NULL; }
8462         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8463             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XToCol. Expected _wxGrid_p.");
8464         return NULL;
8465         }
8466     }
8467 {
8468     wxPy_BEGIN_ALLOW_THREADS;
8469         _result = (int )wxGrid_XToCol(_arg0,_arg1);
8470
8471     wxPy_END_ALLOW_THREADS;
8472     if (PyErr_Occurred()) return NULL;
8473 }    _resultobj = Py_BuildValue("i",_result);
8474     return _resultobj;
8475 }
8476
8477 #define wxGrid_YToEdgeOfRow(_swigobj,_swigarg0)  (_swigobj->YToEdgeOfRow(_swigarg0))
8478 static PyObject *_wrap_wxGrid_YToEdgeOfRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8479     PyObject * _resultobj;
8480     int  _result;
8481     wxGrid * _arg0;
8482     int  _arg1;
8483     PyObject * _argo0 = 0;
8484     char *_kwnames[] = { "self","y", NULL };
8485
8486     self = self;
8487     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_YToEdgeOfRow",_kwnames,&_argo0,&_arg1))
8488         return NULL;
8489     if (_argo0) {
8490         if (_argo0 == Py_None) { _arg0 = NULL; }
8491         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8492             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_YToEdgeOfRow. Expected _wxGrid_p.");
8493         return NULL;
8494         }
8495     }
8496 {
8497     wxPy_BEGIN_ALLOW_THREADS;
8498         _result = (int )wxGrid_YToEdgeOfRow(_arg0,_arg1);
8499
8500     wxPy_END_ALLOW_THREADS;
8501     if (PyErr_Occurred()) return NULL;
8502 }    _resultobj = Py_BuildValue("i",_result);
8503     return _resultobj;
8504 }
8505
8506 #define wxGrid_XToEdgeOfCol(_swigobj,_swigarg0)  (_swigobj->XToEdgeOfCol(_swigarg0))
8507 static PyObject *_wrap_wxGrid_XToEdgeOfCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8508     PyObject * _resultobj;
8509     int  _result;
8510     wxGrid * _arg0;
8511     int  _arg1;
8512     PyObject * _argo0 = 0;
8513     char *_kwnames[] = { "self","x", NULL };
8514
8515     self = self;
8516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_XToEdgeOfCol",_kwnames,&_argo0,&_arg1))
8517         return NULL;
8518     if (_argo0) {
8519         if (_argo0 == Py_None) { _arg0 = NULL; }
8520         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8521             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XToEdgeOfCol. Expected _wxGrid_p.");
8522         return NULL;
8523         }
8524     }
8525 {
8526     wxPy_BEGIN_ALLOW_THREADS;
8527         _result = (int )wxGrid_XToEdgeOfCol(_arg0,_arg1);
8528
8529     wxPy_END_ALLOW_THREADS;
8530     if (PyErr_Occurred()) return NULL;
8531 }    _resultobj = Py_BuildValue("i",_result);
8532     return _resultobj;
8533 }
8534
8535 #define wxGrid_CellToRect(_swigobj,_swigarg0,_swigarg1)  (_swigobj->CellToRect(_swigarg0,_swigarg1))
8536 static PyObject *_wrap_wxGrid_CellToRect(PyObject *self, PyObject *args, PyObject *kwargs) {
8537     PyObject * _resultobj;
8538     wxRect * _result;
8539     wxGrid * _arg0;
8540     int  _arg1;
8541     int  _arg2;
8542     PyObject * _argo0 = 0;
8543     char *_kwnames[] = { "self","row","col", NULL };
8544     char _ptemp[128];
8545
8546     self = self;
8547     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_CellToRect",_kwnames,&_argo0,&_arg1,&_arg2))
8548         return NULL;
8549     if (_argo0) {
8550         if (_argo0 == Py_None) { _arg0 = NULL; }
8551         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8552             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CellToRect. Expected _wxGrid_p.");
8553         return NULL;
8554         }
8555     }
8556 {
8557     wxPy_BEGIN_ALLOW_THREADS;
8558         _result = new wxRect (wxGrid_CellToRect(_arg0,_arg1,_arg2));
8559
8560     wxPy_END_ALLOW_THREADS;
8561     if (PyErr_Occurred()) return NULL;
8562 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
8563     _resultobj = Py_BuildValue("s",_ptemp);
8564     return _resultobj;
8565 }
8566
8567 #define wxGrid_GetGridCursorRow(_swigobj)  (_swigobj->GetGridCursorRow())
8568 static PyObject *_wrap_wxGrid_GetGridCursorRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8569     PyObject * _resultobj;
8570     int  _result;
8571     wxGrid * _arg0;
8572     PyObject * _argo0 = 0;
8573     char *_kwnames[] = { "self", NULL };
8574
8575     self = self;
8576     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCursorRow",_kwnames,&_argo0))
8577         return NULL;
8578     if (_argo0) {
8579         if (_argo0 == Py_None) { _arg0 = NULL; }
8580         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8581             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCursorRow. Expected _wxGrid_p.");
8582         return NULL;
8583         }
8584     }
8585 {
8586     wxPy_BEGIN_ALLOW_THREADS;
8587         _result = (int )wxGrid_GetGridCursorRow(_arg0);
8588
8589     wxPy_END_ALLOW_THREADS;
8590     if (PyErr_Occurred()) return NULL;
8591 }    _resultobj = Py_BuildValue("i",_result);
8592     return _resultobj;
8593 }
8594
8595 #define wxGrid_GetGridCursorCol(_swigobj)  (_swigobj->GetGridCursorCol())
8596 static PyObject *_wrap_wxGrid_GetGridCursorCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8597     PyObject * _resultobj;
8598     int  _result;
8599     wxGrid * _arg0;
8600     PyObject * _argo0 = 0;
8601     char *_kwnames[] = { "self", NULL };
8602
8603     self = self;
8604     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCursorCol",_kwnames,&_argo0))
8605         return NULL;
8606     if (_argo0) {
8607         if (_argo0 == Py_None) { _arg0 = NULL; }
8608         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8609             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCursorCol. Expected _wxGrid_p.");
8610         return NULL;
8611         }
8612     }
8613 {
8614     wxPy_BEGIN_ALLOW_THREADS;
8615         _result = (int )wxGrid_GetGridCursorCol(_arg0);
8616
8617     wxPy_END_ALLOW_THREADS;
8618     if (PyErr_Occurred()) return NULL;
8619 }    _resultobj = Py_BuildValue("i",_result);
8620     return _resultobj;
8621 }
8622
8623 #define wxGrid_IsVisible(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->IsVisible(_swigarg0,_swigarg1,_swigarg2))
8624 static PyObject *_wrap_wxGrid_IsVisible(PyObject *self, PyObject *args, PyObject *kwargs) {
8625     PyObject * _resultobj;
8626     bool  _result;
8627     wxGrid * _arg0;
8628     int  _arg1;
8629     int  _arg2;
8630     bool  _arg3 = (bool ) TRUE;
8631     PyObject * _argo0 = 0;
8632     int tempbool3 = (int) TRUE;
8633     char *_kwnames[] = { "self","row","col","wholeCellVisible", NULL };
8634
8635     self = self;
8636     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_IsVisible",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
8637         return NULL;
8638     if (_argo0) {
8639         if (_argo0 == Py_None) { _arg0 = NULL; }
8640         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8641             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsVisible. Expected _wxGrid_p.");
8642         return NULL;
8643         }
8644     }
8645     _arg3 = (bool ) tempbool3;
8646 {
8647     wxPy_BEGIN_ALLOW_THREADS;
8648         _result = (bool )wxGrid_IsVisible(_arg0,_arg1,_arg2,_arg3);
8649
8650     wxPy_END_ALLOW_THREADS;
8651     if (PyErr_Occurred()) return NULL;
8652 }    _resultobj = Py_BuildValue("i",_result);
8653     return _resultobj;
8654 }
8655
8656 #define wxGrid_MakeCellVisible(_swigobj,_swigarg0,_swigarg1)  (_swigobj->MakeCellVisible(_swigarg0,_swigarg1))
8657 static PyObject *_wrap_wxGrid_MakeCellVisible(PyObject *self, PyObject *args, PyObject *kwargs) {
8658     PyObject * _resultobj;
8659     wxGrid * _arg0;
8660     int  _arg1;
8661     int  _arg2;
8662     PyObject * _argo0 = 0;
8663     char *_kwnames[] = { "self","row","col", NULL };
8664
8665     self = self;
8666     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_MakeCellVisible",_kwnames,&_argo0,&_arg1,&_arg2))
8667         return NULL;
8668     if (_argo0) {
8669         if (_argo0 == Py_None) { _arg0 = NULL; }
8670         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8671             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MakeCellVisible. Expected _wxGrid_p.");
8672         return NULL;
8673         }
8674     }
8675 {
8676     wxPy_BEGIN_ALLOW_THREADS;
8677         wxGrid_MakeCellVisible(_arg0,_arg1,_arg2);
8678
8679     wxPy_END_ALLOW_THREADS;
8680     if (PyErr_Occurred()) return NULL;
8681 }    Py_INCREF(Py_None);
8682     _resultobj = Py_None;
8683     return _resultobj;
8684 }
8685
8686 #define wxGrid_SetGridCursor(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetGridCursor(_swigarg0,_swigarg1))
8687 static PyObject *_wrap_wxGrid_SetGridCursor(PyObject *self, PyObject *args, PyObject *kwargs) {
8688     PyObject * _resultobj;
8689     wxGrid * _arg0;
8690     int  _arg1;
8691     int  _arg2;
8692     PyObject * _argo0 = 0;
8693     char *_kwnames[] = { "self","row","col", NULL };
8694
8695     self = self;
8696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetGridCursor",_kwnames,&_argo0,&_arg1,&_arg2))
8697         return NULL;
8698     if (_argo0) {
8699         if (_argo0 == Py_None) { _arg0 = NULL; }
8700         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8701             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetGridCursor. Expected _wxGrid_p.");
8702         return NULL;
8703         }
8704     }
8705 {
8706     wxPy_BEGIN_ALLOW_THREADS;
8707         wxGrid_SetGridCursor(_arg0,_arg1,_arg2);
8708
8709     wxPy_END_ALLOW_THREADS;
8710     if (PyErr_Occurred()) return NULL;
8711 }    Py_INCREF(Py_None);
8712     _resultobj = Py_None;
8713     return _resultobj;
8714 }
8715
8716 #define wxGrid_MoveCursorUp(_swigobj,_swigarg0)  (_swigobj->MoveCursorUp(_swigarg0))
8717 static PyObject *_wrap_wxGrid_MoveCursorUp(PyObject *self, PyObject *args, PyObject *kwargs) {
8718     PyObject * _resultobj;
8719     bool  _result;
8720     wxGrid * _arg0;
8721     bool  _arg1;
8722     PyObject * _argo0 = 0;
8723     int tempbool1;
8724     char *_kwnames[] = { "self","expandSelection", NULL };
8725
8726     self = self;
8727     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorUp",_kwnames,&_argo0,&tempbool1))
8728         return NULL;
8729     if (_argo0) {
8730         if (_argo0 == Py_None) { _arg0 = NULL; }
8731         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8732             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorUp. Expected _wxGrid_p.");
8733         return NULL;
8734         }
8735     }
8736     _arg1 = (bool ) tempbool1;
8737 {
8738     wxPy_BEGIN_ALLOW_THREADS;
8739         _result = (bool )wxGrid_MoveCursorUp(_arg0,_arg1);
8740
8741     wxPy_END_ALLOW_THREADS;
8742     if (PyErr_Occurred()) return NULL;
8743 }    _resultobj = Py_BuildValue("i",_result);
8744     return _resultobj;
8745 }
8746
8747 #define wxGrid_MoveCursorDown(_swigobj,_swigarg0)  (_swigobj->MoveCursorDown(_swigarg0))
8748 static PyObject *_wrap_wxGrid_MoveCursorDown(PyObject *self, PyObject *args, PyObject *kwargs) {
8749     PyObject * _resultobj;
8750     bool  _result;
8751     wxGrid * _arg0;
8752     bool  _arg1;
8753     PyObject * _argo0 = 0;
8754     int tempbool1;
8755     char *_kwnames[] = { "self","expandSelection", NULL };
8756
8757     self = self;
8758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorDown",_kwnames,&_argo0,&tempbool1))
8759         return NULL;
8760     if (_argo0) {
8761         if (_argo0 == Py_None) { _arg0 = NULL; }
8762         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8763             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorDown. Expected _wxGrid_p.");
8764         return NULL;
8765         }
8766     }
8767     _arg1 = (bool ) tempbool1;
8768 {
8769     wxPy_BEGIN_ALLOW_THREADS;
8770         _result = (bool )wxGrid_MoveCursorDown(_arg0,_arg1);
8771
8772     wxPy_END_ALLOW_THREADS;
8773     if (PyErr_Occurred()) return NULL;
8774 }    _resultobj = Py_BuildValue("i",_result);
8775     return _resultobj;
8776 }
8777
8778 #define wxGrid_MoveCursorLeft(_swigobj,_swigarg0)  (_swigobj->MoveCursorLeft(_swigarg0))
8779 static PyObject *_wrap_wxGrid_MoveCursorLeft(PyObject *self, PyObject *args, PyObject *kwargs) {
8780     PyObject * _resultobj;
8781     bool  _result;
8782     wxGrid * _arg0;
8783     bool  _arg1;
8784     PyObject * _argo0 = 0;
8785     int tempbool1;
8786     char *_kwnames[] = { "self","expandSelection", NULL };
8787
8788     self = self;
8789     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorLeft",_kwnames,&_argo0,&tempbool1))
8790         return NULL;
8791     if (_argo0) {
8792         if (_argo0 == Py_None) { _arg0 = NULL; }
8793         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8794             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorLeft. Expected _wxGrid_p.");
8795         return NULL;
8796         }
8797     }
8798     _arg1 = (bool ) tempbool1;
8799 {
8800     wxPy_BEGIN_ALLOW_THREADS;
8801         _result = (bool )wxGrid_MoveCursorLeft(_arg0,_arg1);
8802
8803     wxPy_END_ALLOW_THREADS;
8804     if (PyErr_Occurred()) return NULL;
8805 }    _resultobj = Py_BuildValue("i",_result);
8806     return _resultobj;
8807 }
8808
8809 #define wxGrid_MoveCursorRight(_swigobj,_swigarg0)  (_swigobj->MoveCursorRight(_swigarg0))
8810 static PyObject *_wrap_wxGrid_MoveCursorRight(PyObject *self, PyObject *args, PyObject *kwargs) {
8811     PyObject * _resultobj;
8812     bool  _result;
8813     wxGrid * _arg0;
8814     bool  _arg1;
8815     PyObject * _argo0 = 0;
8816     int tempbool1;
8817     char *_kwnames[] = { "self","expandSelection", NULL };
8818
8819     self = self;
8820     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorRight",_kwnames,&_argo0,&tempbool1))
8821         return NULL;
8822     if (_argo0) {
8823         if (_argo0 == Py_None) { _arg0 = NULL; }
8824         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8825             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorRight. Expected _wxGrid_p.");
8826         return NULL;
8827         }
8828     }
8829     _arg1 = (bool ) tempbool1;
8830 {
8831     wxPy_BEGIN_ALLOW_THREADS;
8832         _result = (bool )wxGrid_MoveCursorRight(_arg0,_arg1);
8833
8834     wxPy_END_ALLOW_THREADS;
8835     if (PyErr_Occurred()) return NULL;
8836 }    _resultobj = Py_BuildValue("i",_result);
8837     return _resultobj;
8838 }
8839
8840 #define wxGrid_MovePageDown(_swigobj)  (_swigobj->MovePageDown())
8841 static PyObject *_wrap_wxGrid_MovePageDown(PyObject *self, PyObject *args, PyObject *kwargs) {
8842     PyObject * _resultobj;
8843     bool  _result;
8844     wxGrid * _arg0;
8845     PyObject * _argo0 = 0;
8846     char *_kwnames[] = { "self", NULL };
8847
8848     self = self;
8849     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_MovePageDown",_kwnames,&_argo0))
8850         return NULL;
8851     if (_argo0) {
8852         if (_argo0 == Py_None) { _arg0 = NULL; }
8853         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8854             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MovePageDown. Expected _wxGrid_p.");
8855         return NULL;
8856         }
8857     }
8858 {
8859     wxPy_BEGIN_ALLOW_THREADS;
8860         _result = (bool )wxGrid_MovePageDown(_arg0);
8861
8862     wxPy_END_ALLOW_THREADS;
8863     if (PyErr_Occurred()) return NULL;
8864 }    _resultobj = Py_BuildValue("i",_result);
8865     return _resultobj;
8866 }
8867
8868 #define wxGrid_MovePageUp(_swigobj)  (_swigobj->MovePageUp())
8869 static PyObject *_wrap_wxGrid_MovePageUp(PyObject *self, PyObject *args, PyObject *kwargs) {
8870     PyObject * _resultobj;
8871     bool  _result;
8872     wxGrid * _arg0;
8873     PyObject * _argo0 = 0;
8874     char *_kwnames[] = { "self", NULL };
8875
8876     self = self;
8877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_MovePageUp",_kwnames,&_argo0))
8878         return NULL;
8879     if (_argo0) {
8880         if (_argo0 == Py_None) { _arg0 = NULL; }
8881         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8882             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MovePageUp. Expected _wxGrid_p.");
8883         return NULL;
8884         }
8885     }
8886 {
8887     wxPy_BEGIN_ALLOW_THREADS;
8888         _result = (bool )wxGrid_MovePageUp(_arg0);
8889
8890     wxPy_END_ALLOW_THREADS;
8891     if (PyErr_Occurred()) return NULL;
8892 }    _resultobj = Py_BuildValue("i",_result);
8893     return _resultobj;
8894 }
8895
8896 #define wxGrid_MoveCursorUpBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorUpBlock(_swigarg0))
8897 static PyObject *_wrap_wxGrid_MoveCursorUpBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8898     PyObject * _resultobj;
8899     bool  _result;
8900     wxGrid * _arg0;
8901     bool  _arg1;
8902     PyObject * _argo0 = 0;
8903     int tempbool1;
8904     char *_kwnames[] = { "self","expandSelection", NULL };
8905
8906     self = self;
8907     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorUpBlock",_kwnames,&_argo0,&tempbool1))
8908         return NULL;
8909     if (_argo0) {
8910         if (_argo0 == Py_None) { _arg0 = NULL; }
8911         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8912             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorUpBlock. Expected _wxGrid_p.");
8913         return NULL;
8914         }
8915     }
8916     _arg1 = (bool ) tempbool1;
8917 {
8918     wxPy_BEGIN_ALLOW_THREADS;
8919         _result = (bool )wxGrid_MoveCursorUpBlock(_arg0,_arg1);
8920
8921     wxPy_END_ALLOW_THREADS;
8922     if (PyErr_Occurred()) return NULL;
8923 }    _resultobj = Py_BuildValue("i",_result);
8924     return _resultobj;
8925 }
8926
8927 #define wxGrid_MoveCursorDownBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorDownBlock(_swigarg0))
8928 static PyObject *_wrap_wxGrid_MoveCursorDownBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8929     PyObject * _resultobj;
8930     bool  _result;
8931     wxGrid * _arg0;
8932     bool  _arg1;
8933     PyObject * _argo0 = 0;
8934     int tempbool1;
8935     char *_kwnames[] = { "self","expandSelection", NULL };
8936
8937     self = self;
8938     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorDownBlock",_kwnames,&_argo0,&tempbool1))
8939         return NULL;
8940     if (_argo0) {
8941         if (_argo0 == Py_None) { _arg0 = NULL; }
8942         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8943             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorDownBlock. Expected _wxGrid_p.");
8944         return NULL;
8945         }
8946     }
8947     _arg1 = (bool ) tempbool1;
8948 {
8949     wxPy_BEGIN_ALLOW_THREADS;
8950         _result = (bool )wxGrid_MoveCursorDownBlock(_arg0,_arg1);
8951
8952     wxPy_END_ALLOW_THREADS;
8953     if (PyErr_Occurred()) return NULL;
8954 }    _resultobj = Py_BuildValue("i",_result);
8955     return _resultobj;
8956 }
8957
8958 #define wxGrid_MoveCursorLeftBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorLeftBlock(_swigarg0))
8959 static PyObject *_wrap_wxGrid_MoveCursorLeftBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8960     PyObject * _resultobj;
8961     bool  _result;
8962     wxGrid * _arg0;
8963     bool  _arg1;
8964     PyObject * _argo0 = 0;
8965     int tempbool1;
8966     char *_kwnames[] = { "self","expandSelection", NULL };
8967
8968     self = self;
8969     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorLeftBlock",_kwnames,&_argo0,&tempbool1))
8970         return NULL;
8971     if (_argo0) {
8972         if (_argo0 == Py_None) { _arg0 = NULL; }
8973         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8974             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorLeftBlock. Expected _wxGrid_p.");
8975         return NULL;
8976         }
8977     }
8978     _arg1 = (bool ) tempbool1;
8979 {
8980     wxPy_BEGIN_ALLOW_THREADS;
8981         _result = (bool )wxGrid_MoveCursorLeftBlock(_arg0,_arg1);
8982
8983     wxPy_END_ALLOW_THREADS;
8984     if (PyErr_Occurred()) return NULL;
8985 }    _resultobj = Py_BuildValue("i",_result);
8986     return _resultobj;
8987 }
8988
8989 #define wxGrid_MoveCursorRightBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorRightBlock(_swigarg0))
8990 static PyObject *_wrap_wxGrid_MoveCursorRightBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8991     PyObject * _resultobj;
8992     bool  _result;
8993     wxGrid * _arg0;
8994     bool  _arg1;
8995     PyObject * _argo0 = 0;
8996     int tempbool1;
8997     char *_kwnames[] = { "self","expandSelection", NULL };
8998
8999     self = self;
9000     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorRightBlock",_kwnames,&_argo0,&tempbool1))
9001         return NULL;
9002     if (_argo0) {
9003         if (_argo0 == Py_None) { _arg0 = NULL; }
9004         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9005             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorRightBlock. Expected _wxGrid_p.");
9006         return NULL;
9007         }
9008     }
9009     _arg1 = (bool ) tempbool1;
9010 {
9011     wxPy_BEGIN_ALLOW_THREADS;
9012         _result = (bool )wxGrid_MoveCursorRightBlock(_arg0,_arg1);
9013
9014     wxPy_END_ALLOW_THREADS;
9015     if (PyErr_Occurred()) return NULL;
9016 }    _resultobj = Py_BuildValue("i",_result);
9017     return _resultobj;
9018 }
9019
9020 #define wxGrid_GetDefaultRowLabelSize(_swigobj)  (_swigobj->GetDefaultRowLabelSize())
9021 static PyObject *_wrap_wxGrid_GetDefaultRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9022     PyObject * _resultobj;
9023     int  _result;
9024     wxGrid * _arg0;
9025     PyObject * _argo0 = 0;
9026     char *_kwnames[] = { "self", NULL };
9027
9028     self = self;
9029     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRowLabelSize",_kwnames,&_argo0))
9030         return NULL;
9031     if (_argo0) {
9032         if (_argo0 == Py_None) { _arg0 = NULL; }
9033         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9034             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRowLabelSize. Expected _wxGrid_p.");
9035         return NULL;
9036         }
9037     }
9038 {
9039     wxPy_BEGIN_ALLOW_THREADS;
9040         _result = (int )wxGrid_GetDefaultRowLabelSize(_arg0);
9041
9042     wxPy_END_ALLOW_THREADS;
9043     if (PyErr_Occurred()) return NULL;
9044 }    _resultobj = Py_BuildValue("i",_result);
9045     return _resultobj;
9046 }
9047
9048 #define wxGrid_GetRowLabelSize(_swigobj)  (_swigobj->GetRowLabelSize())
9049 static PyObject *_wrap_wxGrid_GetRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9050     PyObject * _resultobj;
9051     int  _result;
9052     wxGrid * _arg0;
9053     PyObject * _argo0 = 0;
9054     char *_kwnames[] = { "self", NULL };
9055
9056     self = self;
9057     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetRowLabelSize",_kwnames,&_argo0))
9058         return NULL;
9059     if (_argo0) {
9060         if (_argo0 == Py_None) { _arg0 = NULL; }
9061         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9062             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelSize. Expected _wxGrid_p.");
9063         return NULL;
9064         }
9065     }
9066 {
9067     wxPy_BEGIN_ALLOW_THREADS;
9068         _result = (int )wxGrid_GetRowLabelSize(_arg0);
9069
9070     wxPy_END_ALLOW_THREADS;
9071     if (PyErr_Occurred()) return NULL;
9072 }    _resultobj = Py_BuildValue("i",_result);
9073     return _resultobj;
9074 }
9075
9076 #define wxGrid_GetDefaultColLabelSize(_swigobj)  (_swigobj->GetDefaultColLabelSize())
9077 static PyObject *_wrap_wxGrid_GetDefaultColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9078     PyObject * _resultobj;
9079     int  _result;
9080     wxGrid * _arg0;
9081     PyObject * _argo0 = 0;
9082     char *_kwnames[] = { "self", NULL };
9083
9084     self = self;
9085     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultColLabelSize",_kwnames,&_argo0))
9086         return NULL;
9087     if (_argo0) {
9088         if (_argo0 == Py_None) { _arg0 = NULL; }
9089         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9090             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultColLabelSize. Expected _wxGrid_p.");
9091         return NULL;
9092         }
9093     }
9094 {
9095     wxPy_BEGIN_ALLOW_THREADS;
9096         _result = (int )wxGrid_GetDefaultColLabelSize(_arg0);
9097
9098     wxPy_END_ALLOW_THREADS;
9099     if (PyErr_Occurred()) return NULL;
9100 }    _resultobj = Py_BuildValue("i",_result);
9101     return _resultobj;
9102 }
9103
9104 #define wxGrid_GetColLabelSize(_swigobj)  (_swigobj->GetColLabelSize())
9105 static PyObject *_wrap_wxGrid_GetColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9106     PyObject * _resultobj;
9107     int  _result;
9108     wxGrid * _arg0;
9109     PyObject * _argo0 = 0;
9110     char *_kwnames[] = { "self", NULL };
9111
9112     self = self;
9113     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetColLabelSize",_kwnames,&_argo0))
9114         return NULL;
9115     if (_argo0) {
9116         if (_argo0 == Py_None) { _arg0 = NULL; }
9117         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9118             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelSize. Expected _wxGrid_p.");
9119         return NULL;
9120         }
9121     }
9122 {
9123     wxPy_BEGIN_ALLOW_THREADS;
9124         _result = (int )wxGrid_GetColLabelSize(_arg0);
9125
9126     wxPy_END_ALLOW_THREADS;
9127     if (PyErr_Occurred()) return NULL;
9128 }    _resultobj = Py_BuildValue("i",_result);
9129     return _resultobj;
9130 }
9131
9132 #define wxGrid_GetLabelBackgroundColour(_swigobj)  (_swigobj->GetLabelBackgroundColour())
9133 static PyObject *_wrap_wxGrid_GetLabelBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9134     PyObject * _resultobj;
9135     wxColour * _result;
9136     wxGrid * _arg0;
9137     PyObject * _argo0 = 0;
9138     char *_kwnames[] = { "self", NULL };
9139     char _ptemp[128];
9140
9141     self = self;
9142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelBackgroundColour",_kwnames,&_argo0))
9143         return NULL;
9144     if (_argo0) {
9145         if (_argo0 == Py_None) { _arg0 = NULL; }
9146         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9147             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelBackgroundColour. Expected _wxGrid_p.");
9148         return NULL;
9149         }
9150     }
9151 {
9152     wxPy_BEGIN_ALLOW_THREADS;
9153         _result = new wxColour (wxGrid_GetLabelBackgroundColour(_arg0));
9154
9155     wxPy_END_ALLOW_THREADS;
9156     if (PyErr_Occurred()) return NULL;
9157 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9158     _resultobj = Py_BuildValue("s",_ptemp);
9159     return _resultobj;
9160 }
9161
9162 #define wxGrid_GetLabelTextColour(_swigobj)  (_swigobj->GetLabelTextColour())
9163 static PyObject *_wrap_wxGrid_GetLabelTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9164     PyObject * _resultobj;
9165     wxColour * _result;
9166     wxGrid * _arg0;
9167     PyObject * _argo0 = 0;
9168     char *_kwnames[] = { "self", NULL };
9169     char _ptemp[128];
9170
9171     self = self;
9172     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelTextColour",_kwnames,&_argo0))
9173         return NULL;
9174     if (_argo0) {
9175         if (_argo0 == Py_None) { _arg0 = NULL; }
9176         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9177             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelTextColour. Expected _wxGrid_p.");
9178         return NULL;
9179         }
9180     }
9181 {
9182     wxPy_BEGIN_ALLOW_THREADS;
9183         _result = new wxColour (wxGrid_GetLabelTextColour(_arg0));
9184
9185     wxPy_END_ALLOW_THREADS;
9186     if (PyErr_Occurred()) return NULL;
9187 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9188     _resultobj = Py_BuildValue("s",_ptemp);
9189     return _resultobj;
9190 }
9191
9192 #define wxGrid_GetLabelFont(_swigobj)  (_swigobj->GetLabelFont())
9193 static PyObject *_wrap_wxGrid_GetLabelFont(PyObject *self, PyObject *args, PyObject *kwargs) {
9194     PyObject * _resultobj;
9195     wxFont * _result;
9196     wxGrid * _arg0;
9197     PyObject * _argo0 = 0;
9198     char *_kwnames[] = { "self", NULL };
9199     char _ptemp[128];
9200
9201     self = self;
9202     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelFont",_kwnames,&_argo0))
9203         return NULL;
9204     if (_argo0) {
9205         if (_argo0 == Py_None) { _arg0 = NULL; }
9206         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9207             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelFont. Expected _wxGrid_p.");
9208         return NULL;
9209         }
9210     }
9211 {
9212     wxPy_BEGIN_ALLOW_THREADS;
9213         _result = new wxFont (wxGrid_GetLabelFont(_arg0));
9214
9215     wxPy_END_ALLOW_THREADS;
9216     if (PyErr_Occurred()) return NULL;
9217 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
9218     _resultobj = Py_BuildValue("s",_ptemp);
9219     return _resultobj;
9220 }
9221
9222 #define wxGrid_GetRowLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRowLabelAlignment(_swigarg0,_swigarg1))
9223 static PyObject *_wrap_wxGrid_GetRowLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9224     PyObject * _resultobj;
9225     wxGrid * _arg0;
9226     int * _arg1;
9227     int  temp;
9228     int * _arg2;
9229     int  temp0;
9230     PyObject * _argo0 = 0;
9231     char *_kwnames[] = { "self", NULL };
9232
9233     self = self;
9234 {
9235   _arg1 = &temp;
9236 }
9237 {
9238   _arg2 = &temp0;
9239 }
9240     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetRowLabelAlignment",_kwnames,&_argo0))
9241         return NULL;
9242     if (_argo0) {
9243         if (_argo0 == Py_None) { _arg0 = NULL; }
9244         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9245             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelAlignment. Expected _wxGrid_p.");
9246         return NULL;
9247         }
9248     }
9249 {
9250     wxPy_BEGIN_ALLOW_THREADS;
9251         wxGrid_GetRowLabelAlignment(_arg0,_arg1,_arg2);
9252
9253     wxPy_END_ALLOW_THREADS;
9254     if (PyErr_Occurred()) return NULL;
9255 }    Py_INCREF(Py_None);
9256     _resultobj = Py_None;
9257 {
9258     PyObject *o;
9259     o = PyInt_FromLong((long) (*_arg1));
9260     _resultobj = t_output_helper(_resultobj, o);
9261 }
9262 {
9263     PyObject *o;
9264     o = PyInt_FromLong((long) (*_arg2));
9265     _resultobj = t_output_helper(_resultobj, o);
9266 }
9267     return _resultobj;
9268 }
9269
9270 #define wxGrid_GetColLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetColLabelAlignment(_swigarg0,_swigarg1))
9271 static PyObject *_wrap_wxGrid_GetColLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9272     PyObject * _resultobj;
9273     wxGrid * _arg0;
9274     int * _arg1;
9275     int  temp;
9276     int * _arg2;
9277     int  temp0;
9278     PyObject * _argo0 = 0;
9279     char *_kwnames[] = { "self", NULL };
9280
9281     self = self;
9282 {
9283   _arg1 = &temp;
9284 }
9285 {
9286   _arg2 = &temp0;
9287 }
9288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetColLabelAlignment",_kwnames,&_argo0))
9289         return NULL;
9290     if (_argo0) {
9291         if (_argo0 == Py_None) { _arg0 = NULL; }
9292         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9293             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelAlignment. Expected _wxGrid_p.");
9294         return NULL;
9295         }
9296     }
9297 {
9298     wxPy_BEGIN_ALLOW_THREADS;
9299         wxGrid_GetColLabelAlignment(_arg0,_arg1,_arg2);
9300
9301     wxPy_END_ALLOW_THREADS;
9302     if (PyErr_Occurred()) return NULL;
9303 }    Py_INCREF(Py_None);
9304     _resultobj = Py_None;
9305 {
9306     PyObject *o;
9307     o = PyInt_FromLong((long) (*_arg1));
9308     _resultobj = t_output_helper(_resultobj, o);
9309 }
9310 {
9311     PyObject *o;
9312     o = PyInt_FromLong((long) (*_arg2));
9313     _resultobj = t_output_helper(_resultobj, o);
9314 }
9315     return _resultobj;
9316 }
9317
9318 #define wxGrid_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->GetRowLabelValue(_swigarg0))
9319 static PyObject *_wrap_wxGrid_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9320     PyObject * _resultobj;
9321     wxString * _result;
9322     wxGrid * _arg0;
9323     int  _arg1;
9324     PyObject * _argo0 = 0;
9325     char *_kwnames[] = { "self","row", NULL };
9326
9327     self = self;
9328     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
9329         return NULL;
9330     if (_argo0) {
9331         if (_argo0 == Py_None) { _arg0 = NULL; }
9332         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9333             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelValue. Expected _wxGrid_p.");
9334         return NULL;
9335         }
9336     }
9337 {
9338     wxPy_BEGIN_ALLOW_THREADS;
9339         _result = new wxString (wxGrid_GetRowLabelValue(_arg0,_arg1));
9340
9341     wxPy_END_ALLOW_THREADS;
9342     if (PyErr_Occurred()) return NULL;
9343 }{
9344     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
9345 }
9346 {
9347     delete _result;
9348 }
9349     return _resultobj;
9350 }
9351
9352 #define wxGrid_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->GetColLabelValue(_swigarg0))
9353 static PyObject *_wrap_wxGrid_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9354     PyObject * _resultobj;
9355     wxString * _result;
9356     wxGrid * _arg0;
9357     int  _arg1;
9358     PyObject * _argo0 = 0;
9359     char *_kwnames[] = { "self","col", NULL };
9360
9361     self = self;
9362     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetColLabelValue",_kwnames,&_argo0,&_arg1))
9363         return NULL;
9364     if (_argo0) {
9365         if (_argo0 == Py_None) { _arg0 = NULL; }
9366         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9367             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelValue. Expected _wxGrid_p.");
9368         return NULL;
9369         }
9370     }
9371 {
9372     wxPy_BEGIN_ALLOW_THREADS;
9373         _result = new wxString (wxGrid_GetColLabelValue(_arg0,_arg1));
9374
9375     wxPy_END_ALLOW_THREADS;
9376     if (PyErr_Occurred()) return NULL;
9377 }{
9378     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
9379 }
9380 {
9381     delete _result;
9382 }
9383     return _resultobj;
9384 }
9385
9386 #define wxGrid_GetGridLineColour(_swigobj)  (_swigobj->GetGridLineColour())
9387 static PyObject *_wrap_wxGrid_GetGridLineColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9388     PyObject * _resultobj;
9389     wxColour * _result;
9390     wxGrid * _arg0;
9391     PyObject * _argo0 = 0;
9392     char *_kwnames[] = { "self", NULL };
9393     char _ptemp[128];
9394
9395     self = self;
9396     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridLineColour",_kwnames,&_argo0))
9397         return NULL;
9398     if (_argo0) {
9399         if (_argo0 == Py_None) { _arg0 = NULL; }
9400         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9401             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridLineColour. Expected _wxGrid_p.");
9402         return NULL;
9403         }
9404     }
9405 {
9406     wxPy_BEGIN_ALLOW_THREADS;
9407         _result = new wxColour (wxGrid_GetGridLineColour(_arg0));
9408
9409     wxPy_END_ALLOW_THREADS;
9410     if (PyErr_Occurred()) return NULL;
9411 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9412     _resultobj = Py_BuildValue("s",_ptemp);
9413     return _resultobj;
9414 }
9415
9416 #define wxGrid_GetCellHighlightColour(_swigobj)  (_swigobj->GetCellHighlightColour())
9417 static PyObject *_wrap_wxGrid_GetCellHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9418     PyObject * _resultobj;
9419     wxColour * _result;
9420     wxGrid * _arg0;
9421     PyObject * _argo0 = 0;
9422     char *_kwnames[] = { "self", NULL };
9423     char _ptemp[128];
9424
9425     self = self;
9426     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightColour",_kwnames,&_argo0))
9427         return NULL;
9428     if (_argo0) {
9429         if (_argo0 == Py_None) { _arg0 = NULL; }
9430         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9431             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightColour. Expected _wxGrid_p.");
9432         return NULL;
9433         }
9434     }
9435 {
9436     wxPy_BEGIN_ALLOW_THREADS;
9437         _result = new wxColour (wxGrid_GetCellHighlightColour(_arg0));
9438
9439     wxPy_END_ALLOW_THREADS;
9440     if (PyErr_Occurred()) return NULL;
9441 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9442     _resultobj = Py_BuildValue("s",_ptemp);
9443     return _resultobj;
9444 }
9445
9446 #define wxGrid_GetCellHighlightPenWidth(_swigobj)  (_swigobj->GetCellHighlightPenWidth())
9447 static PyObject *_wrap_wxGrid_GetCellHighlightPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9448     PyObject * _resultobj;
9449     int  _result;
9450     wxGrid * _arg0;
9451     PyObject * _argo0 = 0;
9452     char *_kwnames[] = { "self", NULL };
9453
9454     self = self;
9455     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightPenWidth",_kwnames,&_argo0))
9456         return NULL;
9457     if (_argo0) {
9458         if (_argo0 == Py_None) { _arg0 = NULL; }
9459         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9460             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightPenWidth. Expected _wxGrid_p.");
9461         return NULL;
9462         }
9463     }
9464 {
9465     wxPy_BEGIN_ALLOW_THREADS;
9466         _result = (int )wxGrid_GetCellHighlightPenWidth(_arg0);
9467
9468     wxPy_END_ALLOW_THREADS;
9469     if (PyErr_Occurred()) return NULL;
9470 }    _resultobj = Py_BuildValue("i",_result);
9471     return _resultobj;
9472 }
9473
9474 #define wxGrid_GetCellHighlightROPenWidth(_swigobj)  (_swigobj->GetCellHighlightROPenWidth())
9475 static PyObject *_wrap_wxGrid_GetCellHighlightROPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9476     PyObject * _resultobj;
9477     int  _result;
9478     wxGrid * _arg0;
9479     PyObject * _argo0 = 0;
9480     char *_kwnames[] = { "self", NULL };
9481
9482     self = self;
9483     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightROPenWidth",_kwnames,&_argo0))
9484         return NULL;
9485     if (_argo0) {
9486         if (_argo0 == Py_None) { _arg0 = NULL; }
9487         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9488             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightROPenWidth. Expected _wxGrid_p.");
9489         return NULL;
9490         }
9491     }
9492 {
9493     wxPy_BEGIN_ALLOW_THREADS;
9494         _result = (int )wxGrid_GetCellHighlightROPenWidth(_arg0);
9495
9496     wxPy_END_ALLOW_THREADS;
9497     if (PyErr_Occurred()) return NULL;
9498 }    _resultobj = Py_BuildValue("i",_result);
9499     return _resultobj;
9500 }
9501
9502 #define wxGrid_SetRowLabelSize(_swigobj,_swigarg0)  (_swigobj->SetRowLabelSize(_swigarg0))
9503 static PyObject *_wrap_wxGrid_SetRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9504     PyObject * _resultobj;
9505     wxGrid * _arg0;
9506     int  _arg1;
9507     PyObject * _argo0 = 0;
9508     char *_kwnames[] = { "self","width", NULL };
9509
9510     self = self;
9511     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetRowLabelSize",_kwnames,&_argo0,&_arg1))
9512         return NULL;
9513     if (_argo0) {
9514         if (_argo0 == Py_None) { _arg0 = NULL; }
9515         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9516             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelSize. Expected _wxGrid_p.");
9517         return NULL;
9518         }
9519     }
9520 {
9521     wxPy_BEGIN_ALLOW_THREADS;
9522         wxGrid_SetRowLabelSize(_arg0,_arg1);
9523
9524     wxPy_END_ALLOW_THREADS;
9525     if (PyErr_Occurred()) return NULL;
9526 }    Py_INCREF(Py_None);
9527     _resultobj = Py_None;
9528     return _resultobj;
9529 }
9530
9531 #define wxGrid_SetColLabelSize(_swigobj,_swigarg0)  (_swigobj->SetColLabelSize(_swigarg0))
9532 static PyObject *_wrap_wxGrid_SetColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9533     PyObject * _resultobj;
9534     wxGrid * _arg0;
9535     int  _arg1;
9536     PyObject * _argo0 = 0;
9537     char *_kwnames[] = { "self","height", NULL };
9538
9539     self = self;
9540     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColLabelSize",_kwnames,&_argo0,&_arg1))
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_SetColLabelSize. Expected _wxGrid_p.");
9546         return NULL;
9547         }
9548     }
9549 {
9550     wxPy_BEGIN_ALLOW_THREADS;
9551         wxGrid_SetColLabelSize(_arg0,_arg1);
9552
9553     wxPy_END_ALLOW_THREADS;
9554     if (PyErr_Occurred()) return NULL;
9555 }    Py_INCREF(Py_None);
9556     _resultobj = Py_None;
9557     return _resultobj;
9558 }
9559
9560 #define wxGrid_SetLabelBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetLabelBackgroundColour(_swigarg0))
9561 static PyObject *_wrap_wxGrid_SetLabelBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9562     PyObject * _resultobj;
9563     wxGrid * _arg0;
9564     wxColour * _arg1;
9565     PyObject * _argo0 = 0;
9566     wxColour  temp;
9567     PyObject * _obj1 = 0;
9568     char *_kwnames[] = { "self","arg2", NULL };
9569
9570     self = self;
9571     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelBackgroundColour",_kwnames,&_argo0,&_obj1))
9572         return NULL;
9573     if (_argo0) {
9574         if (_argo0 == Py_None) { _arg0 = NULL; }
9575         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9576             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelBackgroundColour. Expected _wxGrid_p.");
9577         return NULL;
9578         }
9579     }
9580 {
9581     _arg1 = &temp;
9582     if (! wxColour_helper(_obj1, &_arg1))
9583         return NULL;
9584 }
9585 {
9586     wxPy_BEGIN_ALLOW_THREADS;
9587         wxGrid_SetLabelBackgroundColour(_arg0,*_arg1);
9588
9589     wxPy_END_ALLOW_THREADS;
9590     if (PyErr_Occurred()) return NULL;
9591 }    Py_INCREF(Py_None);
9592     _resultobj = Py_None;
9593     return _resultobj;
9594 }
9595
9596 #define wxGrid_SetLabelTextColour(_swigobj,_swigarg0)  (_swigobj->SetLabelTextColour(_swigarg0))
9597 static PyObject *_wrap_wxGrid_SetLabelTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9598     PyObject * _resultobj;
9599     wxGrid * _arg0;
9600     wxColour * _arg1;
9601     PyObject * _argo0 = 0;
9602     wxColour  temp;
9603     PyObject * _obj1 = 0;
9604     char *_kwnames[] = { "self","arg2", NULL };
9605
9606     self = self;
9607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelTextColour",_kwnames,&_argo0,&_obj1))
9608         return NULL;
9609     if (_argo0) {
9610         if (_argo0 == Py_None) { _arg0 = NULL; }
9611         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9612             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelTextColour. Expected _wxGrid_p.");
9613         return NULL;
9614         }
9615     }
9616 {
9617     _arg1 = &temp;
9618     if (! wxColour_helper(_obj1, &_arg1))
9619         return NULL;
9620 }
9621 {
9622     wxPy_BEGIN_ALLOW_THREADS;
9623         wxGrid_SetLabelTextColour(_arg0,*_arg1);
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_SetLabelFont(_swigobj,_swigarg0)  (_swigobj->SetLabelFont(_swigarg0))
9633 static PyObject *_wrap_wxGrid_SetLabelFont(PyObject *self, PyObject *args, PyObject *kwargs) {
9634     PyObject * _resultobj;
9635     wxGrid * _arg0;
9636     wxFont * _arg1;
9637     PyObject * _argo0 = 0;
9638     PyObject * _argo1 = 0;
9639     char *_kwnames[] = { "self","arg2", NULL };
9640
9641     self = self;
9642     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelFont",_kwnames,&_argo0,&_argo1))
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_SetLabelFont. Expected _wxGrid_p.");
9648         return NULL;
9649         }
9650     }
9651     if (_argo1) {
9652         if (_argo1 == Py_None) { _arg1 = NULL; }
9653         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
9654             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetLabelFont. Expected _wxFont_p.");
9655         return NULL;
9656         }
9657     }
9658 {
9659     wxPy_BEGIN_ALLOW_THREADS;
9660         wxGrid_SetLabelFont(_arg0,*_arg1);
9661
9662     wxPy_END_ALLOW_THREADS;
9663     if (PyErr_Occurred()) return NULL;
9664 }    Py_INCREF(Py_None);
9665     _resultobj = Py_None;
9666     return _resultobj;
9667 }
9668
9669 #define wxGrid_SetRowLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelAlignment(_swigarg0,_swigarg1))
9670 static PyObject *_wrap_wxGrid_SetRowLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9671     PyObject * _resultobj;
9672     wxGrid * _arg0;
9673     int  _arg1;
9674     int  _arg2;
9675     PyObject * _argo0 = 0;
9676     char *_kwnames[] = { "self","horiz","vert", NULL };
9677
9678     self = self;
9679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowLabelAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
9680         return NULL;
9681     if (_argo0) {
9682         if (_argo0 == Py_None) { _arg0 = NULL; }
9683         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9684             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelAlignment. Expected _wxGrid_p.");
9685         return NULL;
9686         }
9687     }
9688 {
9689     wxPy_BEGIN_ALLOW_THREADS;
9690         wxGrid_SetRowLabelAlignment(_arg0,_arg1,_arg2);
9691
9692     wxPy_END_ALLOW_THREADS;
9693     if (PyErr_Occurred()) return NULL;
9694 }    Py_INCREF(Py_None);
9695     _resultobj = Py_None;
9696     return _resultobj;
9697 }
9698
9699 #define wxGrid_SetColLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelAlignment(_swigarg0,_swigarg1))
9700 static PyObject *_wrap_wxGrid_SetColLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9701     PyObject * _resultobj;
9702     wxGrid * _arg0;
9703     int  _arg1;
9704     int  _arg2;
9705     PyObject * _argo0 = 0;
9706     char *_kwnames[] = { "self","horiz","vert", NULL };
9707
9708     self = self;
9709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColLabelAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
9710         return NULL;
9711     if (_argo0) {
9712         if (_argo0 == Py_None) { _arg0 = NULL; }
9713         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9714             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelAlignment. Expected _wxGrid_p.");
9715         return NULL;
9716         }
9717     }
9718 {
9719     wxPy_BEGIN_ALLOW_THREADS;
9720         wxGrid_SetColLabelAlignment(_arg0,_arg1,_arg2);
9721
9722     wxPy_END_ALLOW_THREADS;
9723     if (PyErr_Occurred()) return NULL;
9724 }    Py_INCREF(Py_None);
9725     _resultobj = Py_None;
9726     return _resultobj;
9727 }
9728
9729 #define wxGrid_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelValue(_swigarg0,_swigarg1))
9730 static PyObject *_wrap_wxGrid_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9731     PyObject * _resultobj;
9732     wxGrid * _arg0;
9733     int  _arg1;
9734     wxString * _arg2;
9735     PyObject * _argo0 = 0;
9736     PyObject * _obj2 = 0;
9737     char *_kwnames[] = { "self","row","arg3", NULL };
9738
9739     self = self;
9740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
9741         return NULL;
9742     if (_argo0) {
9743         if (_argo0 == Py_None) { _arg0 = NULL; }
9744         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9745             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelValue. Expected _wxGrid_p.");
9746         return NULL;
9747         }
9748     }
9749 {
9750 #if PYTHON_API_VERSION >= 1009
9751     char* tmpPtr; int tmpSize;
9752     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
9753         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9754         return NULL;
9755     }
9756     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
9757         return NULL;
9758     _arg2 = new wxString(tmpPtr, tmpSize);
9759 #else
9760     if (!PyString_Check(_obj2)) {
9761         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9762         return NULL;
9763     }
9764     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
9765 #endif
9766 }
9767 {
9768     wxPy_BEGIN_ALLOW_THREADS;
9769         wxGrid_SetRowLabelValue(_arg0,_arg1,*_arg2);
9770
9771     wxPy_END_ALLOW_THREADS;
9772     if (PyErr_Occurred()) return NULL;
9773 }    Py_INCREF(Py_None);
9774     _resultobj = Py_None;
9775 {
9776     if (_obj2)
9777         delete _arg2;
9778 }
9779     return _resultobj;
9780 }
9781
9782 #define wxGrid_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelValue(_swigarg0,_swigarg1))
9783 static PyObject *_wrap_wxGrid_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9784     PyObject * _resultobj;
9785     wxGrid * _arg0;
9786     int  _arg1;
9787     wxString * _arg2;
9788     PyObject * _argo0 = 0;
9789     PyObject * _obj2 = 0;
9790     char *_kwnames[] = { "self","col","arg3", NULL };
9791
9792     self = self;
9793     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
9794         return NULL;
9795     if (_argo0) {
9796         if (_argo0 == Py_None) { _arg0 = NULL; }
9797         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9798             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelValue. Expected _wxGrid_p.");
9799         return NULL;
9800         }
9801     }
9802 {
9803 #if PYTHON_API_VERSION >= 1009
9804     char* tmpPtr; int tmpSize;
9805     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
9806         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9807         return NULL;
9808     }
9809     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
9810         return NULL;
9811     _arg2 = new wxString(tmpPtr, tmpSize);
9812 #else
9813     if (!PyString_Check(_obj2)) {
9814         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9815         return NULL;
9816     }
9817     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
9818 #endif
9819 }
9820 {
9821     wxPy_BEGIN_ALLOW_THREADS;
9822         wxGrid_SetColLabelValue(_arg0,_arg1,*_arg2);
9823
9824     wxPy_END_ALLOW_THREADS;
9825     if (PyErr_Occurred()) return NULL;
9826 }    Py_INCREF(Py_None);
9827     _resultobj = Py_None;
9828 {
9829     if (_obj2)
9830         delete _arg2;
9831 }
9832     return _resultobj;
9833 }
9834
9835 #define wxGrid_SetGridLineColour(_swigobj,_swigarg0)  (_swigobj->SetGridLineColour(_swigarg0))
9836 static PyObject *_wrap_wxGrid_SetGridLineColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9837     PyObject * _resultobj;
9838     wxGrid * _arg0;
9839     wxColour * _arg1;
9840     PyObject * _argo0 = 0;
9841     wxColour  temp;
9842     PyObject * _obj1 = 0;
9843     char *_kwnames[] = { "self","arg2", NULL };
9844
9845     self = self;
9846     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetGridLineColour",_kwnames,&_argo0,&_obj1))
9847         return NULL;
9848     if (_argo0) {
9849         if (_argo0 == Py_None) { _arg0 = NULL; }
9850         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9851             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetGridLineColour. Expected _wxGrid_p.");
9852         return NULL;
9853         }
9854     }
9855 {
9856     _arg1 = &temp;
9857     if (! wxColour_helper(_obj1, &_arg1))
9858         return NULL;
9859 }
9860 {
9861     wxPy_BEGIN_ALLOW_THREADS;
9862         wxGrid_SetGridLineColour(_arg0,*_arg1);
9863
9864     wxPy_END_ALLOW_THREADS;
9865     if (PyErr_Occurred()) return NULL;
9866 }    Py_INCREF(Py_None);
9867     _resultobj = Py_None;
9868     return _resultobj;
9869 }
9870
9871 #define wxGrid_SetCellHighlightColour(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightColour(_swigarg0))
9872 static PyObject *_wrap_wxGrid_SetCellHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9873     PyObject * _resultobj;
9874     wxGrid * _arg0;
9875     wxColour * _arg1;
9876     PyObject * _argo0 = 0;
9877     wxColour  temp;
9878     PyObject * _obj1 = 0;
9879     char *_kwnames[] = { "self","arg2", NULL };
9880
9881     self = self;
9882     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetCellHighlightColour",_kwnames,&_argo0,&_obj1))
9883         return NULL;
9884     if (_argo0) {
9885         if (_argo0 == Py_None) { _arg0 = NULL; }
9886         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9887             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightColour. Expected _wxGrid_p.");
9888         return NULL;
9889         }
9890     }
9891 {
9892     _arg1 = &temp;
9893     if (! wxColour_helper(_obj1, &_arg1))
9894         return NULL;
9895 }
9896 {
9897     wxPy_BEGIN_ALLOW_THREADS;
9898         wxGrid_SetCellHighlightColour(_arg0,*_arg1);
9899
9900     wxPy_END_ALLOW_THREADS;
9901     if (PyErr_Occurred()) return NULL;
9902 }    Py_INCREF(Py_None);
9903     _resultobj = Py_None;
9904     return _resultobj;
9905 }
9906
9907 #define wxGrid_SetCellHighlightPenWidth(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightPenWidth(_swigarg0))
9908 static PyObject *_wrap_wxGrid_SetCellHighlightPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9909     PyObject * _resultobj;
9910     wxGrid * _arg0;
9911     int  _arg1;
9912     PyObject * _argo0 = 0;
9913     char *_kwnames[] = { "self","width", NULL };
9914
9915     self = self;
9916     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetCellHighlightPenWidth",_kwnames,&_argo0,&_arg1))
9917         return NULL;
9918     if (_argo0) {
9919         if (_argo0 == Py_None) { _arg0 = NULL; }
9920         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9921             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightPenWidth. Expected _wxGrid_p.");
9922         return NULL;
9923         }
9924     }
9925 {
9926     wxPy_BEGIN_ALLOW_THREADS;
9927         wxGrid_SetCellHighlightPenWidth(_arg0,_arg1);
9928
9929     wxPy_END_ALLOW_THREADS;
9930     if (PyErr_Occurred()) return NULL;
9931 }    Py_INCREF(Py_None);
9932     _resultobj = Py_None;
9933     return _resultobj;
9934 }
9935
9936 #define wxGrid_SetCellHighlightROPenWidth(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightROPenWidth(_swigarg0))
9937 static PyObject *_wrap_wxGrid_SetCellHighlightROPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9938     PyObject * _resultobj;
9939     wxGrid * _arg0;
9940     int  _arg1;
9941     PyObject * _argo0 = 0;
9942     char *_kwnames[] = { "self","width", NULL };
9943
9944     self = self;
9945     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetCellHighlightROPenWidth",_kwnames,&_argo0,&_arg1))
9946         return NULL;
9947     if (_argo0) {
9948         if (_argo0 == Py_None) { _arg0 = NULL; }
9949         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9950             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightROPenWidth. Expected _wxGrid_p.");
9951         return NULL;
9952         }
9953     }
9954 {
9955     wxPy_BEGIN_ALLOW_THREADS;
9956         wxGrid_SetCellHighlightROPenWidth(_arg0,_arg1);
9957
9958     wxPy_END_ALLOW_THREADS;
9959     if (PyErr_Occurred()) return NULL;
9960 }    Py_INCREF(Py_None);
9961     _resultobj = Py_None;
9962     return _resultobj;
9963 }
9964
9965 #define wxGrid_EnableDragRowSize(_swigobj,_swigarg0)  (_swigobj->EnableDragRowSize(_swigarg0))
9966 static PyObject *_wrap_wxGrid_EnableDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9967     PyObject * _resultobj;
9968     wxGrid * _arg0;
9969     bool  _arg1 = (bool ) TRUE;
9970     PyObject * _argo0 = 0;
9971     int tempbool1 = (int) TRUE;
9972     char *_kwnames[] = { "self","enable", NULL };
9973
9974     self = self;
9975     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragRowSize",_kwnames,&_argo0,&tempbool1))
9976         return NULL;
9977     if (_argo0) {
9978         if (_argo0 == Py_None) { _arg0 = NULL; }
9979         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9980             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragRowSize. Expected _wxGrid_p.");
9981         return NULL;
9982         }
9983     }
9984     _arg1 = (bool ) tempbool1;
9985 {
9986     wxPy_BEGIN_ALLOW_THREADS;
9987         wxGrid_EnableDragRowSize(_arg0,_arg1);
9988
9989     wxPy_END_ALLOW_THREADS;
9990     if (PyErr_Occurred()) return NULL;
9991 }    Py_INCREF(Py_None);
9992     _resultobj = Py_None;
9993     return _resultobj;
9994 }
9995
9996 #define wxGrid_DisableDragRowSize(_swigobj)  (_swigobj->DisableDragRowSize())
9997 static PyObject *_wrap_wxGrid_DisableDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9998     PyObject * _resultobj;
9999     wxGrid * _arg0;
10000     PyObject * _argo0 = 0;
10001     char *_kwnames[] = { "self", NULL };
10002
10003     self = self;
10004     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragRowSize",_kwnames,&_argo0))
10005         return NULL;
10006     if (_argo0) {
10007         if (_argo0 == Py_None) { _arg0 = NULL; }
10008         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10009             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragRowSize. Expected _wxGrid_p.");
10010         return NULL;
10011         }
10012     }
10013 {
10014     wxPy_BEGIN_ALLOW_THREADS;
10015         wxGrid_DisableDragRowSize(_arg0);
10016
10017     wxPy_END_ALLOW_THREADS;
10018     if (PyErr_Occurred()) return NULL;
10019 }    Py_INCREF(Py_None);
10020     _resultobj = Py_None;
10021     return _resultobj;
10022 }
10023
10024 #define wxGrid_CanDragRowSize(_swigobj)  (_swigobj->CanDragRowSize())
10025 static PyObject *_wrap_wxGrid_CanDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10026     PyObject * _resultobj;
10027     bool  _result;
10028     wxGrid * _arg0;
10029     PyObject * _argo0 = 0;
10030     char *_kwnames[] = { "self", NULL };
10031
10032     self = self;
10033     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragRowSize",_kwnames,&_argo0))
10034         return NULL;
10035     if (_argo0) {
10036         if (_argo0 == Py_None) { _arg0 = NULL; }
10037         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10038             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragRowSize. Expected _wxGrid_p.");
10039         return NULL;
10040         }
10041     }
10042 {
10043     wxPy_BEGIN_ALLOW_THREADS;
10044         _result = (bool )wxGrid_CanDragRowSize(_arg0);
10045
10046     wxPy_END_ALLOW_THREADS;
10047     if (PyErr_Occurred()) return NULL;
10048 }    _resultobj = Py_BuildValue("i",_result);
10049     return _resultobj;
10050 }
10051
10052 #define wxGrid_EnableDragColSize(_swigobj,_swigarg0)  (_swigobj->EnableDragColSize(_swigarg0))
10053 static PyObject *_wrap_wxGrid_EnableDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10054     PyObject * _resultobj;
10055     wxGrid * _arg0;
10056     bool  _arg1 = (bool ) TRUE;
10057     PyObject * _argo0 = 0;
10058     int tempbool1 = (int) TRUE;
10059     char *_kwnames[] = { "self","enable", NULL };
10060
10061     self = self;
10062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragColSize",_kwnames,&_argo0,&tempbool1))
10063         return NULL;
10064     if (_argo0) {
10065         if (_argo0 == Py_None) { _arg0 = NULL; }
10066         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10067             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragColSize. Expected _wxGrid_p.");
10068         return NULL;
10069         }
10070     }
10071     _arg1 = (bool ) tempbool1;
10072 {
10073     wxPy_BEGIN_ALLOW_THREADS;
10074         wxGrid_EnableDragColSize(_arg0,_arg1);
10075
10076     wxPy_END_ALLOW_THREADS;
10077     if (PyErr_Occurred()) return NULL;
10078 }    Py_INCREF(Py_None);
10079     _resultobj = Py_None;
10080     return _resultobj;
10081 }
10082
10083 #define wxGrid_DisableDragColSize(_swigobj)  (_swigobj->DisableDragColSize())
10084 static PyObject *_wrap_wxGrid_DisableDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10085     PyObject * _resultobj;
10086     wxGrid * _arg0;
10087     PyObject * _argo0 = 0;
10088     char *_kwnames[] = { "self", NULL };
10089
10090     self = self;
10091     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragColSize",_kwnames,&_argo0))
10092         return NULL;
10093     if (_argo0) {
10094         if (_argo0 == Py_None) { _arg0 = NULL; }
10095         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10096             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragColSize. Expected _wxGrid_p.");
10097         return NULL;
10098         }
10099     }
10100 {
10101     wxPy_BEGIN_ALLOW_THREADS;
10102         wxGrid_DisableDragColSize(_arg0);
10103
10104     wxPy_END_ALLOW_THREADS;
10105     if (PyErr_Occurred()) return NULL;
10106 }    Py_INCREF(Py_None);
10107     _resultobj = Py_None;
10108     return _resultobj;
10109 }
10110
10111 #define wxGrid_CanDragColSize(_swigobj)  (_swigobj->CanDragColSize())
10112 static PyObject *_wrap_wxGrid_CanDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10113     PyObject * _resultobj;
10114     bool  _result;
10115     wxGrid * _arg0;
10116     PyObject * _argo0 = 0;
10117     char *_kwnames[] = { "self", NULL };
10118
10119     self = self;
10120     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragColSize",_kwnames,&_argo0))
10121         return NULL;
10122     if (_argo0) {
10123         if (_argo0 == Py_None) { _arg0 = NULL; }
10124         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10125             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragColSize. Expected _wxGrid_p.");
10126         return NULL;
10127         }
10128     }
10129 {
10130     wxPy_BEGIN_ALLOW_THREADS;
10131         _result = (bool )wxGrid_CanDragColSize(_arg0);
10132
10133     wxPy_END_ALLOW_THREADS;
10134     if (PyErr_Occurred()) return NULL;
10135 }    _resultobj = Py_BuildValue("i",_result);
10136     return _resultobj;
10137 }
10138
10139 #define wxGrid_EnableDragGridSize(_swigobj,_swigarg0)  (_swigobj->EnableDragGridSize(_swigarg0))
10140 static PyObject *_wrap_wxGrid_EnableDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10141     PyObject * _resultobj;
10142     wxGrid * _arg0;
10143     bool  _arg1 = (bool ) TRUE;
10144     PyObject * _argo0 = 0;
10145     int tempbool1 = (int) TRUE;
10146     char *_kwnames[] = { "self","enable", NULL };
10147
10148     self = self;
10149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragGridSize",_kwnames,&_argo0,&tempbool1))
10150         return NULL;
10151     if (_argo0) {
10152         if (_argo0 == Py_None) { _arg0 = NULL; }
10153         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10154             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragGridSize. Expected _wxGrid_p.");
10155         return NULL;
10156         }
10157     }
10158     _arg1 = (bool ) tempbool1;
10159 {
10160     wxPy_BEGIN_ALLOW_THREADS;
10161         wxGrid_EnableDragGridSize(_arg0,_arg1);
10162
10163     wxPy_END_ALLOW_THREADS;
10164     if (PyErr_Occurred()) return NULL;
10165 }    Py_INCREF(Py_None);
10166     _resultobj = Py_None;
10167     return _resultobj;
10168 }
10169
10170 #define wxGrid_DisableDragGridSize(_swigobj)  (_swigobj->DisableDragGridSize())
10171 static PyObject *_wrap_wxGrid_DisableDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10172     PyObject * _resultobj;
10173     wxGrid * _arg0;
10174     PyObject * _argo0 = 0;
10175     char *_kwnames[] = { "self", NULL };
10176
10177     self = self;
10178     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragGridSize",_kwnames,&_argo0))
10179         return NULL;
10180     if (_argo0) {
10181         if (_argo0 == Py_None) { _arg0 = NULL; }
10182         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10183             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragGridSize. Expected _wxGrid_p.");
10184         return NULL;
10185         }
10186     }
10187 {
10188     wxPy_BEGIN_ALLOW_THREADS;
10189         wxGrid_DisableDragGridSize(_arg0);
10190
10191     wxPy_END_ALLOW_THREADS;
10192     if (PyErr_Occurred()) return NULL;
10193 }    Py_INCREF(Py_None);
10194     _resultobj = Py_None;
10195     return _resultobj;
10196 }
10197
10198 #define wxGrid_CanDragGridSize(_swigobj)  (_swigobj->CanDragGridSize())
10199 static PyObject *_wrap_wxGrid_CanDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10200     PyObject * _resultobj;
10201     bool  _result;
10202     wxGrid * _arg0;
10203     PyObject * _argo0 = 0;
10204     char *_kwnames[] = { "self", NULL };
10205
10206     self = self;
10207     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragGridSize",_kwnames,&_argo0))
10208         return NULL;
10209     if (_argo0) {
10210         if (_argo0 == Py_None) { _arg0 = NULL; }
10211         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10212             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragGridSize. Expected _wxGrid_p.");
10213         return NULL;
10214         }
10215     }
10216 {
10217     wxPy_BEGIN_ALLOW_THREADS;
10218         _result = (bool )wxGrid_CanDragGridSize(_arg0);
10219
10220     wxPy_END_ALLOW_THREADS;
10221     if (PyErr_Occurred()) return NULL;
10222 }    _resultobj = Py_BuildValue("i",_result);
10223     return _resultobj;
10224 }
10225
10226 #define wxGrid_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
10227 static PyObject *_wrap_wxGrid_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
10228     PyObject * _resultobj;
10229     wxGrid * _arg0;
10230     int  _arg1;
10231     wxGridCellAttr * _arg2;
10232     PyObject * _argo0 = 0;
10233     PyObject * _argo2 = 0;
10234     char *_kwnames[] = { "self","row","attr", NULL };
10235
10236     self = self;
10237     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetRowAttr",_kwnames,&_argo0,&_arg1,&_argo2))
10238         return NULL;
10239     if (_argo0) {
10240         if (_argo0 == Py_None) { _arg0 = NULL; }
10241         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10242             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowAttr. Expected _wxGrid_p.");
10243         return NULL;
10244         }
10245     }
10246     if (_argo2) {
10247         if (_argo2 == Py_None) { _arg2 = NULL; }
10248         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
10249             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_SetRowAttr. Expected _wxGridCellAttr_p.");
10250         return NULL;
10251         }
10252     }
10253 {
10254     wxPy_BEGIN_ALLOW_THREADS;
10255         wxGrid_SetRowAttr(_arg0,_arg1,_arg2);
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_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
10265 static PyObject *_wrap_wxGrid_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
10266     PyObject * _resultobj;
10267     wxGrid * _arg0;
10268     int  _arg1;
10269     wxGridCellAttr * _arg2;
10270     PyObject * _argo0 = 0;
10271     PyObject * _argo2 = 0;
10272     char *_kwnames[] = { "self","col","attr", NULL };
10273
10274     self = self;
10275     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColAttr",_kwnames,&_argo0,&_arg1,&_argo2))
10276         return NULL;
10277     if (_argo0) {
10278         if (_argo0 == Py_None) { _arg0 = NULL; }
10279         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10280             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColAttr. Expected _wxGrid_p.");
10281         return NULL;
10282         }
10283     }
10284     if (_argo2) {
10285         if (_argo2 == Py_None) { _arg2 = NULL; }
10286         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
10287             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_SetColAttr. Expected _wxGridCellAttr_p.");
10288         return NULL;
10289         }
10290     }
10291 {
10292     wxPy_BEGIN_ALLOW_THREADS;
10293         wxGrid_SetColAttr(_arg0,_arg1,_arg2);
10294
10295     wxPy_END_ALLOW_THREADS;
10296     if (PyErr_Occurred()) return NULL;
10297 }    Py_INCREF(Py_None);
10298     _resultobj = Py_None;
10299     return _resultobj;
10300 }
10301
10302 #define wxGrid_SetColFormatBool(_swigobj,_swigarg0)  (_swigobj->SetColFormatBool(_swigarg0))
10303 static PyObject *_wrap_wxGrid_SetColFormatBool(PyObject *self, PyObject *args, PyObject *kwargs) {
10304     PyObject * _resultobj;
10305     wxGrid * _arg0;
10306     int  _arg1;
10307     PyObject * _argo0 = 0;
10308     char *_kwnames[] = { "self","col", NULL };
10309
10310     self = self;
10311     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColFormatBool",_kwnames,&_argo0,&_arg1))
10312         return NULL;
10313     if (_argo0) {
10314         if (_argo0 == Py_None) { _arg0 = NULL; }
10315         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10316             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatBool. Expected _wxGrid_p.");
10317         return NULL;
10318         }
10319     }
10320 {
10321     wxPy_BEGIN_ALLOW_THREADS;
10322         wxGrid_SetColFormatBool(_arg0,_arg1);
10323
10324     wxPy_END_ALLOW_THREADS;
10325     if (PyErr_Occurred()) return NULL;
10326 }    Py_INCREF(Py_None);
10327     _resultobj = Py_None;
10328     return _resultobj;
10329 }
10330
10331 #define wxGrid_SetColFormatNumber(_swigobj,_swigarg0)  (_swigobj->SetColFormatNumber(_swigarg0))
10332 static PyObject *_wrap_wxGrid_SetColFormatNumber(PyObject *self, PyObject *args, PyObject *kwargs) {
10333     PyObject * _resultobj;
10334     wxGrid * _arg0;
10335     int  _arg1;
10336     PyObject * _argo0 = 0;
10337     char *_kwnames[] = { "self","col", NULL };
10338
10339     self = self;
10340     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColFormatNumber",_kwnames,&_argo0,&_arg1))
10341         return NULL;
10342     if (_argo0) {
10343         if (_argo0 == Py_None) { _arg0 = NULL; }
10344         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10345             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatNumber. Expected _wxGrid_p.");
10346         return NULL;
10347         }
10348     }
10349 {
10350     wxPy_BEGIN_ALLOW_THREADS;
10351         wxGrid_SetColFormatNumber(_arg0,_arg1);
10352
10353     wxPy_END_ALLOW_THREADS;
10354     if (PyErr_Occurred()) return NULL;
10355 }    Py_INCREF(Py_None);
10356     _resultobj = Py_None;
10357     return _resultobj;
10358 }
10359
10360 #define wxGrid_SetColFormatFloat(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetColFormatFloat(_swigarg0,_swigarg1,_swigarg2))
10361 static PyObject *_wrap_wxGrid_SetColFormatFloat(PyObject *self, PyObject *args, PyObject *kwargs) {
10362     PyObject * _resultobj;
10363     wxGrid * _arg0;
10364     int  _arg1;
10365     int  _arg2 = (int ) -1;
10366     int  _arg3 = (int ) -1;
10367     PyObject * _argo0 = 0;
10368     char *_kwnames[] = { "self","col","width","precision", NULL };
10369
10370     self = self;
10371     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|ii:wxGrid_SetColFormatFloat",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
10372         return NULL;
10373     if (_argo0) {
10374         if (_argo0 == Py_None) { _arg0 = NULL; }
10375         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10376             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatFloat. Expected _wxGrid_p.");
10377         return NULL;
10378         }
10379     }
10380 {
10381     wxPy_BEGIN_ALLOW_THREADS;
10382         wxGrid_SetColFormatFloat(_arg0,_arg1,_arg2,_arg3);
10383
10384     wxPy_END_ALLOW_THREADS;
10385     if (PyErr_Occurred()) return NULL;
10386 }    Py_INCREF(Py_None);
10387     _resultobj = Py_None;
10388     return _resultobj;
10389 }
10390
10391 #define wxGrid_SetColFormatCustom(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColFormatCustom(_swigarg0,_swigarg1))
10392 static PyObject *_wrap_wxGrid_SetColFormatCustom(PyObject *self, PyObject *args, PyObject *kwargs) {
10393     PyObject * _resultobj;
10394     wxGrid * _arg0;
10395     int  _arg1;
10396     wxString * _arg2;
10397     PyObject * _argo0 = 0;
10398     PyObject * _obj2 = 0;
10399     char *_kwnames[] = { "self","col","typeName", NULL };
10400
10401     self = self;
10402     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColFormatCustom",_kwnames,&_argo0,&_arg1,&_obj2))
10403         return NULL;
10404     if (_argo0) {
10405         if (_argo0 == Py_None) { _arg0 = NULL; }
10406         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10407             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatCustom. Expected _wxGrid_p.");
10408         return NULL;
10409         }
10410     }
10411 {
10412 #if PYTHON_API_VERSION >= 1009
10413     char* tmpPtr; int tmpSize;
10414     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
10415         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
10416         return NULL;
10417     }
10418     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
10419         return NULL;
10420     _arg2 = new wxString(tmpPtr, tmpSize);
10421 #else
10422     if (!PyString_Check(_obj2)) {
10423         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
10424         return NULL;
10425     }
10426     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
10427 #endif
10428 }
10429 {
10430     wxPy_BEGIN_ALLOW_THREADS;
10431         wxGrid_SetColFormatCustom(_arg0,_arg1,*_arg2);
10432
10433     wxPy_END_ALLOW_THREADS;
10434     if (PyErr_Occurred()) return NULL;
10435 }    Py_INCREF(Py_None);
10436     _resultobj = Py_None;
10437 {
10438     if (_obj2)
10439         delete _arg2;
10440 }
10441     return _resultobj;
10442 }
10443
10444 #define wxGrid_EnableGridLines(_swigobj,_swigarg0)  (_swigobj->EnableGridLines(_swigarg0))
10445 static PyObject *_wrap_wxGrid_EnableGridLines(PyObject *self, PyObject *args, PyObject *kwargs) {
10446     PyObject * _resultobj;
10447     wxGrid * _arg0;
10448     bool  _arg1 = (bool ) TRUE;
10449     PyObject * _argo0 = 0;
10450     int tempbool1 = (int) TRUE;
10451     char *_kwnames[] = { "self","enable", NULL };
10452
10453     self = self;
10454     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableGridLines",_kwnames,&_argo0,&tempbool1))
10455         return NULL;
10456     if (_argo0) {
10457         if (_argo0 == Py_None) { _arg0 = NULL; }
10458         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10459             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableGridLines. Expected _wxGrid_p.");
10460         return NULL;
10461         }
10462     }
10463     _arg1 = (bool ) tempbool1;
10464 {
10465     wxPy_BEGIN_ALLOW_THREADS;
10466         wxGrid_EnableGridLines(_arg0,_arg1);
10467
10468     wxPy_END_ALLOW_THREADS;
10469     if (PyErr_Occurred()) return NULL;
10470 }    Py_INCREF(Py_None);
10471     _resultobj = Py_None;
10472     return _resultobj;
10473 }
10474
10475 #define wxGrid_GridLinesEnabled(_swigobj)  (_swigobj->GridLinesEnabled())
10476 static PyObject *_wrap_wxGrid_GridLinesEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
10477     PyObject * _resultobj;
10478     bool  _result;
10479     wxGrid * _arg0;
10480     PyObject * _argo0 = 0;
10481     char *_kwnames[] = { "self", NULL };
10482
10483     self = self;
10484     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GridLinesEnabled",_kwnames,&_argo0))
10485         return NULL;
10486     if (_argo0) {
10487         if (_argo0 == Py_None) { _arg0 = NULL; }
10488         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10489             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GridLinesEnabled. Expected _wxGrid_p.");
10490         return NULL;
10491         }
10492     }
10493 {
10494     wxPy_BEGIN_ALLOW_THREADS;
10495         _result = (bool )wxGrid_GridLinesEnabled(_arg0);
10496
10497     wxPy_END_ALLOW_THREADS;
10498     if (PyErr_Occurred()) return NULL;
10499 }    _resultobj = Py_BuildValue("i",_result);
10500     return _resultobj;
10501 }
10502
10503 #define wxGrid_GetDefaultRowSize(_swigobj)  (_swigobj->GetDefaultRowSize())
10504 static PyObject *_wrap_wxGrid_GetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10505     PyObject * _resultobj;
10506     int  _result;
10507     wxGrid * _arg0;
10508     PyObject * _argo0 = 0;
10509     char *_kwnames[] = { "self", NULL };
10510
10511     self = self;
10512     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRowSize",_kwnames,&_argo0))
10513         return NULL;
10514     if (_argo0) {
10515         if (_argo0 == Py_None) { _arg0 = NULL; }
10516         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10517             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRowSize. Expected _wxGrid_p.");
10518         return NULL;
10519         }
10520     }
10521 {
10522     wxPy_BEGIN_ALLOW_THREADS;
10523         _result = (int )wxGrid_GetDefaultRowSize(_arg0);
10524
10525     wxPy_END_ALLOW_THREADS;
10526     if (PyErr_Occurred()) return NULL;
10527 }    _resultobj = Py_BuildValue("i",_result);
10528     return _resultobj;
10529 }
10530
10531 #define wxGrid_GetRowSize(_swigobj,_swigarg0)  (_swigobj->GetRowSize(_swigarg0))
10532 static PyObject *_wrap_wxGrid_GetRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10533     PyObject * _resultobj;
10534     int  _result;
10535     wxGrid * _arg0;
10536     int  _arg1;
10537     PyObject * _argo0 = 0;
10538     char *_kwnames[] = { "self","row", NULL };
10539
10540     self = self;
10541     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetRowSize",_kwnames,&_argo0,&_arg1))
10542         return NULL;
10543     if (_argo0) {
10544         if (_argo0 == Py_None) { _arg0 = NULL; }
10545         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10546             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowSize. Expected _wxGrid_p.");
10547         return NULL;
10548         }
10549     }
10550 {
10551     wxPy_BEGIN_ALLOW_THREADS;
10552         _result = (int )wxGrid_GetRowSize(_arg0,_arg1);
10553
10554     wxPy_END_ALLOW_THREADS;
10555     if (PyErr_Occurred()) return NULL;
10556 }    _resultobj = Py_BuildValue("i",_result);
10557     return _resultobj;
10558 }
10559
10560 #define wxGrid_GetDefaultColSize(_swigobj)  (_swigobj->GetDefaultColSize())
10561 static PyObject *_wrap_wxGrid_GetDefaultColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10562     PyObject * _resultobj;
10563     int  _result;
10564     wxGrid * _arg0;
10565     PyObject * _argo0 = 0;
10566     char *_kwnames[] = { "self", NULL };
10567
10568     self = self;
10569     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultColSize",_kwnames,&_argo0))
10570         return NULL;
10571     if (_argo0) {
10572         if (_argo0 == Py_None) { _arg0 = NULL; }
10573         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10574             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultColSize. Expected _wxGrid_p.");
10575         return NULL;
10576         }
10577     }
10578 {
10579     wxPy_BEGIN_ALLOW_THREADS;
10580         _result = (int )wxGrid_GetDefaultColSize(_arg0);
10581
10582     wxPy_END_ALLOW_THREADS;
10583     if (PyErr_Occurred()) return NULL;
10584 }    _resultobj = Py_BuildValue("i",_result);
10585     return _resultobj;
10586 }
10587
10588 #define wxGrid_GetColSize(_swigobj,_swigarg0)  (_swigobj->GetColSize(_swigarg0))
10589 static PyObject *_wrap_wxGrid_GetColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10590     PyObject * _resultobj;
10591     int  _result;
10592     wxGrid * _arg0;
10593     int  _arg1;
10594     PyObject * _argo0 = 0;
10595     char *_kwnames[] = { "self","col", NULL };
10596
10597     self = self;
10598     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetColSize",_kwnames,&_argo0,&_arg1))
10599         return NULL;
10600     if (_argo0) {
10601         if (_argo0 == Py_None) { _arg0 = NULL; }
10602         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10603             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColSize. Expected _wxGrid_p.");
10604         return NULL;
10605         }
10606     }
10607 {
10608     wxPy_BEGIN_ALLOW_THREADS;
10609         _result = (int )wxGrid_GetColSize(_arg0,_arg1);
10610
10611     wxPy_END_ALLOW_THREADS;
10612     if (PyErr_Occurred()) return NULL;
10613 }    _resultobj = Py_BuildValue("i",_result);
10614     return _resultobj;
10615 }
10616
10617 #define wxGrid_GetDefaultCellBackgroundColour(_swigobj)  (_swigobj->GetDefaultCellBackgroundColour())
10618 static PyObject *_wrap_wxGrid_GetDefaultCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10619     PyObject * _resultobj;
10620     wxColour * _result;
10621     wxGrid * _arg0;
10622     PyObject * _argo0 = 0;
10623     char *_kwnames[] = { "self", NULL };
10624     char _ptemp[128];
10625
10626     self = self;
10627     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellBackgroundColour",_kwnames,&_argo0))
10628         return NULL;
10629     if (_argo0) {
10630         if (_argo0 == Py_None) { _arg0 = NULL; }
10631         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10632             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellBackgroundColour. Expected _wxGrid_p.");
10633         return NULL;
10634         }
10635     }
10636 {
10637     wxPy_BEGIN_ALLOW_THREADS;
10638         _result = new wxColour (wxGrid_GetDefaultCellBackgroundColour(_arg0));
10639
10640     wxPy_END_ALLOW_THREADS;
10641     if (PyErr_Occurred()) return NULL;
10642 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10643     _resultobj = Py_BuildValue("s",_ptemp);
10644     return _resultobj;
10645 }
10646
10647 #define wxGrid_GetCellBackgroundColour(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellBackgroundColour(_swigarg0,_swigarg1))
10648 static PyObject *_wrap_wxGrid_GetCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10649     PyObject * _resultobj;
10650     wxColour * _result;
10651     wxGrid * _arg0;
10652     int  _arg1;
10653     int  _arg2;
10654     PyObject * _argo0 = 0;
10655     char *_kwnames[] = { "self","row","col", NULL };
10656     char _ptemp[128];
10657
10658     self = self;
10659     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellBackgroundColour",_kwnames,&_argo0,&_arg1,&_arg2))
10660         return NULL;
10661     if (_argo0) {
10662         if (_argo0 == Py_None) { _arg0 = NULL; }
10663         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10664             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellBackgroundColour. Expected _wxGrid_p.");
10665         return NULL;
10666         }
10667     }
10668 {
10669     wxPy_BEGIN_ALLOW_THREADS;
10670         _result = new wxColour (wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2));
10671
10672     wxPy_END_ALLOW_THREADS;
10673     if (PyErr_Occurred()) return NULL;
10674 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10675     _resultobj = Py_BuildValue("s",_ptemp);
10676     return _resultobj;
10677 }
10678
10679 #define wxGrid_GetDefaultCellTextColour(_swigobj)  (_swigobj->GetDefaultCellTextColour())
10680 static PyObject *_wrap_wxGrid_GetDefaultCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10681     PyObject * _resultobj;
10682     wxColour * _result;
10683     wxGrid * _arg0;
10684     PyObject * _argo0 = 0;
10685     char *_kwnames[] = { "self", NULL };
10686     char _ptemp[128];
10687
10688     self = self;
10689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellTextColour",_kwnames,&_argo0))
10690         return NULL;
10691     if (_argo0) {
10692         if (_argo0 == Py_None) { _arg0 = NULL; }
10693         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10694             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellTextColour. Expected _wxGrid_p.");
10695         return NULL;
10696         }
10697     }
10698 {
10699     wxPy_BEGIN_ALLOW_THREADS;
10700         _result = new wxColour (wxGrid_GetDefaultCellTextColour(_arg0));
10701
10702     wxPy_END_ALLOW_THREADS;
10703     if (PyErr_Occurred()) return NULL;
10704 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10705     _resultobj = Py_BuildValue("s",_ptemp);
10706     return _resultobj;
10707 }
10708
10709 #define wxGrid_GetCellTextColour(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellTextColour(_swigarg0,_swigarg1))
10710 static PyObject *_wrap_wxGrid_GetCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10711     PyObject * _resultobj;
10712     wxColour * _result;
10713     wxGrid * _arg0;
10714     int  _arg1;
10715     int  _arg2;
10716     PyObject * _argo0 = 0;
10717     char *_kwnames[] = { "self","row","col", NULL };
10718     char _ptemp[128];
10719
10720     self = self;
10721     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellTextColour",_kwnames,&_argo0,&_arg1,&_arg2))
10722         return NULL;
10723     if (_argo0) {
10724         if (_argo0 == Py_None) { _arg0 = NULL; }
10725         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10726             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellTextColour. Expected _wxGrid_p.");
10727         return NULL;
10728         }
10729     }
10730 {
10731     wxPy_BEGIN_ALLOW_THREADS;
10732         _result = new wxColour (wxGrid_GetCellTextColour(_arg0,_arg1,_arg2));
10733
10734     wxPy_END_ALLOW_THREADS;
10735     if (PyErr_Occurred()) return NULL;
10736 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10737     _resultobj = Py_BuildValue("s",_ptemp);
10738     return _resultobj;
10739 }
10740
10741 #define wxGrid_GetDefaultCellFont(_swigobj)  (_swigobj->GetDefaultCellFont())
10742 static PyObject *_wrap_wxGrid_GetDefaultCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
10743     PyObject * _resultobj;
10744     wxFont * _result;
10745     wxGrid * _arg0;
10746     PyObject * _argo0 = 0;
10747     char *_kwnames[] = { "self", NULL };
10748     char _ptemp[128];
10749
10750     self = self;
10751     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellFont",_kwnames,&_argo0))
10752         return NULL;
10753     if (_argo0) {
10754         if (_argo0 == Py_None) { _arg0 = NULL; }
10755         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10756             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellFont. Expected _wxGrid_p.");
10757         return NULL;
10758         }
10759     }
10760 {
10761     wxPy_BEGIN_ALLOW_THREADS;
10762         _result = new wxFont (wxGrid_GetDefaultCellFont(_arg0));
10763
10764     wxPy_END_ALLOW_THREADS;
10765     if (PyErr_Occurred()) return NULL;
10766 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
10767     _resultobj = Py_BuildValue("s",_ptemp);
10768     return _resultobj;
10769 }
10770
10771 #define wxGrid_GetCellFont(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellFont(_swigarg0,_swigarg1))
10772 static PyObject *_wrap_wxGrid_GetCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
10773     PyObject * _resultobj;
10774     wxFont * _result;
10775     wxGrid * _arg0;
10776     int  _arg1;
10777     int  _arg2;
10778     PyObject * _argo0 = 0;
10779     char *_kwnames[] = { "self","row","col", NULL };
10780     char _ptemp[128];
10781
10782     self = self;
10783     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellFont",_kwnames,&_argo0,&_arg1,&_arg2))
10784         return NULL;
10785     if (_argo0) {
10786         if (_argo0 == Py_None) { _arg0 = NULL; }
10787         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10788             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellFont. Expected _wxGrid_p.");
10789         return NULL;
10790         }
10791     }
10792 {
10793     wxPy_BEGIN_ALLOW_THREADS;
10794         _result = new wxFont (wxGrid_GetCellFont(_arg0,_arg1,_arg2));
10795
10796     wxPy_END_ALLOW_THREADS;
10797     if (PyErr_Occurred()) return NULL;
10798 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
10799     _resultobj = Py_BuildValue("s",_ptemp);
10800     return _resultobj;
10801 }
10802
10803 #define wxGrid_GetDefaultCellAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultCellAlignment(_swigarg0,_swigarg1))
10804 static PyObject *_wrap_wxGrid_GetDefaultCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
10805     PyObject * _resultobj;
10806     wxGrid * _arg0;
10807     int * _arg1;
10808     int * _arg2;
10809     PyObject * _argo0 = 0;
10810     PyObject * _argo1 = 0;
10811     PyObject * _argo2 = 0;
10812     char *_kwnames[] = { "self","horiz","vert", NULL };
10813
10814     self = self;
10815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetDefaultCellAlignment",_kwnames,&_argo0,&_argo1,&_argo2))
10816         return NULL;
10817     if (_argo0) {
10818         if (_argo0 == Py_None) { _arg0 = NULL; }
10819         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10820             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellAlignment. Expected _wxGrid_p.");
10821         return NULL;
10822         }
10823     }
10824     if (_argo1) {
10825         if (_argo1 == Py_None) { _arg1 = NULL; }
10826         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_int_p")) {
10827             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_GetDefaultCellAlignment. Expected _int_p.");
10828         return NULL;
10829         }
10830     }
10831     if (_argo2) {
10832         if (_argo2 == Py_None) { _arg2 = NULL; }
10833         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_int_p")) {
10834             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_GetDefaultCellAlignment. Expected _int_p.");
10835         return NULL;
10836         }
10837     }
10838 {
10839     wxPy_BEGIN_ALLOW_THREADS;
10840         wxGrid_GetDefaultCellAlignment(_arg0,_arg1,_arg2);
10841
10842     wxPy_END_ALLOW_THREADS;
10843     if (PyErr_Occurred()) return NULL;
10844 }    Py_INCREF(Py_None);
10845     _resultobj = Py_None;
10846     return _resultobj;
10847 }
10848
10849 #define wxGrid_GetCellAlignment(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetCellAlignment(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
10850 static PyObject *_wrap_wxGrid_GetCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
10851     PyObject * _resultobj;
10852     wxGrid * _arg0;
10853     int  _arg1;
10854     int  _arg2;
10855     int * _arg3;
10856     int * _arg4;
10857     PyObject * _argo0 = 0;
10858     PyObject * _argo3 = 0;
10859     PyObject * _argo4 = 0;
10860     char *_kwnames[] = { "self","row","col","horiz","vert", NULL };
10861
10862     self = self;
10863     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiOO:wxGrid_GetCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3,&_argo4))
10864         return NULL;
10865     if (_argo0) {
10866         if (_argo0 == Py_None) { _arg0 = NULL; }
10867         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10868             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellAlignment. Expected _wxGrid_p.");
10869         return NULL;
10870         }
10871     }
10872     if (_argo3) {
10873         if (_argo3 == Py_None) { _arg3 = NULL; }
10874         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_int_p")) {
10875             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_GetCellAlignment. Expected _int_p.");
10876         return NULL;
10877         }
10878     }
10879     if (_argo4) {
10880         if (_argo4 == Py_None) { _arg4 = NULL; }
10881         else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_int_p")) {
10882             PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxGrid_GetCellAlignment. Expected _int_p.");
10883         return NULL;
10884         }
10885     }
10886 {
10887     wxPy_BEGIN_ALLOW_THREADS;
10888         wxGrid_GetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
10889
10890     wxPy_END_ALLOW_THREADS;
10891     if (PyErr_Occurred()) return NULL;
10892 }    Py_INCREF(Py_None);
10893     _resultobj = Py_None;
10894     return _resultobj;
10895 }
10896
10897 #define wxGrid_SetDefaultRowSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultRowSize(_swigarg0,_swigarg1))
10898 static PyObject *_wrap_wxGrid_SetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10899     PyObject * _resultobj;
10900     wxGrid * _arg0;
10901     int  _arg1;
10902     bool  _arg2 = (bool ) FALSE;
10903     PyObject * _argo0 = 0;
10904     int tempbool2 = (int) FALSE;
10905     char *_kwnames[] = { "self","height","resizeExistingRows", NULL };
10906
10907     self = self;
10908     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SetDefaultRowSize",_kwnames,&_argo0,&_arg1,&tempbool2))
10909         return NULL;
10910     if (_argo0) {
10911         if (_argo0 == Py_None) { _arg0 = NULL; }
10912         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10913             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultRowSize. Expected _wxGrid_p.");
10914         return NULL;
10915         }
10916     }
10917     _arg2 = (bool ) tempbool2;
10918 {
10919     wxPy_BEGIN_ALLOW_THREADS;
10920         wxGrid_SetDefaultRowSize(_arg0,_arg1,_arg2);
10921
10922     wxPy_END_ALLOW_THREADS;
10923     if (PyErr_Occurred()) return NULL;
10924 }    Py_INCREF(Py_None);
10925     _resultobj = Py_None;
10926     return _resultobj;
10927 }
10928
10929 #define wxGrid_SetRowSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowSize(_swigarg0,_swigarg1))
10930 static PyObject *_wrap_wxGrid_SetRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10931     PyObject * _resultobj;
10932     wxGrid * _arg0;
10933     int  _arg1;
10934     int  _arg2;
10935     PyObject * _argo0 = 0;
10936     char *_kwnames[] = { "self","row","height", NULL };
10937
10938     self = self;
10939     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowSize",_kwnames,&_argo0,&_arg1,&_arg2))
10940         return NULL;
10941     if (_argo0) {
10942         if (_argo0 == Py_None) { _arg0 = NULL; }
10943         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10944             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowSize. Expected _wxGrid_p.");
10945         return NULL;
10946         }
10947     }
10948 {
10949     wxPy_BEGIN_ALLOW_THREADS;
10950         wxGrid_SetRowSize(_arg0,_arg1,_arg2);
10951
10952     wxPy_END_ALLOW_THREADS;
10953     if (PyErr_Occurred()) return NULL;
10954 }    Py_INCREF(Py_None);
10955     _resultobj = Py_None;
10956     return _resultobj;
10957 }
10958
10959 #define wxGrid_SetDefaultColSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultColSize(_swigarg0,_swigarg1))
10960 static PyObject *_wrap_wxGrid_SetDefaultColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10961     PyObject * _resultobj;
10962     wxGrid * _arg0;
10963     int  _arg1;
10964     bool  _arg2 = (bool ) FALSE;
10965     PyObject * _argo0 = 0;
10966     int tempbool2 = (int) FALSE;
10967     char *_kwnames[] = { "self","width","resizeExistingCols", NULL };
10968
10969     self = self;
10970     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SetDefaultColSize",_kwnames,&_argo0,&_arg1,&tempbool2))
10971         return NULL;
10972     if (_argo0) {
10973         if (_argo0 == Py_None) { _arg0 = NULL; }
10974         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10975             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultColSize. Expected _wxGrid_p.");
10976         return NULL;
10977         }
10978     }
10979     _arg2 = (bool ) tempbool2;
10980 {
10981     wxPy_BEGIN_ALLOW_THREADS;
10982         wxGrid_SetDefaultColSize(_arg0,_arg1,_arg2);
10983
10984     wxPy_END_ALLOW_THREADS;
10985     if (PyErr_Occurred()) return NULL;
10986 }    Py_INCREF(Py_None);
10987     _resultobj = Py_None;
10988     return _resultobj;
10989 }
10990
10991 #define wxGrid_SetColSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColSize(_swigarg0,_swigarg1))
10992 static PyObject *_wrap_wxGrid_SetColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10993     PyObject * _resultobj;
10994     wxGrid * _arg0;
10995     int  _arg1;
10996     int  _arg2;
10997     PyObject * _argo0 = 0;
10998     char *_kwnames[] = { "self","col","width", NULL };
10999
11000     self = self;
11001     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColSize",_kwnames,&_argo0,&_arg1,&_arg2))
11002         return NULL;
11003     if (_argo0) {
11004         if (_argo0 == Py_None) { _arg0 = NULL; }
11005         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11006             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColSize. Expected _wxGrid_p.");
11007         return NULL;
11008         }
11009     }
11010 {
11011     wxPy_BEGIN_ALLOW_THREADS;
11012         wxGrid_SetColSize(_arg0,_arg1,_arg2);
11013
11014     wxPy_END_ALLOW_THREADS;
11015     if (PyErr_Occurred()) return NULL;
11016 }    Py_INCREF(Py_None);
11017     _resultobj = Py_None;
11018     return _resultobj;
11019 }
11020
11021 #define wxGrid_AutoSizeColumn(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AutoSizeColumn(_swigarg0,_swigarg1))
11022 static PyObject *_wrap_wxGrid_AutoSizeColumn(PyObject *self, PyObject *args, PyObject *kwargs) {
11023     PyObject * _resultobj;
11024     wxGrid * _arg0;
11025     int  _arg1;
11026     bool  _arg2 = (bool ) TRUE;
11027     PyObject * _argo0 = 0;
11028     int tempbool2 = (int) TRUE;
11029     char *_kwnames[] = { "self","col","setAsMin", NULL };
11030
11031     self = self;
11032     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_AutoSizeColumn",_kwnames,&_argo0,&_arg1,&tempbool2))
11033         return NULL;
11034     if (_argo0) {
11035         if (_argo0 == Py_None) { _arg0 = NULL; }
11036         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11037             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeColumn. Expected _wxGrid_p.");
11038         return NULL;
11039         }
11040     }
11041     _arg2 = (bool ) tempbool2;
11042 {
11043     wxPy_BEGIN_ALLOW_THREADS;
11044         wxGrid_AutoSizeColumn(_arg0,_arg1,_arg2);
11045
11046     wxPy_END_ALLOW_THREADS;
11047     if (PyErr_Occurred()) return NULL;
11048 }    Py_INCREF(Py_None);
11049     _resultobj = Py_None;
11050     return _resultobj;
11051 }
11052
11053 #define wxGrid_AutoSizeRow(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AutoSizeRow(_swigarg0,_swigarg1))
11054 static PyObject *_wrap_wxGrid_AutoSizeRow(PyObject *self, PyObject *args, PyObject *kwargs) {
11055     PyObject * _resultobj;
11056     wxGrid * _arg0;
11057     int  _arg1;
11058     bool  _arg2 = (bool ) TRUE;
11059     PyObject * _argo0 = 0;
11060     int tempbool2 = (int) TRUE;
11061     char *_kwnames[] = { "self","row","setAsMin", NULL };
11062
11063     self = self;
11064     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_AutoSizeRow",_kwnames,&_argo0,&_arg1,&tempbool2))
11065         return NULL;
11066     if (_argo0) {
11067         if (_argo0 == Py_None) { _arg0 = NULL; }
11068         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11069             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeRow. Expected _wxGrid_p.");
11070         return NULL;
11071         }
11072     }
11073     _arg2 = (bool ) tempbool2;
11074 {
11075     wxPy_BEGIN_ALLOW_THREADS;
11076         wxGrid_AutoSizeRow(_arg0,_arg1,_arg2);
11077
11078     wxPy_END_ALLOW_THREADS;
11079     if (PyErr_Occurred()) return NULL;
11080 }    Py_INCREF(Py_None);
11081     _resultobj = Py_None;
11082     return _resultobj;
11083 }
11084
11085 #define wxGrid_AutoSizeColumns(_swigobj,_swigarg0)  (_swigobj->AutoSizeColumns(_swigarg0))
11086 static PyObject *_wrap_wxGrid_AutoSizeColumns(PyObject *self, PyObject *args, PyObject *kwargs) {
11087     PyObject * _resultobj;
11088     wxGrid * _arg0;
11089     bool  _arg1 = (bool ) TRUE;
11090     PyObject * _argo0 = 0;
11091     int tempbool1 = (int) TRUE;
11092     char *_kwnames[] = { "self","setAsMin", NULL };
11093
11094     self = self;
11095     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_AutoSizeColumns",_kwnames,&_argo0,&tempbool1))
11096         return NULL;
11097     if (_argo0) {
11098         if (_argo0 == Py_None) { _arg0 = NULL; }
11099         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11100             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeColumns. Expected _wxGrid_p.");
11101         return NULL;
11102         }
11103     }
11104     _arg1 = (bool ) tempbool1;
11105 {
11106     wxPy_BEGIN_ALLOW_THREADS;
11107         wxGrid_AutoSizeColumns(_arg0,_arg1);
11108
11109     wxPy_END_ALLOW_THREADS;
11110     if (PyErr_Occurred()) return NULL;
11111 }    Py_INCREF(Py_None);
11112     _resultobj = Py_None;
11113     return _resultobj;
11114 }
11115
11116 #define wxGrid_AutoSizeRows(_swigobj,_swigarg0)  (_swigobj->AutoSizeRows(_swigarg0))
11117 static PyObject *_wrap_wxGrid_AutoSizeRows(PyObject *self, PyObject *args, PyObject *kwargs) {
11118     PyObject * _resultobj;
11119     wxGrid * _arg0;
11120     bool  _arg1 = (bool ) TRUE;
11121     PyObject * _argo0 = 0;
11122     int tempbool1 = (int) TRUE;
11123     char *_kwnames[] = { "self","setAsMin", NULL };
11124
11125     self = self;
11126     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_AutoSizeRows",_kwnames,&_argo0,&tempbool1))
11127         return NULL;
11128     if (_argo0) {
11129         if (_argo0 == Py_None) { _arg0 = NULL; }
11130         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11131             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeRows. Expected _wxGrid_p.");
11132         return NULL;
11133         }
11134     }
11135     _arg1 = (bool ) tempbool1;
11136 {
11137     wxPy_BEGIN_ALLOW_THREADS;
11138         wxGrid_AutoSizeRows(_arg0,_arg1);
11139
11140     wxPy_END_ALLOW_THREADS;
11141     if (PyErr_Occurred()) return NULL;
11142 }    Py_INCREF(Py_None);
11143     _resultobj = Py_None;
11144     return _resultobj;
11145 }
11146
11147 #define wxGrid_AutoSize(_swigobj)  (_swigobj->AutoSize())
11148 static PyObject *_wrap_wxGrid_AutoSize(PyObject *self, PyObject *args, PyObject *kwargs) {
11149     PyObject * _resultobj;
11150     wxGrid * _arg0;
11151     PyObject * _argo0 = 0;
11152     char *_kwnames[] = { "self", NULL };
11153
11154     self = self;
11155     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_AutoSize",_kwnames,&_argo0))
11156         return NULL;
11157     if (_argo0) {
11158         if (_argo0 == Py_None) { _arg0 = NULL; }
11159         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11160             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSize. Expected _wxGrid_p.");
11161         return NULL;
11162         }
11163     }
11164 {
11165     wxPy_BEGIN_ALLOW_THREADS;
11166         wxGrid_AutoSize(_arg0);
11167
11168     wxPy_END_ALLOW_THREADS;
11169     if (PyErr_Occurred()) return NULL;
11170 }    Py_INCREF(Py_None);
11171     _resultobj = Py_None;
11172     return _resultobj;
11173 }
11174
11175 #define wxGrid_SetColMinimalWidth(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColMinimalWidth(_swigarg0,_swigarg1))
11176 static PyObject *_wrap_wxGrid_SetColMinimalWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
11177     PyObject * _resultobj;
11178     wxGrid * _arg0;
11179     int  _arg1;
11180     int  _arg2;
11181     PyObject * _argo0 = 0;
11182     char *_kwnames[] = { "self","col","width", NULL };
11183
11184     self = self;
11185     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColMinimalWidth",_kwnames,&_argo0,&_arg1,&_arg2))
11186         return NULL;
11187     if (_argo0) {
11188         if (_argo0 == Py_None) { _arg0 = NULL; }
11189         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11190             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColMinimalWidth. Expected _wxGrid_p.");
11191         return NULL;
11192         }
11193     }
11194 {
11195     wxPy_BEGIN_ALLOW_THREADS;
11196         wxGrid_SetColMinimalWidth(_arg0,_arg1,_arg2);
11197
11198     wxPy_END_ALLOW_THREADS;
11199     if (PyErr_Occurred()) return NULL;
11200 }    Py_INCREF(Py_None);
11201     _resultobj = Py_None;
11202     return _resultobj;
11203 }
11204
11205 #define wxGrid_SetRowMinimalHeight(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowMinimalHeight(_swigarg0,_swigarg1))
11206 static PyObject *_wrap_wxGrid_SetRowMinimalHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
11207     PyObject * _resultobj;
11208     wxGrid * _arg0;
11209     int  _arg1;
11210     int  _arg2;
11211     PyObject * _argo0 = 0;
11212     char *_kwnames[] = { "self","row","width", NULL };
11213
11214     self = self;
11215     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowMinimalHeight",_kwnames,&_argo0,&_arg1,&_arg2))
11216         return NULL;
11217     if (_argo0) {
11218         if (_argo0 == Py_None) { _arg0 = NULL; }
11219         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11220             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowMinimalHeight. Expected _wxGrid_p.");
11221         return NULL;
11222         }
11223     }
11224 {
11225     wxPy_BEGIN_ALLOW_THREADS;
11226         wxGrid_SetRowMinimalHeight(_arg0,_arg1,_arg2);
11227
11228     wxPy_END_ALLOW_THREADS;
11229     if (PyErr_Occurred()) return NULL;
11230 }    Py_INCREF(Py_None);
11231     _resultobj = Py_None;
11232     return _resultobj;
11233 }
11234
11235 #define wxGrid_SetDefaultCellBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellBackgroundColour(_swigarg0))
11236 static PyObject *_wrap_wxGrid_SetDefaultCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11237     PyObject * _resultobj;
11238     wxGrid * _arg0;
11239     wxColour * _arg1;
11240     PyObject * _argo0 = 0;
11241     wxColour  temp;
11242     PyObject * _obj1 = 0;
11243     char *_kwnames[] = { "self","arg2", NULL };
11244
11245     self = self;
11246     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellBackgroundColour",_kwnames,&_argo0,&_obj1))
11247         return NULL;
11248     if (_argo0) {
11249         if (_argo0 == Py_None) { _arg0 = NULL; }
11250         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11251             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellBackgroundColour. Expected _wxGrid_p.");
11252         return NULL;
11253         }
11254     }
11255 {
11256     _arg1 = &temp;
11257     if (! wxColour_helper(_obj1, &_arg1))
11258         return NULL;
11259 }
11260 {
11261     wxPy_BEGIN_ALLOW_THREADS;
11262         wxGrid_SetDefaultCellBackgroundColour(_arg0,*_arg1);
11263
11264     wxPy_END_ALLOW_THREADS;
11265     if (PyErr_Occurred()) return NULL;
11266 }    Py_INCREF(Py_None);
11267     _resultobj = Py_None;
11268     return _resultobj;
11269 }
11270
11271 #define wxGrid_SetCellBackgroundColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellBackgroundColour(_swigarg0,_swigarg1,_swigarg2))
11272 static PyObject *_wrap_wxGrid_SetCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11273     PyObject * _resultobj;
11274     wxGrid * _arg0;
11275     int  _arg1;
11276     int  _arg2;
11277     wxColour * _arg3;
11278     PyObject * _argo0 = 0;
11279     wxColour  temp;
11280     PyObject * _obj3 = 0;
11281     char *_kwnames[] = { "self","row","col","arg4", NULL };
11282
11283     self = self;
11284     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellBackgroundColour",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11285         return NULL;
11286     if (_argo0) {
11287         if (_argo0 == Py_None) { _arg0 = NULL; }
11288         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11289             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellBackgroundColour. Expected _wxGrid_p.");
11290         return NULL;
11291         }
11292     }
11293 {
11294     _arg3 = &temp;
11295     if (! wxColour_helper(_obj3, &_arg3))
11296         return NULL;
11297 }
11298 {
11299     wxPy_BEGIN_ALLOW_THREADS;
11300         wxGrid_SetCellBackgroundColour(_arg0,_arg1,_arg2,*_arg3);
11301
11302     wxPy_END_ALLOW_THREADS;
11303     if (PyErr_Occurred()) return NULL;
11304 }    Py_INCREF(Py_None);
11305     _resultobj = Py_None;
11306     return _resultobj;
11307 }
11308
11309 #define wxGrid_SetDefaultCellTextColour(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellTextColour(_swigarg0))
11310 static PyObject *_wrap_wxGrid_SetDefaultCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11311     PyObject * _resultobj;
11312     wxGrid * _arg0;
11313     wxColour * _arg1;
11314     PyObject * _argo0 = 0;
11315     wxColour  temp;
11316     PyObject * _obj1 = 0;
11317     char *_kwnames[] = { "self","arg2", NULL };
11318
11319     self = self;
11320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellTextColour",_kwnames,&_argo0,&_obj1))
11321         return NULL;
11322     if (_argo0) {
11323         if (_argo0 == Py_None) { _arg0 = NULL; }
11324         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11325             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellTextColour. Expected _wxGrid_p.");
11326         return NULL;
11327         }
11328     }
11329 {
11330     _arg1 = &temp;
11331     if (! wxColour_helper(_obj1, &_arg1))
11332         return NULL;
11333 }
11334 {
11335     wxPy_BEGIN_ALLOW_THREADS;
11336         wxGrid_SetDefaultCellTextColour(_arg0,*_arg1);
11337
11338     wxPy_END_ALLOW_THREADS;
11339     if (PyErr_Occurred()) return NULL;
11340 }    Py_INCREF(Py_None);
11341     _resultobj = Py_None;
11342     return _resultobj;
11343 }
11344
11345 #define wxGrid_SetCellTextColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellTextColour(_swigarg0,_swigarg1,_swigarg2))
11346 static PyObject *_wrap_wxGrid_SetCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11347     PyObject * _resultobj;
11348     wxGrid * _arg0;
11349     int  _arg1;
11350     int  _arg2;
11351     wxColour * _arg3;
11352     PyObject * _argo0 = 0;
11353     wxColour  temp;
11354     PyObject * _obj3 = 0;
11355     char *_kwnames[] = { "self","row","col","arg4", NULL };
11356
11357     self = self;
11358     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellTextColour",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11359         return NULL;
11360     if (_argo0) {
11361         if (_argo0 == Py_None) { _arg0 = NULL; }
11362         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11363             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellTextColour. Expected _wxGrid_p.");
11364         return NULL;
11365         }
11366     }
11367 {
11368     _arg3 = &temp;
11369     if (! wxColour_helper(_obj3, &_arg3))
11370         return NULL;
11371 }
11372 {
11373     wxPy_BEGIN_ALLOW_THREADS;
11374         wxGrid_SetCellTextColour(_arg0,_arg1,_arg2,*_arg3);
11375
11376     wxPy_END_ALLOW_THREADS;
11377     if (PyErr_Occurred()) return NULL;
11378 }    Py_INCREF(Py_None);
11379     _resultobj = Py_None;
11380     return _resultobj;
11381 }
11382
11383 #define wxGrid_SetDefaultCellFont(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellFont(_swigarg0))
11384 static PyObject *_wrap_wxGrid_SetDefaultCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
11385     PyObject * _resultobj;
11386     wxGrid * _arg0;
11387     wxFont * _arg1;
11388     PyObject * _argo0 = 0;
11389     PyObject * _argo1 = 0;
11390     char *_kwnames[] = { "self","arg2", NULL };
11391
11392     self = self;
11393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellFont",_kwnames,&_argo0,&_argo1))
11394         return NULL;
11395     if (_argo0) {
11396         if (_argo0 == Py_None) { _arg0 = NULL; }
11397         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11398             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellFont. Expected _wxGrid_p.");
11399         return NULL;
11400         }
11401     }
11402     if (_argo1) {
11403         if (_argo1 == Py_None) { _arg1 = NULL; }
11404         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
11405             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultCellFont. Expected _wxFont_p.");
11406         return NULL;
11407         }
11408     }
11409 {
11410     wxPy_BEGIN_ALLOW_THREADS;
11411         wxGrid_SetDefaultCellFont(_arg0,*_arg1);
11412
11413     wxPy_END_ALLOW_THREADS;
11414     if (PyErr_Occurred()) return NULL;
11415 }    Py_INCREF(Py_None);
11416     _resultobj = Py_None;
11417     return _resultobj;
11418 }
11419
11420 #define wxGrid_SetCellFont(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellFont(_swigarg0,_swigarg1,_swigarg2))
11421 static PyObject *_wrap_wxGrid_SetCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
11422     PyObject * _resultobj;
11423     wxGrid * _arg0;
11424     int  _arg1;
11425     int  _arg2;
11426     wxFont * _arg3;
11427     PyObject * _argo0 = 0;
11428     PyObject * _argo3 = 0;
11429     char *_kwnames[] = { "self","row","col","arg4", NULL };
11430
11431     self = self;
11432     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellFont",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11433         return NULL;
11434     if (_argo0) {
11435         if (_argo0 == Py_None) { _arg0 = NULL; }
11436         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11437             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellFont. Expected _wxGrid_p.");
11438         return NULL;
11439         }
11440     }
11441     if (_argo3) {
11442         if (_argo3 == Py_None) { _arg3 = NULL; }
11443         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxFont_p")) {
11444             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellFont. Expected _wxFont_p.");
11445         return NULL;
11446         }
11447     }
11448 {
11449     wxPy_BEGIN_ALLOW_THREADS;
11450         wxGrid_SetCellFont(_arg0,_arg1,_arg2,*_arg3);
11451
11452     wxPy_END_ALLOW_THREADS;
11453     if (PyErr_Occurred()) return NULL;
11454 }    Py_INCREF(Py_None);
11455     _resultobj = Py_None;
11456     return _resultobj;
11457 }
11458
11459 #define wxGrid_SetDefaultCellAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultCellAlignment(_swigarg0,_swigarg1))
11460 static PyObject *_wrap_wxGrid_SetDefaultCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
11461     PyObject * _resultobj;
11462     wxGrid * _arg0;
11463     int  _arg1;
11464     int  _arg2;
11465     PyObject * _argo0 = 0;
11466     char *_kwnames[] = { "self","horiz","vert", NULL };
11467
11468     self = self;
11469     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetDefaultCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
11470         return NULL;
11471     if (_argo0) {
11472         if (_argo0 == Py_None) { _arg0 = NULL; }
11473         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11474             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellAlignment. Expected _wxGrid_p.");
11475         return NULL;
11476         }
11477     }
11478 {
11479     wxPy_BEGIN_ALLOW_THREADS;
11480         wxGrid_SetDefaultCellAlignment(_arg0,_arg1,_arg2);
11481
11482     wxPy_END_ALLOW_THREADS;
11483     if (PyErr_Occurred()) return NULL;
11484 }    Py_INCREF(Py_None);
11485     _resultobj = Py_None;
11486     return _resultobj;
11487 }
11488
11489 #define wxGrid_SetCellAlignment(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->SetCellAlignment(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
11490 static PyObject *_wrap_wxGrid_SetCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
11491     PyObject * _resultobj;
11492     wxGrid * _arg0;
11493     int  _arg1;
11494     int  _arg2;
11495     int  _arg3;
11496     int  _arg4;
11497     PyObject * _argo0 = 0;
11498     char *_kwnames[] = { "self","row","col","horiz","vert", NULL };
11499
11500     self = self;
11501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii:wxGrid_SetCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4))
11502         return NULL;
11503     if (_argo0) {
11504         if (_argo0 == Py_None) { _arg0 = NULL; }
11505         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11506             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellAlignment. Expected _wxGrid_p.");
11507         return NULL;
11508         }
11509     }
11510 {
11511     wxPy_BEGIN_ALLOW_THREADS;
11512         wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
11513
11514     wxPy_END_ALLOW_THREADS;
11515     if (PyErr_Occurred()) return NULL;
11516 }    Py_INCREF(Py_None);
11517     _resultobj = Py_None;
11518     return _resultobj;
11519 }
11520
11521 #define wxGrid_SetDefaultRenderer(_swigobj,_swigarg0)  (_swigobj->SetDefaultRenderer(_swigarg0))
11522 static PyObject *_wrap_wxGrid_SetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11523     PyObject * _resultobj;
11524     wxGrid * _arg0;
11525     wxGridCellRenderer * _arg1;
11526     PyObject * _argo0 = 0;
11527     PyObject * _argo1 = 0;
11528     char *_kwnames[] = { "self","renderer", NULL };
11529
11530     self = self;
11531     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultRenderer",_kwnames,&_argo0,&_argo1))
11532         return NULL;
11533     if (_argo0) {
11534         if (_argo0 == Py_None) { _arg0 = NULL; }
11535         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11536             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultRenderer. Expected _wxGrid_p.");
11537         return NULL;
11538         }
11539     }
11540     if (_argo1) {
11541         if (_argo1 == Py_None) { _arg1 = NULL; }
11542         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellRenderer_p")) {
11543             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultRenderer. Expected _wxGridCellRenderer_p.");
11544         return NULL;
11545         }
11546     }
11547 {
11548     wxPy_BEGIN_ALLOW_THREADS;
11549         wxGrid_SetDefaultRenderer(_arg0,_arg1);
11550
11551     wxPy_END_ALLOW_THREADS;
11552     if (PyErr_Occurred()) return NULL;
11553 }    Py_INCREF(Py_None);
11554     _resultobj = Py_None;
11555     return _resultobj;
11556 }
11557
11558 #define wxGrid_SetCellRenderer(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellRenderer(_swigarg0,_swigarg1,_swigarg2))
11559 static PyObject *_wrap_wxGrid_SetCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11560     PyObject * _resultobj;
11561     wxGrid * _arg0;
11562     int  _arg1;
11563     int  _arg2;
11564     wxGridCellRenderer * _arg3;
11565     PyObject * _argo0 = 0;
11566     PyObject * _argo3 = 0;
11567     char *_kwnames[] = { "self","row","col","renderer", NULL };
11568
11569     self = self;
11570     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11571         return NULL;
11572     if (_argo0) {
11573         if (_argo0 == Py_None) { _arg0 = NULL; }
11574         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11575             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellRenderer. Expected _wxGrid_p.");
11576         return NULL;
11577         }
11578     }
11579     if (_argo3) {
11580         if (_argo3 == Py_None) { _arg3 = NULL; }
11581         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellRenderer_p")) {
11582             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellRenderer. Expected _wxGridCellRenderer_p.");
11583         return NULL;
11584         }
11585     }
11586 {
11587     wxPy_BEGIN_ALLOW_THREADS;
11588         wxGrid_SetCellRenderer(_arg0,_arg1,_arg2,_arg3);
11589
11590     wxPy_END_ALLOW_THREADS;
11591     if (PyErr_Occurred()) return NULL;
11592 }    Py_INCREF(Py_None);
11593     _resultobj = Py_None;
11594     return _resultobj;
11595 }
11596
11597 #define wxGrid_GetDefaultRenderer(_swigobj)  (_swigobj->GetDefaultRenderer())
11598 static PyObject *_wrap_wxGrid_GetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11599     PyObject * _resultobj;
11600     wxGridCellRenderer * _result;
11601     wxGrid * _arg0;
11602     PyObject * _argo0 = 0;
11603     char *_kwnames[] = { "self", NULL };
11604     char _ptemp[128];
11605
11606     self = self;
11607     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRenderer",_kwnames,&_argo0))
11608         return NULL;
11609     if (_argo0) {
11610         if (_argo0 == Py_None) { _arg0 = NULL; }
11611         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11612             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRenderer. Expected _wxGrid_p.");
11613         return NULL;
11614         }
11615     }
11616 {
11617     wxPy_BEGIN_ALLOW_THREADS;
11618         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRenderer(_arg0);
11619
11620     wxPy_END_ALLOW_THREADS;
11621     if (PyErr_Occurred()) return NULL;
11622 }    if (_result) {
11623         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
11624         _resultobj = Py_BuildValue("s",_ptemp);
11625     } else {
11626         Py_INCREF(Py_None);
11627         _resultobj = Py_None;
11628     }
11629     return _resultobj;
11630 }
11631
11632 #define wxGrid_GetCellRenderer(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellRenderer(_swigarg0,_swigarg1))
11633 static PyObject *_wrap_wxGrid_GetCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11634     PyObject * _resultobj;
11635     wxGridCellRenderer * _result;
11636     wxGrid * _arg0;
11637     int  _arg1;
11638     int  _arg2;
11639     PyObject * _argo0 = 0;
11640     char *_kwnames[] = { "self","row","col", NULL };
11641     char _ptemp[128];
11642
11643     self = self;
11644     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2))
11645         return NULL;
11646     if (_argo0) {
11647         if (_argo0 == Py_None) { _arg0 = NULL; }
11648         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11649             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellRenderer. Expected _wxGrid_p.");
11650         return NULL;
11651         }
11652     }
11653 {
11654     wxPy_BEGIN_ALLOW_THREADS;
11655         _result = (wxGridCellRenderer *)wxGrid_GetCellRenderer(_arg0,_arg1,_arg2);
11656
11657     wxPy_END_ALLOW_THREADS;
11658     if (PyErr_Occurred()) return NULL;
11659 }    if (_result) {
11660         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
11661         _resultobj = Py_BuildValue("s",_ptemp);
11662     } else {
11663         Py_INCREF(Py_None);
11664         _resultobj = Py_None;
11665     }
11666     return _resultobj;
11667 }
11668
11669 #define wxGrid_SetDefaultEditor(_swigobj,_swigarg0)  (_swigobj->SetDefaultEditor(_swigarg0))
11670 static PyObject *_wrap_wxGrid_SetDefaultEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11671     PyObject * _resultobj;
11672     wxGrid * _arg0;
11673     wxGridCellEditor * _arg1;
11674     PyObject * _argo0 = 0;
11675     PyObject * _argo1 = 0;
11676     char *_kwnames[] = { "self","editor", NULL };
11677
11678     self = self;
11679     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultEditor",_kwnames,&_argo0,&_argo1))
11680         return NULL;
11681     if (_argo0) {
11682         if (_argo0 == Py_None) { _arg0 = NULL; }
11683         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11684             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultEditor. Expected _wxGrid_p.");
11685         return NULL;
11686         }
11687     }
11688     if (_argo1) {
11689         if (_argo1 == Py_None) { _arg1 = NULL; }
11690         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellEditor_p")) {
11691             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultEditor. Expected _wxGridCellEditor_p.");
11692         return NULL;
11693         }
11694     }
11695 {
11696     wxPy_BEGIN_ALLOW_THREADS;
11697         wxGrid_SetDefaultEditor(_arg0,_arg1);
11698
11699     wxPy_END_ALLOW_THREADS;
11700     if (PyErr_Occurred()) return NULL;
11701 }    Py_INCREF(Py_None);
11702     _resultobj = Py_None;
11703     return _resultobj;
11704 }
11705
11706 #define wxGrid_SetCellEditor(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellEditor(_swigarg0,_swigarg1,_swigarg2))
11707 static PyObject *_wrap_wxGrid_SetCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11708     PyObject * _resultobj;
11709     wxGrid * _arg0;
11710     int  _arg1;
11711     int  _arg2;
11712     wxGridCellEditor * _arg3;
11713     PyObject * _argo0 = 0;
11714     PyObject * _argo3 = 0;
11715     char *_kwnames[] = { "self","row","col","editor", NULL };
11716
11717     self = self;
11718     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11719         return NULL;
11720     if (_argo0) {
11721         if (_argo0 == Py_None) { _arg0 = NULL; }
11722         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11723             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellEditor. Expected _wxGrid_p.");
11724         return NULL;
11725         }
11726     }
11727     if (_argo3) {
11728         if (_argo3 == Py_None) { _arg3 = NULL; }
11729         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellEditor_p")) {
11730             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellEditor. Expected _wxGridCellEditor_p.");
11731         return NULL;
11732         }
11733     }
11734 {
11735     wxPy_BEGIN_ALLOW_THREADS;
11736         wxGrid_SetCellEditor(_arg0,_arg1,_arg2,_arg3);
11737
11738     wxPy_END_ALLOW_THREADS;
11739     if (PyErr_Occurred()) return NULL;
11740 }    Py_INCREF(Py_None);
11741     _resultobj = Py_None;
11742     return _resultobj;
11743 }
11744
11745 #define wxGrid_GetDefaultEditor(_swigobj)  (_swigobj->GetDefaultEditor())
11746 static PyObject *_wrap_wxGrid_GetDefaultEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11747     PyObject * _resultobj;
11748     wxGridCellEditor * _result;
11749     wxGrid * _arg0;
11750     PyObject * _argo0 = 0;
11751     char *_kwnames[] = { "self", NULL };
11752     char _ptemp[128];
11753
11754     self = self;
11755     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultEditor",_kwnames,&_argo0))
11756         return NULL;
11757     if (_argo0) {
11758         if (_argo0 == Py_None) { _arg0 = NULL; }
11759         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11760             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditor. Expected _wxGrid_p.");
11761         return NULL;
11762         }
11763     }
11764 {
11765     wxPy_BEGIN_ALLOW_THREADS;
11766         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditor(_arg0);
11767
11768     wxPy_END_ALLOW_THREADS;
11769     if (PyErr_Occurred()) return NULL;
11770 }    if (_result) {
11771         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
11772         _resultobj = Py_BuildValue("s",_ptemp);
11773     } else {
11774         Py_INCREF(Py_None);
11775         _resultobj = Py_None;
11776     }
11777     return _resultobj;
11778 }
11779
11780 #define wxGrid_GetCellEditor(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellEditor(_swigarg0,_swigarg1))
11781 static PyObject *_wrap_wxGrid_GetCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11782     PyObject * _resultobj;
11783     wxGridCellEditor * _result;
11784     wxGrid * _arg0;
11785     int  _arg1;
11786     int  _arg2;
11787     PyObject * _argo0 = 0;
11788     char *_kwnames[] = { "self","row","col", NULL };
11789     char _ptemp[128];
11790
11791     self = self;
11792     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2))
11793         return NULL;
11794     if (_argo0) {
11795         if (_argo0 == Py_None) { _arg0 = NULL; }
11796         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11797             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellEditor. Expected _wxGrid_p.");
11798         return NULL;
11799         }
11800     }
11801 {
11802     wxPy_BEGIN_ALLOW_THREADS;
11803         _result = (wxGridCellEditor *)wxGrid_GetCellEditor(_arg0,_arg1,_arg2);
11804
11805     wxPy_END_ALLOW_THREADS;
11806     if (PyErr_Occurred()) return NULL;
11807 }    if (_result) {
11808         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
11809         _resultobj = Py_BuildValue("s",_ptemp);
11810     } else {
11811         Py_INCREF(Py_None);
11812         _resultobj = Py_None;
11813     }
11814     return _resultobj;
11815 }
11816
11817 #define wxGrid_GetCellValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellValue(_swigarg0,_swigarg1))
11818 static PyObject *_wrap_wxGrid_GetCellValue(PyObject *self, PyObject *args, PyObject *kwargs) {
11819     PyObject * _resultobj;
11820     wxString * _result;
11821     wxGrid * _arg0;
11822     int  _arg1;
11823     int  _arg2;
11824     PyObject * _argo0 = 0;
11825     char *_kwnames[] = { "self","row","col", NULL };
11826
11827     self = self;
11828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellValue",_kwnames,&_argo0,&_arg1,&_arg2))
11829         return NULL;
11830     if (_argo0) {
11831         if (_argo0 == Py_None) { _arg0 = NULL; }
11832         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11833             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellValue. Expected _wxGrid_p.");
11834         return NULL;
11835         }
11836     }
11837 {
11838     wxPy_BEGIN_ALLOW_THREADS;
11839         _result = new wxString (wxGrid_GetCellValue(_arg0,_arg1,_arg2));
11840
11841     wxPy_END_ALLOW_THREADS;
11842     if (PyErr_Occurred()) return NULL;
11843 }{
11844     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
11845 }
11846 {
11847     delete _result;
11848 }
11849     return _resultobj;
11850 }
11851
11852 #define wxGrid_SetCellValue(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellValue(_swigarg0,_swigarg1,_swigarg2))
11853 static PyObject *_wrap_wxGrid_SetCellValue(PyObject *self, PyObject *args, PyObject *kwargs) {
11854     PyObject * _resultobj;
11855     wxGrid * _arg0;
11856     int  _arg1;
11857     int  _arg2;
11858     wxString * _arg3;
11859     PyObject * _argo0 = 0;
11860     PyObject * _obj3 = 0;
11861     char *_kwnames[] = { "self","row","col","s", NULL };
11862
11863     self = self;
11864     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellValue",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11865         return NULL;
11866     if (_argo0) {
11867         if (_argo0 == Py_None) { _arg0 = NULL; }
11868         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11869             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellValue. Expected _wxGrid_p.");
11870         return NULL;
11871         }
11872     }
11873 {
11874 #if PYTHON_API_VERSION >= 1009
11875     char* tmpPtr; int tmpSize;
11876     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
11877         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
11878         return NULL;
11879     }
11880     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
11881         return NULL;
11882     _arg3 = new wxString(tmpPtr, tmpSize);
11883 #else
11884     if (!PyString_Check(_obj3)) {
11885         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
11886         return NULL;
11887     }
11888     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
11889 #endif
11890 }
11891 {
11892     wxPy_BEGIN_ALLOW_THREADS;
11893         wxGrid_SetCellValue(_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 {
11900     if (_obj3)
11901         delete _arg3;
11902 }
11903     return _resultobj;
11904 }
11905
11906 #define wxGrid_IsReadOnly(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsReadOnly(_swigarg0,_swigarg1))
11907 static PyObject *_wrap_wxGrid_IsReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
11908     PyObject * _resultobj;
11909     bool  _result;
11910     wxGrid * _arg0;
11911     int  _arg1;
11912     int  _arg2;
11913     PyObject * _argo0 = 0;
11914     char *_kwnames[] = { "self","row","col", NULL };
11915
11916     self = self;
11917     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_IsReadOnly",_kwnames,&_argo0,&_arg1,&_arg2))
11918         return NULL;
11919     if (_argo0) {
11920         if (_argo0 == Py_None) { _arg0 = NULL; }
11921         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11922             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsReadOnly. Expected _wxGrid_p.");
11923         return NULL;
11924         }
11925     }
11926 {
11927     wxPy_BEGIN_ALLOW_THREADS;
11928         _result = (bool )wxGrid_IsReadOnly(_arg0,_arg1,_arg2);
11929
11930     wxPy_END_ALLOW_THREADS;
11931     if (PyErr_Occurred()) return NULL;
11932 }    _resultobj = Py_BuildValue("i",_result);
11933     return _resultobj;
11934 }
11935
11936 #define wxGrid_SetReadOnly(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetReadOnly(_swigarg0,_swigarg1,_swigarg2))
11937 static PyObject *_wrap_wxGrid_SetReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
11938     PyObject * _resultobj;
11939     wxGrid * _arg0;
11940     int  _arg1;
11941     int  _arg2;
11942     bool  _arg3 = (bool ) TRUE;
11943     PyObject * _argo0 = 0;
11944     int tempbool3 = (int) TRUE;
11945     char *_kwnames[] = { "self","row","col","isReadOnly", NULL };
11946
11947     self = self;
11948     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_SetReadOnly",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
11949         return NULL;
11950     if (_argo0) {
11951         if (_argo0 == Py_None) { _arg0 = NULL; }
11952         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11953             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetReadOnly. Expected _wxGrid_p.");
11954         return NULL;
11955         }
11956     }
11957     _arg3 = (bool ) tempbool3;
11958 {
11959     wxPy_BEGIN_ALLOW_THREADS;
11960         wxGrid_SetReadOnly(_arg0,_arg1,_arg2,_arg3);
11961
11962     wxPy_END_ALLOW_THREADS;
11963     if (PyErr_Occurred()) return NULL;
11964 }    Py_INCREF(Py_None);
11965     _resultobj = Py_None;
11966     return _resultobj;
11967 }
11968
11969 #define wxGrid_SelectRow(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SelectRow(_swigarg0,_swigarg1))
11970 static PyObject *_wrap_wxGrid_SelectRow(PyObject *self, PyObject *args, PyObject *kwargs) {
11971     PyObject * _resultobj;
11972     wxGrid * _arg0;
11973     int  _arg1;
11974     bool  _arg2 = (bool ) FALSE;
11975     PyObject * _argo0 = 0;
11976     int tempbool2 = (int) FALSE;
11977     char *_kwnames[] = { "self","row","addToSelected", NULL };
11978
11979     self = self;
11980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SelectRow",_kwnames,&_argo0,&_arg1,&tempbool2))
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_SelectRow. Expected _wxGrid_p.");
11986         return NULL;
11987         }
11988     }
11989     _arg2 = (bool ) tempbool2;
11990 {
11991     wxPy_BEGIN_ALLOW_THREADS;
11992         wxGrid_SelectRow(_arg0,_arg1,_arg2);
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_SelectCol(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SelectCol(_swigarg0,_swigarg1))
12002 static PyObject *_wrap_wxGrid_SelectCol(PyObject *self, PyObject *args, PyObject *kwargs) {
12003     PyObject * _resultobj;
12004     wxGrid * _arg0;
12005     int  _arg1;
12006     bool  _arg2 = (bool ) FALSE;
12007     PyObject * _argo0 = 0;
12008     int tempbool2 = (int) FALSE;
12009     char *_kwnames[] = { "self","col","addToSelected", NULL };
12010
12011     self = self;
12012     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SelectCol",_kwnames,&_argo0,&_arg1,&tempbool2))
12013         return NULL;
12014     if (_argo0) {
12015         if (_argo0 == Py_None) { _arg0 = NULL; }
12016         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12017             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectCol. Expected _wxGrid_p.");
12018         return NULL;
12019         }
12020     }
12021     _arg2 = (bool ) tempbool2;
12022 {
12023     wxPy_BEGIN_ALLOW_THREADS;
12024         wxGrid_SelectCol(_arg0,_arg1,_arg2);
12025
12026     wxPy_END_ALLOW_THREADS;
12027     if (PyErr_Occurred()) return NULL;
12028 }    Py_INCREF(Py_None);
12029     _resultobj = Py_None;
12030     return _resultobj;
12031 }
12032
12033 #define wxGrid_SelectBlock(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SelectBlock(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
12034 static PyObject *_wrap_wxGrid_SelectBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
12035     PyObject * _resultobj;
12036     wxGrid * _arg0;
12037     int  _arg1;
12038     int  _arg2;
12039     int  _arg3;
12040     int  _arg4;
12041     bool  _arg5 = (bool ) FALSE;
12042     PyObject * _argo0 = 0;
12043     int tempbool5 = (int) FALSE;
12044     char *_kwnames[] = { "self","topRow","leftCol","bottomRow","rightCol","addToSelected", NULL };
12045
12046     self = self;
12047     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|i:wxGrid_SelectBlock",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&tempbool5))
12048         return NULL;
12049     if (_argo0) {
12050         if (_argo0 == Py_None) { _arg0 = NULL; }
12051         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12052             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectBlock. Expected _wxGrid_p.");
12053         return NULL;
12054         }
12055     }
12056     _arg5 = (bool ) tempbool5;
12057 {
12058     wxPy_BEGIN_ALLOW_THREADS;
12059         wxGrid_SelectBlock(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
12060
12061     wxPy_END_ALLOW_THREADS;
12062     if (PyErr_Occurred()) return NULL;
12063 }    Py_INCREF(Py_None);
12064     _resultobj = Py_None;
12065     return _resultobj;
12066 }
12067
12068 #define wxGrid_SelectAll(_swigobj)  (_swigobj->SelectAll())
12069 static PyObject *_wrap_wxGrid_SelectAll(PyObject *self, PyObject *args, PyObject *kwargs) {
12070     PyObject * _resultobj;
12071     wxGrid * _arg0;
12072     PyObject * _argo0 = 0;
12073     char *_kwnames[] = { "self", NULL };
12074
12075     self = self;
12076     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_SelectAll",_kwnames,&_argo0))
12077         return NULL;
12078     if (_argo0) {
12079         if (_argo0 == Py_None) { _arg0 = NULL; }
12080         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12081             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectAll. Expected _wxGrid_p.");
12082         return NULL;
12083         }
12084     }
12085 {
12086     wxPy_BEGIN_ALLOW_THREADS;
12087         wxGrid_SelectAll(_arg0);
12088
12089     wxPy_END_ALLOW_THREADS;
12090     if (PyErr_Occurred()) return NULL;
12091 }    Py_INCREF(Py_None);
12092     _resultobj = Py_None;
12093     return _resultobj;
12094 }
12095
12096 #define wxGrid_IsSelection(_swigobj)  (_swigobj->IsSelection())
12097 static PyObject *_wrap_wxGrid_IsSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12098     PyObject * _resultobj;
12099     bool  _result;
12100     wxGrid * _arg0;
12101     PyObject * _argo0 = 0;
12102     char *_kwnames[] = { "self", NULL };
12103
12104     self = self;
12105     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsSelection",_kwnames,&_argo0))
12106         return NULL;
12107     if (_argo0) {
12108         if (_argo0 == Py_None) { _arg0 = NULL; }
12109         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12110             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsSelection. Expected _wxGrid_p.");
12111         return NULL;
12112         }
12113     }
12114 {
12115     wxPy_BEGIN_ALLOW_THREADS;
12116         _result = (bool )wxGrid_IsSelection(_arg0);
12117
12118     wxPy_END_ALLOW_THREADS;
12119     if (PyErr_Occurred()) return NULL;
12120 }    _resultobj = Py_BuildValue("i",_result);
12121     return _resultobj;
12122 }
12123
12124 #define wxGrid_ClearSelection(_swigobj)  (_swigobj->ClearSelection())
12125 static PyObject *_wrap_wxGrid_ClearSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12126     PyObject * _resultobj;
12127     wxGrid * _arg0;
12128     PyObject * _argo0 = 0;
12129     char *_kwnames[] = { "self", NULL };
12130
12131     self = self;
12132     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ClearSelection",_kwnames,&_argo0))
12133         return NULL;
12134     if (_argo0) {
12135         if (_argo0 == Py_None) { _arg0 = NULL; }
12136         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12137             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ClearSelection. Expected _wxGrid_p.");
12138         return NULL;
12139         }
12140     }
12141 {
12142     wxPy_BEGIN_ALLOW_THREADS;
12143         wxGrid_ClearSelection(_arg0);
12144
12145     wxPy_END_ALLOW_THREADS;
12146     if (PyErr_Occurred()) return NULL;
12147 }    Py_INCREF(Py_None);
12148     _resultobj = Py_None;
12149     return _resultobj;
12150 }
12151
12152 #define wxGrid_IsInSelection(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsInSelection(_swigarg0,_swigarg1))
12153 static PyObject *_wrap_wxGrid_IsInSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12154     PyObject * _resultobj;
12155     bool  _result;
12156     wxGrid * _arg0;
12157     int  _arg1;
12158     int  _arg2;
12159     PyObject * _argo0 = 0;
12160     char *_kwnames[] = { "self","row","col", NULL };
12161
12162     self = self;
12163     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_IsInSelection",_kwnames,&_argo0,&_arg1,&_arg2))
12164         return NULL;
12165     if (_argo0) {
12166         if (_argo0 == Py_None) { _arg0 = NULL; }
12167         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12168             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsInSelection. Expected _wxGrid_p.");
12169         return NULL;
12170         }
12171     }
12172 {
12173     wxPy_BEGIN_ALLOW_THREADS;
12174         _result = (bool )wxGrid_IsInSelection(_arg0,_arg1,_arg2);
12175
12176     wxPy_END_ALLOW_THREADS;
12177     if (PyErr_Occurred()) return NULL;
12178 }    _resultobj = Py_BuildValue("i",_result);
12179     return _resultobj;
12180 }
12181
12182 #define wxGrid_BlockToDeviceRect(_swigobj,_swigarg0,_swigarg1)  (_swigobj->BlockToDeviceRect(_swigarg0,_swigarg1))
12183 static PyObject *_wrap_wxGrid_BlockToDeviceRect(PyObject *self, PyObject *args, PyObject *kwargs) {
12184     PyObject * _resultobj;
12185     wxRect * _result;
12186     wxGrid * _arg0;
12187     wxGridCellCoords * _arg1;
12188     wxGridCellCoords * _arg2;
12189     PyObject * _argo0 = 0;
12190     wxGridCellCoords  temp;
12191     PyObject * _obj1 = 0;
12192     wxGridCellCoords  temp0;
12193     PyObject * _obj2 = 0;
12194     char *_kwnames[] = { "self","topLeft","bottomRight", NULL };
12195     char _ptemp[128];
12196
12197     self = self;
12198     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_BlockToDeviceRect",_kwnames,&_argo0,&_obj1,&_obj2))
12199         return NULL;
12200     if (_argo0) {
12201         if (_argo0 == Py_None) { _arg0 = NULL; }
12202         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12203             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_BlockToDeviceRect. Expected _wxGrid_p.");
12204         return NULL;
12205         }
12206     }
12207 {
12208     _arg1 = &temp;
12209     if (! wxGridCellCoords_helper(_obj1, &_arg1))
12210         return NULL;
12211 }
12212 {
12213     _arg2 = &temp0;
12214     if (! wxGridCellCoords_helper(_obj2, &_arg2))
12215         return NULL;
12216 }
12217 {
12218     wxPy_BEGIN_ALLOW_THREADS;
12219         _result = new wxRect (wxGrid_BlockToDeviceRect(_arg0,*_arg1,*_arg2));
12220
12221     wxPy_END_ALLOW_THREADS;
12222     if (PyErr_Occurred()) return NULL;
12223 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
12224     _resultobj = Py_BuildValue("s",_ptemp);
12225     return _resultobj;
12226 }
12227
12228 #define wxGrid_GetSelectionBackground(_swigobj)  (_swigobj->GetSelectionBackground())
12229 static PyObject *_wrap_wxGrid_GetSelectionBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
12230     PyObject * _resultobj;
12231     wxColour * _result;
12232     wxGrid * _arg0;
12233     PyObject * _argo0 = 0;
12234     char *_kwnames[] = { "self", NULL };
12235     char _ptemp[128];
12236
12237     self = self;
12238     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetSelectionBackground",_kwnames,&_argo0))
12239         return NULL;
12240     if (_argo0) {
12241         if (_argo0 == Py_None) { _arg0 = NULL; }
12242         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12243             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetSelectionBackground. Expected _wxGrid_p.");
12244         return NULL;
12245         }
12246     }
12247 {
12248     wxPy_BEGIN_ALLOW_THREADS;
12249         _result = new wxColour (wxGrid_GetSelectionBackground(_arg0));
12250
12251     wxPy_END_ALLOW_THREADS;
12252     if (PyErr_Occurred()) return NULL;
12253 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
12254     _resultobj = Py_BuildValue("s",_ptemp);
12255     return _resultobj;
12256 }
12257
12258 #define wxGrid_GetSelectionForeground(_swigobj)  (_swigobj->GetSelectionForeground())
12259 static PyObject *_wrap_wxGrid_GetSelectionForeground(PyObject *self, PyObject *args, PyObject *kwargs) {
12260     PyObject * _resultobj;
12261     wxColour * _result;
12262     wxGrid * _arg0;
12263     PyObject * _argo0 = 0;
12264     char *_kwnames[] = { "self", NULL };
12265     char _ptemp[128];
12266
12267     self = self;
12268     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetSelectionForeground",_kwnames,&_argo0))
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_GetSelectionForeground. Expected _wxGrid_p.");
12274         return NULL;
12275         }
12276     }
12277 {
12278     wxPy_BEGIN_ALLOW_THREADS;
12279         _result = new wxColour (wxGrid_GetSelectionForeground(_arg0));
12280
12281     wxPy_END_ALLOW_THREADS;
12282     if (PyErr_Occurred()) return NULL;
12283 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
12284     _resultobj = Py_BuildValue("s",_ptemp);
12285     return _resultobj;
12286 }
12287
12288 #define wxGrid_SetSelectionBackground(_swigobj,_swigarg0)  (_swigobj->SetSelectionBackground(_swigarg0))
12289 static PyObject *_wrap_wxGrid_SetSelectionBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
12290     PyObject * _resultobj;
12291     wxGrid * _arg0;
12292     wxColour * _arg1;
12293     PyObject * _argo0 = 0;
12294     wxColour  temp;
12295     PyObject * _obj1 = 0;
12296     char *_kwnames[] = { "self","c", NULL };
12297
12298     self = self;
12299     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetSelectionBackground",_kwnames,&_argo0,&_obj1))
12300         return NULL;
12301     if (_argo0) {
12302         if (_argo0 == Py_None) { _arg0 = NULL; }
12303         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12304             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionBackground. Expected _wxGrid_p.");
12305         return NULL;
12306         }
12307     }
12308 {
12309     _arg1 = &temp;
12310     if (! wxColour_helper(_obj1, &_arg1))
12311         return NULL;
12312 }
12313 {
12314     wxPy_BEGIN_ALLOW_THREADS;
12315         wxGrid_SetSelectionBackground(_arg0,*_arg1);
12316
12317     wxPy_END_ALLOW_THREADS;
12318     if (PyErr_Occurred()) return NULL;
12319 }    Py_INCREF(Py_None);
12320     _resultobj = Py_None;
12321     return _resultobj;
12322 }
12323
12324 #define wxGrid_SetSelectionForeground(_swigobj,_swigarg0)  (_swigobj->SetSelectionForeground(_swigarg0))
12325 static PyObject *_wrap_wxGrid_SetSelectionForeground(PyObject *self, PyObject *args, PyObject *kwargs) {
12326     PyObject * _resultobj;
12327     wxGrid * _arg0;
12328     wxColour * _arg1;
12329     PyObject * _argo0 = 0;
12330     wxColour  temp;
12331     PyObject * _obj1 = 0;
12332     char *_kwnames[] = { "self","c", NULL };
12333
12334     self = self;
12335     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetSelectionForeground",_kwnames,&_argo0,&_obj1))
12336         return NULL;
12337     if (_argo0) {
12338         if (_argo0 == Py_None) { _arg0 = NULL; }
12339         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12340             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionForeground. Expected _wxGrid_p.");
12341         return NULL;
12342         }
12343     }
12344 {
12345     _arg1 = &temp;
12346     if (! wxColour_helper(_obj1, &_arg1))
12347         return NULL;
12348 }
12349 {
12350     wxPy_BEGIN_ALLOW_THREADS;
12351         wxGrid_SetSelectionForeground(_arg0,*_arg1);
12352
12353     wxPy_END_ALLOW_THREADS;
12354     if (PyErr_Occurred()) return NULL;
12355 }    Py_INCREF(Py_None);
12356     _resultobj = Py_None;
12357     return _resultobj;
12358 }
12359
12360 #define wxGrid_RegisterDataType(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->RegisterDataType(_swigarg0,_swigarg1,_swigarg2))
12361 static PyObject *_wrap_wxGrid_RegisterDataType(PyObject *self, PyObject *args, PyObject *kwargs) {
12362     PyObject * _resultobj;
12363     wxGrid * _arg0;
12364     wxString * _arg1;
12365     wxGridCellRenderer * _arg2;
12366     wxGridCellEditor * _arg3;
12367     PyObject * _argo0 = 0;
12368     PyObject * _obj1 = 0;
12369     PyObject * _argo2 = 0;
12370     PyObject * _argo3 = 0;
12371     char *_kwnames[] = { "self","typeName","renderer","editor", NULL };
12372
12373     self = self;
12374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO:wxGrid_RegisterDataType",_kwnames,&_argo0,&_obj1,&_argo2,&_argo3))
12375         return NULL;
12376     if (_argo0) {
12377         if (_argo0 == Py_None) { _arg0 = NULL; }
12378         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12379             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_RegisterDataType. Expected _wxGrid_p.");
12380         return NULL;
12381         }
12382     }
12383 {
12384 #if PYTHON_API_VERSION >= 1009
12385     char* tmpPtr; int tmpSize;
12386     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12387         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12388         return NULL;
12389     }
12390     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12391         return NULL;
12392     _arg1 = new wxString(tmpPtr, tmpSize);
12393 #else
12394     if (!PyString_Check(_obj1)) {
12395         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12396         return NULL;
12397     }
12398     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12399 #endif
12400 }
12401     if (_argo2) {
12402         if (_argo2 == Py_None) { _arg2 = NULL; }
12403         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellRenderer_p")) {
12404             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_RegisterDataType. Expected _wxGridCellRenderer_p.");
12405         return NULL;
12406         }
12407     }
12408     if (_argo3) {
12409         if (_argo3 == Py_None) { _arg3 = NULL; }
12410         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellEditor_p")) {
12411             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_RegisterDataType. Expected _wxGridCellEditor_p.");
12412         return NULL;
12413         }
12414     }
12415 {
12416     wxPy_BEGIN_ALLOW_THREADS;
12417         wxGrid_RegisterDataType(_arg0,*_arg1,_arg2,_arg3);
12418
12419     wxPy_END_ALLOW_THREADS;
12420     if (PyErr_Occurred()) return NULL;
12421 }    Py_INCREF(Py_None);
12422     _resultobj = Py_None;
12423 {
12424     if (_obj1)
12425         delete _arg1;
12426 }
12427     return _resultobj;
12428 }
12429
12430 #define wxGrid_GetDefaultEditorForCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultEditorForCell(_swigarg0,_swigarg1))
12431 static PyObject *_wrap_wxGrid_GetDefaultEditorForCell(PyObject *self, PyObject *args, PyObject *kwargs) {
12432     PyObject * _resultobj;
12433     wxGridCellEditor * _result;
12434     wxGrid * _arg0;
12435     int  _arg1;
12436     int  _arg2;
12437     PyObject * _argo0 = 0;
12438     char *_kwnames[] = { "self","row","col", NULL };
12439     char _ptemp[128];
12440
12441     self = self;
12442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultEditorForCell",_kwnames,&_argo0,&_arg1,&_arg2))
12443         return NULL;
12444     if (_argo0) {
12445         if (_argo0 == Py_None) { _arg0 = NULL; }
12446         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12447             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditorForCell. Expected _wxGrid_p.");
12448         return NULL;
12449         }
12450     }
12451 {
12452     wxPy_BEGIN_ALLOW_THREADS;
12453         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForCell(_arg0,_arg1,_arg2);
12454
12455     wxPy_END_ALLOW_THREADS;
12456     if (PyErr_Occurred()) return NULL;
12457 }    if (_result) {
12458         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
12459         _resultobj = Py_BuildValue("s",_ptemp);
12460     } else {
12461         Py_INCREF(Py_None);
12462         _resultobj = Py_None;
12463     }
12464     return _resultobj;
12465 }
12466
12467 #define wxGrid_GetDefaultRendererForCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultRendererForCell(_swigarg0,_swigarg1))
12468 static PyObject *_wrap_wxGrid_GetDefaultRendererForCell(PyObject *self, PyObject *args, PyObject *kwargs) {
12469     PyObject * _resultobj;
12470     wxGridCellRenderer * _result;
12471     wxGrid * _arg0;
12472     int  _arg1;
12473     int  _arg2;
12474     PyObject * _argo0 = 0;
12475     char *_kwnames[] = { "self","row","col", NULL };
12476     char _ptemp[128];
12477
12478     self = self;
12479     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultRendererForCell",_kwnames,&_argo0,&_arg1,&_arg2))
12480         return NULL;
12481     if (_argo0) {
12482         if (_argo0 == Py_None) { _arg0 = NULL; }
12483         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12484             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRendererForCell. Expected _wxGrid_p.");
12485         return NULL;
12486         }
12487     }
12488 {
12489     wxPy_BEGIN_ALLOW_THREADS;
12490         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForCell(_arg0,_arg1,_arg2);
12491
12492     wxPy_END_ALLOW_THREADS;
12493     if (PyErr_Occurred()) return NULL;
12494 }    if (_result) {
12495         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
12496         _resultobj = Py_BuildValue("s",_ptemp);
12497     } else {
12498         Py_INCREF(Py_None);
12499         _resultobj = Py_None;
12500     }
12501     return _resultobj;
12502 }
12503
12504 #define wxGrid_GetDefaultEditorForType(_swigobj,_swigarg0)  (_swigobj->GetDefaultEditorForType(_swigarg0))
12505 static PyObject *_wrap_wxGrid_GetDefaultEditorForType(PyObject *self, PyObject *args, PyObject *kwargs) {
12506     PyObject * _resultobj;
12507     wxGridCellEditor * _result;
12508     wxGrid * _arg0;
12509     wxString * _arg1;
12510     PyObject * _argo0 = 0;
12511     PyObject * _obj1 = 0;
12512     char *_kwnames[] = { "self","typeName", NULL };
12513     char _ptemp[128];
12514
12515     self = self;
12516     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultEditorForType",_kwnames,&_argo0,&_obj1))
12517         return NULL;
12518     if (_argo0) {
12519         if (_argo0 == Py_None) { _arg0 = NULL; }
12520         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12521             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditorForType. Expected _wxGrid_p.");
12522         return NULL;
12523         }
12524     }
12525 {
12526 #if PYTHON_API_VERSION >= 1009
12527     char* tmpPtr; int tmpSize;
12528     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12529         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12530         return NULL;
12531     }
12532     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12533         return NULL;
12534     _arg1 = new wxString(tmpPtr, tmpSize);
12535 #else
12536     if (!PyString_Check(_obj1)) {
12537         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12538         return NULL;
12539     }
12540     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12541 #endif
12542 }
12543 {
12544     wxPy_BEGIN_ALLOW_THREADS;
12545         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForType(_arg0,*_arg1);
12546
12547     wxPy_END_ALLOW_THREADS;
12548     if (PyErr_Occurred()) return NULL;
12549 }    if (_result) {
12550         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
12551         _resultobj = Py_BuildValue("s",_ptemp);
12552     } else {
12553         Py_INCREF(Py_None);
12554         _resultobj = Py_None;
12555     }
12556 {
12557     if (_obj1)
12558         delete _arg1;
12559 }
12560     return _resultobj;
12561 }
12562
12563 #define wxGrid_GetDefaultRendererForType(_swigobj,_swigarg0)  (_swigobj->GetDefaultRendererForType(_swigarg0))
12564 static PyObject *_wrap_wxGrid_GetDefaultRendererForType(PyObject *self, PyObject *args, PyObject *kwargs) {
12565     PyObject * _resultobj;
12566     wxGridCellRenderer * _result;
12567     wxGrid * _arg0;
12568     wxString * _arg1;
12569     PyObject * _argo0 = 0;
12570     PyObject * _obj1 = 0;
12571     char *_kwnames[] = { "self","typeName", NULL };
12572     char _ptemp[128];
12573
12574     self = self;
12575     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultRendererForType",_kwnames,&_argo0,&_obj1))
12576         return NULL;
12577     if (_argo0) {
12578         if (_argo0 == Py_None) { _arg0 = NULL; }
12579         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12580             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRendererForType. Expected _wxGrid_p.");
12581         return NULL;
12582         }
12583     }
12584 {
12585 #if PYTHON_API_VERSION >= 1009
12586     char* tmpPtr; int tmpSize;
12587     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12588         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12589         return NULL;
12590     }
12591     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12592         return NULL;
12593     _arg1 = new wxString(tmpPtr, tmpSize);
12594 #else
12595     if (!PyString_Check(_obj1)) {
12596         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12597         return NULL;
12598     }
12599     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12600 #endif
12601 }
12602 {
12603     wxPy_BEGIN_ALLOW_THREADS;
12604         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForType(_arg0,*_arg1);
12605
12606     wxPy_END_ALLOW_THREADS;
12607     if (PyErr_Occurred()) return NULL;
12608 }    if (_result) {
12609         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
12610         _resultobj = Py_BuildValue("s",_ptemp);
12611     } else {
12612         Py_INCREF(Py_None);
12613         _resultobj = Py_None;
12614     }
12615 {
12616     if (_obj1)
12617         delete _arg1;
12618 }
12619     return _resultobj;
12620 }
12621
12622 #define wxGrid_SetMargins(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetMargins(_swigarg0,_swigarg1))
12623 static PyObject *_wrap_wxGrid_SetMargins(PyObject *self, PyObject *args, PyObject *kwargs) {
12624     PyObject * _resultobj;
12625     wxGrid * _arg0;
12626     int  _arg1;
12627     int  _arg2;
12628     PyObject * _argo0 = 0;
12629     char *_kwnames[] = { "self","extraWidth","extraHeight", NULL };
12630
12631     self = self;
12632     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetMargins",_kwnames,&_argo0,&_arg1,&_arg2))
12633         return NULL;
12634     if (_argo0) {
12635         if (_argo0 == Py_None) { _arg0 = NULL; }
12636         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12637             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetMargins. Expected _wxGrid_p.");
12638         return NULL;
12639         }
12640     }
12641 {
12642     wxPy_BEGIN_ALLOW_THREADS;
12643         wxGrid_SetMargins(_arg0,_arg1,_arg2);
12644
12645     wxPy_END_ALLOW_THREADS;
12646     if (PyErr_Occurred()) return NULL;
12647 }    Py_INCREF(Py_None);
12648     _resultobj = Py_None;
12649     return _resultobj;
12650 }
12651
12652 #define wxGrid_GetGridWindow(_swigobj)  (_swigobj->GetGridWindow())
12653 static PyObject *_wrap_wxGrid_GetGridWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12654     PyObject * _resultobj;
12655     wxWindow * _result;
12656     wxGrid * _arg0;
12657     PyObject * _argo0 = 0;
12658     char *_kwnames[] = { "self", NULL };
12659
12660     self = self;
12661     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridWindow",_kwnames,&_argo0))
12662         return NULL;
12663     if (_argo0) {
12664         if (_argo0 == Py_None) { _arg0 = NULL; }
12665         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12666             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridWindow. Expected _wxGrid_p.");
12667         return NULL;
12668         }
12669     }
12670 {
12671     wxPy_BEGIN_ALLOW_THREADS;
12672         _result = (wxWindow *)wxGrid_GetGridWindow(_arg0);
12673
12674     wxPy_END_ALLOW_THREADS;
12675     if (PyErr_Occurred()) return NULL;
12676 }{ _resultobj = wxPyMake_wxObject(_result); }
12677     return _resultobj;
12678 }
12679
12680 #define wxGrid_GetGridRowLabelWindow(_swigobj)  (_swigobj->GetGridRowLabelWindow())
12681 static PyObject *_wrap_wxGrid_GetGridRowLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12682     PyObject * _resultobj;
12683     wxWindow * _result;
12684     wxGrid * _arg0;
12685     PyObject * _argo0 = 0;
12686     char *_kwnames[] = { "self", NULL };
12687
12688     self = self;
12689     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridRowLabelWindow",_kwnames,&_argo0))
12690         return NULL;
12691     if (_argo0) {
12692         if (_argo0 == Py_None) { _arg0 = NULL; }
12693         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12694             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridRowLabelWindow. Expected _wxGrid_p.");
12695         return NULL;
12696         }
12697     }
12698 {
12699     wxPy_BEGIN_ALLOW_THREADS;
12700         _result = (wxWindow *)wxGrid_GetGridRowLabelWindow(_arg0);
12701
12702     wxPy_END_ALLOW_THREADS;
12703     if (PyErr_Occurred()) return NULL;
12704 }{ _resultobj = wxPyMake_wxObject(_result); }
12705     return _resultobj;
12706 }
12707
12708 #define wxGrid_GetGridColLabelWindow(_swigobj)  (_swigobj->GetGridColLabelWindow())
12709 static PyObject *_wrap_wxGrid_GetGridColLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12710     PyObject * _resultobj;
12711     wxWindow * _result;
12712     wxGrid * _arg0;
12713     PyObject * _argo0 = 0;
12714     char *_kwnames[] = { "self", NULL };
12715
12716     self = self;
12717     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridColLabelWindow",_kwnames,&_argo0))
12718         return NULL;
12719     if (_argo0) {
12720         if (_argo0 == Py_None) { _arg0 = NULL; }
12721         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12722             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridColLabelWindow. Expected _wxGrid_p.");
12723         return NULL;
12724         }
12725     }
12726 {
12727     wxPy_BEGIN_ALLOW_THREADS;
12728         _result = (wxWindow *)wxGrid_GetGridColLabelWindow(_arg0);
12729
12730     wxPy_END_ALLOW_THREADS;
12731     if (PyErr_Occurred()) return NULL;
12732 }{ _resultobj = wxPyMake_wxObject(_result); }
12733     return _resultobj;
12734 }
12735
12736 #define wxGrid_GetGridCornerLabelWindow(_swigobj)  (_swigobj->GetGridCornerLabelWindow())
12737 static PyObject *_wrap_wxGrid_GetGridCornerLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12738     PyObject * _resultobj;
12739     wxWindow * _result;
12740     wxGrid * _arg0;
12741     PyObject * _argo0 = 0;
12742     char *_kwnames[] = { "self", NULL };
12743
12744     self = self;
12745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCornerLabelWindow",_kwnames,&_argo0))
12746         return NULL;
12747     if (_argo0) {
12748         if (_argo0 == Py_None) { _arg0 = NULL; }
12749         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12750             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCornerLabelWindow. Expected _wxGrid_p.");
12751         return NULL;
12752         }
12753     }
12754 {
12755     wxPy_BEGIN_ALLOW_THREADS;
12756         _result = (wxWindow *)wxGrid_GetGridCornerLabelWindow(_arg0);
12757
12758     wxPy_END_ALLOW_THREADS;
12759     if (PyErr_Occurred()) return NULL;
12760 }{ _resultobj = wxPyMake_wxObject(_result); }
12761     return _resultobj;
12762 }
12763
12764 static void *SwigwxGridEventTowxNotifyEvent(void *ptr) {
12765     wxGridEvent *src;
12766     wxNotifyEvent *dest;
12767     src = (wxGridEvent *) ptr;
12768     dest = (wxNotifyEvent *) src;
12769     return (void *) dest;
12770 }
12771
12772 static void *SwigwxGridEventTowxCommandEvent(void *ptr) {
12773     wxGridEvent *src;
12774     wxCommandEvent *dest;
12775     src = (wxGridEvent *) ptr;
12776     dest = (wxCommandEvent *) src;
12777     return (void *) dest;
12778 }
12779
12780 static void *SwigwxGridEventTowxEvent(void *ptr) {
12781     wxGridEvent *src;
12782     wxEvent *dest;
12783     src = (wxGridEvent *) ptr;
12784     dest = (wxEvent *) src;
12785     return (void *) dest;
12786 }
12787
12788 static void *SwigwxGridEventTowxObject(void *ptr) {
12789     wxGridEvent *src;
12790     wxObject *dest;
12791     src = (wxGridEvent *) ptr;
12792     dest = (wxObject *) src;
12793     return (void *) dest;
12794 }
12795
12796 #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))
12797 static PyObject *_wrap_new_wxGridEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
12798     PyObject * _resultobj;
12799     wxGridEvent * _result;
12800     int  _arg0;
12801     wxEventType  _arg1;
12802     wxGrid * _arg2;
12803     int  _arg3 = (int ) -1;
12804     int  _arg4 = (int ) -1;
12805     int  _arg5 = (int ) -1;
12806     int  _arg6 = (int ) -1;
12807     bool  _arg7 = (bool ) TRUE;
12808     bool  _arg8 = (bool ) FALSE;
12809     bool  _arg9 = (bool ) FALSE;
12810     bool  _arg10 = (bool ) FALSE;
12811     bool  _arg11 = (bool ) FALSE;
12812     PyObject * _argo2 = 0;
12813     int tempbool7 = (int) TRUE;
12814     int tempbool8 = (int) FALSE;
12815     int tempbool9 = (int) FALSE;
12816     int tempbool10 = (int) FALSE;
12817     int tempbool11 = (int) FALSE;
12818     char *_kwnames[] = { "id","type","obj","row","col","x","y","sel","control","shift","alt","meta", NULL };
12819     char _ptemp[128];
12820
12821     self = self;
12822     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO|iiiiiiiii:new_wxGridEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_arg5,&_arg6,&tempbool7,&tempbool8,&tempbool9,&tempbool10,&tempbool11))
12823         return NULL;
12824     if (_argo2) {
12825         if (_argo2 == Py_None) { _arg2 = NULL; }
12826         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
12827             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridEvent. Expected _wxGrid_p.");
12828         return NULL;
12829         }
12830     }
12831     _arg7 = (bool ) tempbool7;
12832     _arg8 = (bool ) tempbool8;
12833     _arg9 = (bool ) tempbool9;
12834     _arg10 = (bool ) tempbool10;
12835     _arg11 = (bool ) tempbool11;
12836 {
12837     wxPy_BEGIN_ALLOW_THREADS;
12838         _result = (wxGridEvent *)new_wxGridEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9,_arg10,_arg11);
12839
12840     wxPy_END_ALLOW_THREADS;
12841     if (PyErr_Occurred()) return NULL;
12842 }    if (_result) {
12843         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEvent_p");
12844         _resultobj = Py_BuildValue("s",_ptemp);
12845     } else {
12846         Py_INCREF(Py_None);
12847         _resultobj = Py_None;
12848     }
12849     return _resultobj;
12850 }
12851
12852 #define wxGridEvent_GetRow(_swigobj)  (_swigobj->GetRow())
12853 static PyObject *_wrap_wxGridEvent_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
12854     PyObject * _resultobj;
12855     int  _result;
12856     wxGridEvent * _arg0;
12857     PyObject * _argo0 = 0;
12858     char *_kwnames[] = { "self", NULL };
12859
12860     self = self;
12861     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetRow",_kwnames,&_argo0))
12862         return NULL;
12863     if (_argo0) {
12864         if (_argo0 == Py_None) { _arg0 = NULL; }
12865         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12866             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetRow. Expected _wxGridEvent_p.");
12867         return NULL;
12868         }
12869     }
12870 {
12871     wxPy_BEGIN_ALLOW_THREADS;
12872         _result = (int )wxGridEvent_GetRow(_arg0);
12873
12874     wxPy_END_ALLOW_THREADS;
12875     if (PyErr_Occurred()) return NULL;
12876 }    _resultobj = Py_BuildValue("i",_result);
12877     return _resultobj;
12878 }
12879
12880 #define wxGridEvent_GetCol(_swigobj)  (_swigobj->GetCol())
12881 static PyObject *_wrap_wxGridEvent_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
12882     PyObject * _resultobj;
12883     int  _result;
12884     wxGridEvent * _arg0;
12885     PyObject * _argo0 = 0;
12886     char *_kwnames[] = { "self", NULL };
12887
12888     self = self;
12889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetCol",_kwnames,&_argo0))
12890         return NULL;
12891     if (_argo0) {
12892         if (_argo0 == Py_None) { _arg0 = NULL; }
12893         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12894             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetCol. Expected _wxGridEvent_p.");
12895         return NULL;
12896         }
12897     }
12898 {
12899     wxPy_BEGIN_ALLOW_THREADS;
12900         _result = (int )wxGridEvent_GetCol(_arg0);
12901
12902     wxPy_END_ALLOW_THREADS;
12903     if (PyErr_Occurred()) return NULL;
12904 }    _resultobj = Py_BuildValue("i",_result);
12905     return _resultobj;
12906 }
12907
12908 #define wxGridEvent_GetPosition(_swigobj)  (_swigobj->GetPosition())
12909 static PyObject *_wrap_wxGridEvent_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
12910     PyObject * _resultobj;
12911     wxPoint * _result;
12912     wxGridEvent * _arg0;
12913     PyObject * _argo0 = 0;
12914     char *_kwnames[] = { "self", NULL };
12915     char _ptemp[128];
12916
12917     self = self;
12918     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetPosition",_kwnames,&_argo0))
12919         return NULL;
12920     if (_argo0) {
12921         if (_argo0 == Py_None) { _arg0 = NULL; }
12922         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12923             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetPosition. Expected _wxGridEvent_p.");
12924         return NULL;
12925         }
12926     }
12927 {
12928     wxPy_BEGIN_ALLOW_THREADS;
12929         _result = new wxPoint (wxGridEvent_GetPosition(_arg0));
12930
12931     wxPy_END_ALLOW_THREADS;
12932     if (PyErr_Occurred()) return NULL;
12933 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
12934     _resultobj = Py_BuildValue("s",_ptemp);
12935     return _resultobj;
12936 }
12937
12938 #define wxGridEvent_Selecting(_swigobj)  (_swigobj->Selecting())
12939 static PyObject *_wrap_wxGridEvent_Selecting(PyObject *self, PyObject *args, PyObject *kwargs) {
12940     PyObject * _resultobj;
12941     bool  _result;
12942     wxGridEvent * _arg0;
12943     PyObject * _argo0 = 0;
12944     char *_kwnames[] = { "self", NULL };
12945
12946     self = self;
12947     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_Selecting",_kwnames,&_argo0))
12948         return NULL;
12949     if (_argo0) {
12950         if (_argo0 == Py_None) { _arg0 = NULL; }
12951         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12952             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_Selecting. Expected _wxGridEvent_p.");
12953         return NULL;
12954         }
12955     }
12956 {
12957     wxPy_BEGIN_ALLOW_THREADS;
12958         _result = (bool )wxGridEvent_Selecting(_arg0);
12959
12960     wxPy_END_ALLOW_THREADS;
12961     if (PyErr_Occurred()) return NULL;
12962 }    _resultobj = Py_BuildValue("i",_result);
12963     return _resultobj;
12964 }
12965
12966 #define wxGridEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
12967 static PyObject *_wrap_wxGridEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12968     PyObject * _resultobj;
12969     bool  _result;
12970     wxGridEvent * _arg0;
12971     PyObject * _argo0 = 0;
12972     char *_kwnames[] = { "self", NULL };
12973
12974     self = self;
12975     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_ControlDown",_kwnames,&_argo0))
12976         return NULL;
12977     if (_argo0) {
12978         if (_argo0 == Py_None) { _arg0 = NULL; }
12979         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12980             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_ControlDown. Expected _wxGridEvent_p.");
12981         return NULL;
12982         }
12983     }
12984 {
12985     wxPy_BEGIN_ALLOW_THREADS;
12986         _result = (bool )wxGridEvent_ControlDown(_arg0);
12987
12988     wxPy_END_ALLOW_THREADS;
12989     if (PyErr_Occurred()) return NULL;
12990 }    _resultobj = Py_BuildValue("i",_result);
12991     return _resultobj;
12992 }
12993
12994 #define wxGridEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
12995 static PyObject *_wrap_wxGridEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12996     PyObject * _resultobj;
12997     bool  _result;
12998     wxGridEvent * _arg0;
12999     PyObject * _argo0 = 0;
13000     char *_kwnames[] = { "self", NULL };
13001
13002     self = self;
13003     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_MetaDown",_kwnames,&_argo0))
13004         return NULL;
13005     if (_argo0) {
13006         if (_argo0 == Py_None) { _arg0 = NULL; }
13007         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
13008             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_MetaDown. Expected _wxGridEvent_p.");
13009         return NULL;
13010         }
13011     }
13012 {
13013     wxPy_BEGIN_ALLOW_THREADS;
13014         _result = (bool )wxGridEvent_MetaDown(_arg0);
13015
13016     wxPy_END_ALLOW_THREADS;
13017     if (PyErr_Occurred()) return NULL;
13018 }    _resultobj = Py_BuildValue("i",_result);
13019     return _resultobj;
13020 }
13021
13022 #define wxGridEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13023 static PyObject *_wrap_wxGridEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13024     PyObject * _resultobj;
13025     bool  _result;
13026     wxGridEvent * _arg0;
13027     PyObject * _argo0 = 0;
13028     char *_kwnames[] = { "self", NULL };
13029
13030     self = self;
13031     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_ShiftDown",_kwnames,&_argo0))
13032         return NULL;
13033     if (_argo0) {
13034         if (_argo0 == Py_None) { _arg0 = NULL; }
13035         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
13036             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_ShiftDown. Expected _wxGridEvent_p.");
13037         return NULL;
13038         }
13039     }
13040 {
13041     wxPy_BEGIN_ALLOW_THREADS;
13042         _result = (bool )wxGridEvent_ShiftDown(_arg0);
13043
13044     wxPy_END_ALLOW_THREADS;
13045     if (PyErr_Occurred()) return NULL;
13046 }    _resultobj = Py_BuildValue("i",_result);
13047     return _resultobj;
13048 }
13049
13050 #define wxGridEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13051 static PyObject *_wrap_wxGridEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13052     PyObject * _resultobj;
13053     bool  _result;
13054     wxGridEvent * _arg0;
13055     PyObject * _argo0 = 0;
13056     char *_kwnames[] = { "self", NULL };
13057
13058     self = self;
13059     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_AltDown",_kwnames,&_argo0))
13060         return NULL;
13061     if (_argo0) {
13062         if (_argo0 == Py_None) { _arg0 = NULL; }
13063         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
13064             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_AltDown. Expected _wxGridEvent_p.");
13065         return NULL;
13066         }
13067     }
13068 {
13069     wxPy_BEGIN_ALLOW_THREADS;
13070         _result = (bool )wxGridEvent_AltDown(_arg0);
13071
13072     wxPy_END_ALLOW_THREADS;
13073     if (PyErr_Occurred()) return NULL;
13074 }    _resultobj = Py_BuildValue("i",_result);
13075     return _resultobj;
13076 }
13077
13078 static void *SwigwxGridSizeEventTowxNotifyEvent(void *ptr) {
13079     wxGridSizeEvent *src;
13080     wxNotifyEvent *dest;
13081     src = (wxGridSizeEvent *) ptr;
13082     dest = (wxNotifyEvent *) src;
13083     return (void *) dest;
13084 }
13085
13086 static void *SwigwxGridSizeEventTowxCommandEvent(void *ptr) {
13087     wxGridSizeEvent *src;
13088     wxCommandEvent *dest;
13089     src = (wxGridSizeEvent *) ptr;
13090     dest = (wxCommandEvent *) src;
13091     return (void *) dest;
13092 }
13093
13094 static void *SwigwxGridSizeEventTowxEvent(void *ptr) {
13095     wxGridSizeEvent *src;
13096     wxEvent *dest;
13097     src = (wxGridSizeEvent *) ptr;
13098     dest = (wxEvent *) src;
13099     return (void *) dest;
13100 }
13101
13102 static void *SwigwxGridSizeEventTowxObject(void *ptr) {
13103     wxGridSizeEvent *src;
13104     wxObject *dest;
13105     src = (wxGridSizeEvent *) ptr;
13106     dest = (wxObject *) src;
13107     return (void *) dest;
13108 }
13109
13110 #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))
13111 static PyObject *_wrap_new_wxGridSizeEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13112     PyObject * _resultobj;
13113     wxGridSizeEvent * _result;
13114     int  _arg0;
13115     wxEventType  _arg1;
13116     wxGrid * _arg2;
13117     int  _arg3 = (int ) -1;
13118     int  _arg4 = (int ) -1;
13119     int  _arg5 = (int ) -1;
13120     bool  _arg6 = (bool ) FALSE;
13121     bool  _arg7 = (bool ) FALSE;
13122     bool  _arg8 = (bool ) FALSE;
13123     bool  _arg9 = (bool ) FALSE;
13124     PyObject * _argo2 = 0;
13125     int tempbool6 = (int) FALSE;
13126     int tempbool7 = (int) FALSE;
13127     int tempbool8 = (int) FALSE;
13128     int tempbool9 = (int) FALSE;
13129     char *_kwnames[] = { "id","type","obj","rowOrCol","x","y","control","shift","alt","meta", NULL };
13130     char _ptemp[128];
13131
13132     self = self;
13133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO|iiiiiii:new_wxGridSizeEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_arg5,&tempbool6,&tempbool7,&tempbool8,&tempbool9))
13134         return NULL;
13135     if (_argo2) {
13136         if (_argo2 == Py_None) { _arg2 = NULL; }
13137         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
13138             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridSizeEvent. Expected _wxGrid_p.");
13139         return NULL;
13140         }
13141     }
13142     _arg6 = (bool ) tempbool6;
13143     _arg7 = (bool ) tempbool7;
13144     _arg8 = (bool ) tempbool8;
13145     _arg9 = (bool ) tempbool9;
13146 {
13147     wxPy_BEGIN_ALLOW_THREADS;
13148         _result = (wxGridSizeEvent *)new_wxGridSizeEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
13149
13150     wxPy_END_ALLOW_THREADS;
13151     if (PyErr_Occurred()) return NULL;
13152 }    if (_result) {
13153         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridSizeEvent_p");
13154         _resultobj = Py_BuildValue("s",_ptemp);
13155     } else {
13156         Py_INCREF(Py_None);
13157         _resultobj = Py_None;
13158     }
13159     return _resultobj;
13160 }
13161
13162 #define wxGridSizeEvent_GetRowOrCol(_swigobj)  (_swigobj->GetRowOrCol())
13163 static PyObject *_wrap_wxGridSizeEvent_GetRowOrCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13164     PyObject * _resultobj;
13165     int  _result;
13166     wxGridSizeEvent * _arg0;
13167     PyObject * _argo0 = 0;
13168     char *_kwnames[] = { "self", NULL };
13169
13170     self = self;
13171     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_GetRowOrCol",_kwnames,&_argo0))
13172         return NULL;
13173     if (_argo0) {
13174         if (_argo0 == Py_None) { _arg0 = NULL; }
13175         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13176             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_GetRowOrCol. Expected _wxGridSizeEvent_p.");
13177         return NULL;
13178         }
13179     }
13180 {
13181     wxPy_BEGIN_ALLOW_THREADS;
13182         _result = (int )wxGridSizeEvent_GetRowOrCol(_arg0);
13183
13184     wxPy_END_ALLOW_THREADS;
13185     if (PyErr_Occurred()) return NULL;
13186 }    _resultobj = Py_BuildValue("i",_result);
13187     return _resultobj;
13188 }
13189
13190 #define wxGridSizeEvent_GetPosition(_swigobj)  (_swigobj->GetPosition())
13191 static PyObject *_wrap_wxGridSizeEvent_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
13192     PyObject * _resultobj;
13193     wxPoint * _result;
13194     wxGridSizeEvent * _arg0;
13195     PyObject * _argo0 = 0;
13196     char *_kwnames[] = { "self", NULL };
13197     char _ptemp[128];
13198
13199     self = self;
13200     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_GetPosition",_kwnames,&_argo0))
13201         return NULL;
13202     if (_argo0) {
13203         if (_argo0 == Py_None) { _arg0 = NULL; }
13204         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13205             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_GetPosition. Expected _wxGridSizeEvent_p.");
13206         return NULL;
13207         }
13208     }
13209 {
13210     wxPy_BEGIN_ALLOW_THREADS;
13211         _result = new wxPoint (wxGridSizeEvent_GetPosition(_arg0));
13212
13213     wxPy_END_ALLOW_THREADS;
13214     if (PyErr_Occurred()) return NULL;
13215 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
13216     _resultobj = Py_BuildValue("s",_ptemp);
13217     return _resultobj;
13218 }
13219
13220 #define wxGridSizeEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
13221 static PyObject *_wrap_wxGridSizeEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13222     PyObject * _resultobj;
13223     bool  _result;
13224     wxGridSizeEvent * _arg0;
13225     PyObject * _argo0 = 0;
13226     char *_kwnames[] = { "self", NULL };
13227
13228     self = self;
13229     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_ControlDown",_kwnames,&_argo0))
13230         return NULL;
13231     if (_argo0) {
13232         if (_argo0 == Py_None) { _arg0 = NULL; }
13233         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13234             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_ControlDown. Expected _wxGridSizeEvent_p.");
13235         return NULL;
13236         }
13237     }
13238 {
13239     wxPy_BEGIN_ALLOW_THREADS;
13240         _result = (bool )wxGridSizeEvent_ControlDown(_arg0);
13241
13242     wxPy_END_ALLOW_THREADS;
13243     if (PyErr_Occurred()) return NULL;
13244 }    _resultobj = Py_BuildValue("i",_result);
13245     return _resultobj;
13246 }
13247
13248 #define wxGridSizeEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
13249 static PyObject *_wrap_wxGridSizeEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13250     PyObject * _resultobj;
13251     bool  _result;
13252     wxGridSizeEvent * _arg0;
13253     PyObject * _argo0 = 0;
13254     char *_kwnames[] = { "self", NULL };
13255
13256     self = self;
13257     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_MetaDown",_kwnames,&_argo0))
13258         return NULL;
13259     if (_argo0) {
13260         if (_argo0 == Py_None) { _arg0 = NULL; }
13261         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13262             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_MetaDown. Expected _wxGridSizeEvent_p.");
13263         return NULL;
13264         }
13265     }
13266 {
13267     wxPy_BEGIN_ALLOW_THREADS;
13268         _result = (bool )wxGridSizeEvent_MetaDown(_arg0);
13269
13270     wxPy_END_ALLOW_THREADS;
13271     if (PyErr_Occurred()) return NULL;
13272 }    _resultobj = Py_BuildValue("i",_result);
13273     return _resultobj;
13274 }
13275
13276 #define wxGridSizeEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13277 static PyObject *_wrap_wxGridSizeEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13278     PyObject * _resultobj;
13279     bool  _result;
13280     wxGridSizeEvent * _arg0;
13281     PyObject * _argo0 = 0;
13282     char *_kwnames[] = { "self", NULL };
13283
13284     self = self;
13285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_ShiftDown",_kwnames,&_argo0))
13286         return NULL;
13287     if (_argo0) {
13288         if (_argo0 == Py_None) { _arg0 = NULL; }
13289         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13290             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_ShiftDown. Expected _wxGridSizeEvent_p.");
13291         return NULL;
13292         }
13293     }
13294 {
13295     wxPy_BEGIN_ALLOW_THREADS;
13296         _result = (bool )wxGridSizeEvent_ShiftDown(_arg0);
13297
13298     wxPy_END_ALLOW_THREADS;
13299     if (PyErr_Occurred()) return NULL;
13300 }    _resultobj = Py_BuildValue("i",_result);
13301     return _resultobj;
13302 }
13303
13304 #define wxGridSizeEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13305 static PyObject *_wrap_wxGridSizeEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13306     PyObject * _resultobj;
13307     bool  _result;
13308     wxGridSizeEvent * _arg0;
13309     PyObject * _argo0 = 0;
13310     char *_kwnames[] = { "self", NULL };
13311
13312     self = self;
13313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_AltDown",_kwnames,&_argo0))
13314         return NULL;
13315     if (_argo0) {
13316         if (_argo0 == Py_None) { _arg0 = NULL; }
13317         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13318             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_AltDown. Expected _wxGridSizeEvent_p.");
13319         return NULL;
13320         }
13321     }
13322 {
13323     wxPy_BEGIN_ALLOW_THREADS;
13324         _result = (bool )wxGridSizeEvent_AltDown(_arg0);
13325
13326     wxPy_END_ALLOW_THREADS;
13327     if (PyErr_Occurred()) return NULL;
13328 }    _resultobj = Py_BuildValue("i",_result);
13329     return _resultobj;
13330 }
13331
13332 static void *SwigwxGridRangeSelectEventTowxNotifyEvent(void *ptr) {
13333     wxGridRangeSelectEvent *src;
13334     wxNotifyEvent *dest;
13335     src = (wxGridRangeSelectEvent *) ptr;
13336     dest = (wxNotifyEvent *) src;
13337     return (void *) dest;
13338 }
13339
13340 static void *SwigwxGridRangeSelectEventTowxCommandEvent(void *ptr) {
13341     wxGridRangeSelectEvent *src;
13342     wxCommandEvent *dest;
13343     src = (wxGridRangeSelectEvent *) ptr;
13344     dest = (wxCommandEvent *) src;
13345     return (void *) dest;
13346 }
13347
13348 static void *SwigwxGridRangeSelectEventTowxEvent(void *ptr) {
13349     wxGridRangeSelectEvent *src;
13350     wxEvent *dest;
13351     src = (wxGridRangeSelectEvent *) ptr;
13352     dest = (wxEvent *) src;
13353     return (void *) dest;
13354 }
13355
13356 static void *SwigwxGridRangeSelectEventTowxObject(void *ptr) {
13357     wxGridRangeSelectEvent *src;
13358     wxObject *dest;
13359     src = (wxGridRangeSelectEvent *) ptr;
13360     dest = (wxObject *) src;
13361     return (void *) dest;
13362 }
13363
13364 #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))
13365 static PyObject *_wrap_new_wxGridRangeSelectEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13366     PyObject * _resultobj;
13367     wxGridRangeSelectEvent * _result;
13368     int  _arg0;
13369     wxEventType  _arg1;
13370     wxGrid * _arg2;
13371     wxGridCellCoords * _arg3;
13372     wxGridCellCoords * _arg4;
13373     bool  _arg5 = (bool ) TRUE;
13374     bool  _arg6 = (bool ) FALSE;
13375     bool  _arg7 = (bool ) FALSE;
13376     bool  _arg8 = (bool ) FALSE;
13377     bool  _arg9 = (bool ) FALSE;
13378     PyObject * _argo2 = 0;
13379     wxGridCellCoords  temp;
13380     PyObject * _obj3 = 0;
13381     wxGridCellCoords  temp0;
13382     PyObject * _obj4 = 0;
13383     int tempbool5 = (int) TRUE;
13384     int tempbool6 = (int) FALSE;
13385     int tempbool7 = (int) FALSE;
13386     int tempbool8 = (int) FALSE;
13387     int tempbool9 = (int) FALSE;
13388     char *_kwnames[] = { "id","type","obj","topLeft","bottomRight","sel","control","shift","alt","meta", NULL };
13389     char _ptemp[128];
13390
13391     self = self;
13392     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiOOO|iiiii:new_wxGridRangeSelectEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_obj3,&_obj4,&tempbool5,&tempbool6,&tempbool7,&tempbool8,&tempbool9))
13393         return NULL;
13394     if (_argo2) {
13395         if (_argo2 == Py_None) { _arg2 = NULL; }
13396         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
13397             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridRangeSelectEvent. Expected _wxGrid_p.");
13398         return NULL;
13399         }
13400     }
13401 {
13402     _arg3 = &temp;
13403     if (! wxGridCellCoords_helper(_obj3, &_arg3))
13404         return NULL;
13405 }
13406 {
13407     _arg4 = &temp0;
13408     if (! wxGridCellCoords_helper(_obj4, &_arg4))
13409         return NULL;
13410 }
13411     _arg5 = (bool ) tempbool5;
13412     _arg6 = (bool ) tempbool6;
13413     _arg7 = (bool ) tempbool7;
13414     _arg8 = (bool ) tempbool8;
13415     _arg9 = (bool ) tempbool9;
13416 {
13417     wxPy_BEGIN_ALLOW_THREADS;
13418         _result = (wxGridRangeSelectEvent *)new_wxGridRangeSelectEvent(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
13419
13420     wxPy_END_ALLOW_THREADS;
13421     if (PyErr_Occurred()) return NULL;
13422 }    if (_result) {
13423         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridRangeSelectEvent_p");
13424         _resultobj = Py_BuildValue("s",_ptemp);
13425     } else {
13426         Py_INCREF(Py_None);
13427         _resultobj = Py_None;
13428     }
13429     return _resultobj;
13430 }
13431
13432 #define wxGridRangeSelectEvent_GetTopLeftCoords(_swigobj)  (_swigobj->GetTopLeftCoords())
13433 static PyObject *_wrap_wxGridRangeSelectEvent_GetTopLeftCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
13434     PyObject * _resultobj;
13435     wxGridCellCoords * _result;
13436     wxGridRangeSelectEvent * _arg0;
13437     PyObject * _argo0 = 0;
13438     char *_kwnames[] = { "self", NULL };
13439     char _ptemp[128];
13440
13441     self = self;
13442     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetTopLeftCoords",_kwnames,&_argo0))
13443         return NULL;
13444     if (_argo0) {
13445         if (_argo0 == Py_None) { _arg0 = NULL; }
13446         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13447             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetTopLeftCoords. Expected _wxGridRangeSelectEvent_p.");
13448         return NULL;
13449         }
13450     }
13451 {
13452     wxPy_BEGIN_ALLOW_THREADS;
13453         _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetTopLeftCoords(_arg0));
13454
13455     wxPy_END_ALLOW_THREADS;
13456     if (PyErr_Occurred()) return NULL;
13457 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
13458     _resultobj = Py_BuildValue("s",_ptemp);
13459     return _resultobj;
13460 }
13461
13462 #define wxGridRangeSelectEvent_GetBottomRightCoords(_swigobj)  (_swigobj->GetBottomRightCoords())
13463 static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRightCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
13464     PyObject * _resultobj;
13465     wxGridCellCoords * _result;
13466     wxGridRangeSelectEvent * _arg0;
13467     PyObject * _argo0 = 0;
13468     char *_kwnames[] = { "self", NULL };
13469     char _ptemp[128];
13470
13471     self = self;
13472     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetBottomRightCoords",_kwnames,&_argo0))
13473         return NULL;
13474     if (_argo0) {
13475         if (_argo0 == Py_None) { _arg0 = NULL; }
13476         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13477             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetBottomRightCoords. Expected _wxGridRangeSelectEvent_p.");
13478         return NULL;
13479         }
13480     }
13481 {
13482     wxPy_BEGIN_ALLOW_THREADS;
13483         _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetBottomRightCoords(_arg0));
13484
13485     wxPy_END_ALLOW_THREADS;
13486     if (PyErr_Occurred()) return NULL;
13487 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
13488     _resultobj = Py_BuildValue("s",_ptemp);
13489     return _resultobj;
13490 }
13491
13492 #define wxGridRangeSelectEvent_GetTopRow(_swigobj)  (_swigobj->GetTopRow())
13493 static PyObject *_wrap_wxGridRangeSelectEvent_GetTopRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13494     PyObject * _resultobj;
13495     int  _result;
13496     wxGridRangeSelectEvent * _arg0;
13497     PyObject * _argo0 = 0;
13498     char *_kwnames[] = { "self", NULL };
13499
13500     self = self;
13501     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetTopRow",_kwnames,&_argo0))
13502         return NULL;
13503     if (_argo0) {
13504         if (_argo0 == Py_None) { _arg0 = NULL; }
13505         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13506             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetTopRow. Expected _wxGridRangeSelectEvent_p.");
13507         return NULL;
13508         }
13509     }
13510 {
13511     wxPy_BEGIN_ALLOW_THREADS;
13512         _result = (int )wxGridRangeSelectEvent_GetTopRow(_arg0);
13513
13514     wxPy_END_ALLOW_THREADS;
13515     if (PyErr_Occurred()) return NULL;
13516 }    _resultobj = Py_BuildValue("i",_result);
13517     return _resultobj;
13518 }
13519
13520 #define wxGridRangeSelectEvent_GetBottomRow(_swigobj)  (_swigobj->GetBottomRow())
13521 static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13522     PyObject * _resultobj;
13523     int  _result;
13524     wxGridRangeSelectEvent * _arg0;
13525     PyObject * _argo0 = 0;
13526     char *_kwnames[] = { "self", NULL };
13527
13528     self = self;
13529     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetBottomRow",_kwnames,&_argo0))
13530         return NULL;
13531     if (_argo0) {
13532         if (_argo0 == Py_None) { _arg0 = NULL; }
13533         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13534             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetBottomRow. Expected _wxGridRangeSelectEvent_p.");
13535         return NULL;
13536         }
13537     }
13538 {
13539     wxPy_BEGIN_ALLOW_THREADS;
13540         _result = (int )wxGridRangeSelectEvent_GetBottomRow(_arg0);
13541
13542     wxPy_END_ALLOW_THREADS;
13543     if (PyErr_Occurred()) return NULL;
13544 }    _resultobj = Py_BuildValue("i",_result);
13545     return _resultobj;
13546 }
13547
13548 #define wxGridRangeSelectEvent_GetLeftCol(_swigobj)  (_swigobj->GetLeftCol())
13549 static PyObject *_wrap_wxGridRangeSelectEvent_GetLeftCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13550     PyObject * _resultobj;
13551     int  _result;
13552     wxGridRangeSelectEvent * _arg0;
13553     PyObject * _argo0 = 0;
13554     char *_kwnames[] = { "self", NULL };
13555
13556     self = self;
13557     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetLeftCol",_kwnames,&_argo0))
13558         return NULL;
13559     if (_argo0) {
13560         if (_argo0 == Py_None) { _arg0 = NULL; }
13561         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13562             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetLeftCol. Expected _wxGridRangeSelectEvent_p.");
13563         return NULL;
13564         }
13565     }
13566 {
13567     wxPy_BEGIN_ALLOW_THREADS;
13568         _result = (int )wxGridRangeSelectEvent_GetLeftCol(_arg0);
13569
13570     wxPy_END_ALLOW_THREADS;
13571     if (PyErr_Occurred()) return NULL;
13572 }    _resultobj = Py_BuildValue("i",_result);
13573     return _resultobj;
13574 }
13575
13576 #define wxGridRangeSelectEvent_GetRightCol(_swigobj)  (_swigobj->GetRightCol())
13577 static PyObject *_wrap_wxGridRangeSelectEvent_GetRightCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13578     PyObject * _resultobj;
13579     int  _result;
13580     wxGridRangeSelectEvent * _arg0;
13581     PyObject * _argo0 = 0;
13582     char *_kwnames[] = { "self", NULL };
13583
13584     self = self;
13585     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetRightCol",_kwnames,&_argo0))
13586         return NULL;
13587     if (_argo0) {
13588         if (_argo0 == Py_None) { _arg0 = NULL; }
13589         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13590             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetRightCol. Expected _wxGridRangeSelectEvent_p.");
13591         return NULL;
13592         }
13593     }
13594 {
13595     wxPy_BEGIN_ALLOW_THREADS;
13596         _result = (int )wxGridRangeSelectEvent_GetRightCol(_arg0);
13597
13598     wxPy_END_ALLOW_THREADS;
13599     if (PyErr_Occurred()) return NULL;
13600 }    _resultobj = Py_BuildValue("i",_result);
13601     return _resultobj;
13602 }
13603
13604 #define wxGridRangeSelectEvent_Selecting(_swigobj)  (_swigobj->Selecting())
13605 static PyObject *_wrap_wxGridRangeSelectEvent_Selecting(PyObject *self, PyObject *args, PyObject *kwargs) {
13606     PyObject * _resultobj;
13607     bool  _result;
13608     wxGridRangeSelectEvent * _arg0;
13609     PyObject * _argo0 = 0;
13610     char *_kwnames[] = { "self", NULL };
13611
13612     self = self;
13613     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_Selecting",_kwnames,&_argo0))
13614         return NULL;
13615     if (_argo0) {
13616         if (_argo0 == Py_None) { _arg0 = NULL; }
13617         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13618             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_Selecting. Expected _wxGridRangeSelectEvent_p.");
13619         return NULL;
13620         }
13621     }
13622 {
13623     wxPy_BEGIN_ALLOW_THREADS;
13624         _result = (bool )wxGridRangeSelectEvent_Selecting(_arg0);
13625
13626     wxPy_END_ALLOW_THREADS;
13627     if (PyErr_Occurred()) return NULL;
13628 }    _resultobj = Py_BuildValue("i",_result);
13629     return _resultobj;
13630 }
13631
13632 #define wxGridRangeSelectEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
13633 static PyObject *_wrap_wxGridRangeSelectEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13634     PyObject * _resultobj;
13635     bool  _result;
13636     wxGridRangeSelectEvent * _arg0;
13637     PyObject * _argo0 = 0;
13638     char *_kwnames[] = { "self", NULL };
13639
13640     self = self;
13641     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_ControlDown",_kwnames,&_argo0))
13642         return NULL;
13643     if (_argo0) {
13644         if (_argo0 == Py_None) { _arg0 = NULL; }
13645         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13646             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_ControlDown. Expected _wxGridRangeSelectEvent_p.");
13647         return NULL;
13648         }
13649     }
13650 {
13651     wxPy_BEGIN_ALLOW_THREADS;
13652         _result = (bool )wxGridRangeSelectEvent_ControlDown(_arg0);
13653
13654     wxPy_END_ALLOW_THREADS;
13655     if (PyErr_Occurred()) return NULL;
13656 }    _resultobj = Py_BuildValue("i",_result);
13657     return _resultobj;
13658 }
13659
13660 #define wxGridRangeSelectEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
13661 static PyObject *_wrap_wxGridRangeSelectEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13662     PyObject * _resultobj;
13663     bool  _result;
13664     wxGridRangeSelectEvent * _arg0;
13665     PyObject * _argo0 = 0;
13666     char *_kwnames[] = { "self", NULL };
13667
13668     self = self;
13669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_MetaDown",_kwnames,&_argo0))
13670         return NULL;
13671     if (_argo0) {
13672         if (_argo0 == Py_None) { _arg0 = NULL; }
13673         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13674             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_MetaDown. Expected _wxGridRangeSelectEvent_p.");
13675         return NULL;
13676         }
13677     }
13678 {
13679     wxPy_BEGIN_ALLOW_THREADS;
13680         _result = (bool )wxGridRangeSelectEvent_MetaDown(_arg0);
13681
13682     wxPy_END_ALLOW_THREADS;
13683     if (PyErr_Occurred()) return NULL;
13684 }    _resultobj = Py_BuildValue("i",_result);
13685     return _resultobj;
13686 }
13687
13688 #define wxGridRangeSelectEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13689 static PyObject *_wrap_wxGridRangeSelectEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13690     PyObject * _resultobj;
13691     bool  _result;
13692     wxGridRangeSelectEvent * _arg0;
13693     PyObject * _argo0 = 0;
13694     char *_kwnames[] = { "self", NULL };
13695
13696     self = self;
13697     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_ShiftDown",_kwnames,&_argo0))
13698         return NULL;
13699     if (_argo0) {
13700         if (_argo0 == Py_None) { _arg0 = NULL; }
13701         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13702             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_ShiftDown. Expected _wxGridRangeSelectEvent_p.");
13703         return NULL;
13704         }
13705     }
13706 {
13707     wxPy_BEGIN_ALLOW_THREADS;
13708         _result = (bool )wxGridRangeSelectEvent_ShiftDown(_arg0);
13709
13710     wxPy_END_ALLOW_THREADS;
13711     if (PyErr_Occurred()) return NULL;
13712 }    _resultobj = Py_BuildValue("i",_result);
13713     return _resultobj;
13714 }
13715
13716 #define wxGridRangeSelectEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13717 static PyObject *_wrap_wxGridRangeSelectEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13718     PyObject * _resultobj;
13719     bool  _result;
13720     wxGridRangeSelectEvent * _arg0;
13721     PyObject * _argo0 = 0;
13722     char *_kwnames[] = { "self", NULL };
13723
13724     self = self;
13725     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_AltDown",_kwnames,&_argo0))
13726         return NULL;
13727     if (_argo0) {
13728         if (_argo0 == Py_None) { _arg0 = NULL; }
13729         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13730             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_AltDown. Expected _wxGridRangeSelectEvent_p.");
13731         return NULL;
13732         }
13733     }
13734 {
13735     wxPy_BEGIN_ALLOW_THREADS;
13736         _result = (bool )wxGridRangeSelectEvent_AltDown(_arg0);
13737
13738     wxPy_END_ALLOW_THREADS;
13739     if (PyErr_Occurred()) return NULL;
13740 }    _resultobj = Py_BuildValue("i",_result);
13741     return _resultobj;
13742 }
13743
13744 static void *SwigwxGridEditorCreatedEventTowxCommandEvent(void *ptr) {
13745     wxGridEditorCreatedEvent *src;
13746     wxCommandEvent *dest;
13747     src = (wxGridEditorCreatedEvent *) ptr;
13748     dest = (wxCommandEvent *) src;
13749     return (void *) dest;
13750 }
13751
13752 static void *SwigwxGridEditorCreatedEventTowxEvent(void *ptr) {
13753     wxGridEditorCreatedEvent *src;
13754     wxEvent *dest;
13755     src = (wxGridEditorCreatedEvent *) ptr;
13756     dest = (wxEvent *) src;
13757     return (void *) dest;
13758 }
13759
13760 static void *SwigwxGridEditorCreatedEventTowxObject(void *ptr) {
13761     wxGridEditorCreatedEvent *src;
13762     wxObject *dest;
13763     src = (wxGridEditorCreatedEvent *) ptr;
13764     dest = (wxObject *) src;
13765     return (void *) dest;
13766 }
13767
13768 #define new_wxGridEditorCreatedEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (new wxGridEditorCreatedEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
13769 static PyObject *_wrap_new_wxGridEditorCreatedEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13770     PyObject * _resultobj;
13771     wxGridEditorCreatedEvent * _result;
13772     int  _arg0;
13773     wxEventType  _arg1;
13774     wxObject * _arg2;
13775     int  _arg3;
13776     int  _arg4;
13777     wxControl * _arg5;
13778     PyObject * _argo2 = 0;
13779     PyObject * _argo5 = 0;
13780     char *_kwnames[] = { "id","type","obj","row","col","ctrl", NULL };
13781     char _ptemp[128];
13782
13783     self = self;
13784     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiOiiO:new_wxGridEditorCreatedEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_argo5))
13785         return NULL;
13786     if (_argo2) {
13787         if (_argo2 == Py_None) { _arg2 = NULL; }
13788         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxObject_p")) {
13789             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridEditorCreatedEvent. Expected _wxObject_p.");
13790         return NULL;
13791         }
13792     }
13793     if (_argo5) {
13794         if (_argo5 == Py_None) { _arg5 = NULL; }
13795         else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxControl_p")) {
13796             PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of new_wxGridEditorCreatedEvent. Expected _wxControl_p.");
13797         return NULL;
13798         }
13799     }
13800 {
13801     wxPy_BEGIN_ALLOW_THREADS;
13802         _result = (wxGridEditorCreatedEvent *)new_wxGridEditorCreatedEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
13803
13804     wxPy_END_ALLOW_THREADS;
13805     if (PyErr_Occurred()) return NULL;
13806 }    if (_result) {
13807         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEditorCreatedEvent_p");
13808         _resultobj = Py_BuildValue("s",_ptemp);
13809     } else {
13810         Py_INCREF(Py_None);
13811         _resultobj = Py_None;
13812     }
13813     return _resultobj;
13814 }
13815
13816 #define wxGridEditorCreatedEvent_GetRow(_swigobj)  (_swigobj->GetRow())
13817 static PyObject *_wrap_wxGridEditorCreatedEvent_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13818     PyObject * _resultobj;
13819     int  _result;
13820     wxGridEditorCreatedEvent * _arg0;
13821     PyObject * _argo0 = 0;
13822     char *_kwnames[] = { "self", NULL };
13823
13824     self = self;
13825     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetRow",_kwnames,&_argo0))
13826         return NULL;
13827     if (_argo0) {
13828         if (_argo0 == Py_None) { _arg0 = NULL; }
13829         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13830             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetRow. Expected _wxGridEditorCreatedEvent_p.");
13831         return NULL;
13832         }
13833     }
13834 {
13835     wxPy_BEGIN_ALLOW_THREADS;
13836         _result = (int )wxGridEditorCreatedEvent_GetRow(_arg0);
13837
13838     wxPy_END_ALLOW_THREADS;
13839     if (PyErr_Occurred()) return NULL;
13840 }    _resultobj = Py_BuildValue("i",_result);
13841     return _resultobj;
13842 }
13843
13844 #define wxGridEditorCreatedEvent_GetCol(_swigobj)  (_swigobj->GetCol())
13845 static PyObject *_wrap_wxGridEditorCreatedEvent_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13846     PyObject * _resultobj;
13847     int  _result;
13848     wxGridEditorCreatedEvent * _arg0;
13849     PyObject * _argo0 = 0;
13850     char *_kwnames[] = { "self", NULL };
13851
13852     self = self;
13853     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetCol",_kwnames,&_argo0))
13854         return NULL;
13855     if (_argo0) {
13856         if (_argo0 == Py_None) { _arg0 = NULL; }
13857         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13858             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetCol. Expected _wxGridEditorCreatedEvent_p.");
13859         return NULL;
13860         }
13861     }
13862 {
13863     wxPy_BEGIN_ALLOW_THREADS;
13864         _result = (int )wxGridEditorCreatedEvent_GetCol(_arg0);
13865
13866     wxPy_END_ALLOW_THREADS;
13867     if (PyErr_Occurred()) return NULL;
13868 }    _resultobj = Py_BuildValue("i",_result);
13869     return _resultobj;
13870 }
13871
13872 #define wxGridEditorCreatedEvent_GetControl(_swigobj)  (_swigobj->GetControl())
13873 static PyObject *_wrap_wxGridEditorCreatedEvent_GetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
13874     PyObject * _resultobj;
13875     wxControl * _result;
13876     wxGridEditorCreatedEvent * _arg0;
13877     PyObject * _argo0 = 0;
13878     char *_kwnames[] = { "self", NULL };
13879
13880     self = self;
13881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetControl",_kwnames,&_argo0))
13882         return NULL;
13883     if (_argo0) {
13884         if (_argo0 == Py_None) { _arg0 = NULL; }
13885         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13886             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetControl. Expected _wxGridEditorCreatedEvent_p.");
13887         return NULL;
13888         }
13889     }
13890 {
13891     wxPy_BEGIN_ALLOW_THREADS;
13892         _result = (wxControl *)wxGridEditorCreatedEvent_GetControl(_arg0);
13893
13894     wxPy_END_ALLOW_THREADS;
13895     if (PyErr_Occurred()) return NULL;
13896 }{ _resultobj = wxPyMake_wxObject(_result); }
13897     return _resultobj;
13898 }
13899
13900 #define wxGridEditorCreatedEvent_SetRow(_swigobj,_swigarg0)  (_swigobj->SetRow(_swigarg0))
13901 static PyObject *_wrap_wxGridEditorCreatedEvent_SetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13902     PyObject * _resultobj;
13903     wxGridEditorCreatedEvent * _arg0;
13904     int  _arg1;
13905     PyObject * _argo0 = 0;
13906     char *_kwnames[] = { "self","row", NULL };
13907
13908     self = self;
13909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridEditorCreatedEvent_SetRow",_kwnames,&_argo0,&_arg1))
13910         return NULL;
13911     if (_argo0) {
13912         if (_argo0 == Py_None) { _arg0 = NULL; }
13913         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13914             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetRow. Expected _wxGridEditorCreatedEvent_p.");
13915         return NULL;
13916         }
13917     }
13918 {
13919     wxPy_BEGIN_ALLOW_THREADS;
13920         wxGridEditorCreatedEvent_SetRow(_arg0,_arg1);
13921
13922     wxPy_END_ALLOW_THREADS;
13923     if (PyErr_Occurred()) return NULL;
13924 }    Py_INCREF(Py_None);
13925     _resultobj = Py_None;
13926     return _resultobj;
13927 }
13928
13929 #define wxGridEditorCreatedEvent_SetCol(_swigobj,_swigarg0)  (_swigobj->SetCol(_swigarg0))
13930 static PyObject *_wrap_wxGridEditorCreatedEvent_SetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13931     PyObject * _resultobj;
13932     wxGridEditorCreatedEvent * _arg0;
13933     int  _arg1;
13934     PyObject * _argo0 = 0;
13935     char *_kwnames[] = { "self","col", NULL };
13936
13937     self = self;
13938     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridEditorCreatedEvent_SetCol",_kwnames,&_argo0,&_arg1))
13939         return NULL;
13940     if (_argo0) {
13941         if (_argo0 == Py_None) { _arg0 = NULL; }
13942         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13943             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetCol. Expected _wxGridEditorCreatedEvent_p.");
13944         return NULL;
13945         }
13946     }
13947 {
13948     wxPy_BEGIN_ALLOW_THREADS;
13949         wxGridEditorCreatedEvent_SetCol(_arg0,_arg1);
13950
13951     wxPy_END_ALLOW_THREADS;
13952     if (PyErr_Occurred()) return NULL;
13953 }    Py_INCREF(Py_None);
13954     _resultobj = Py_None;
13955     return _resultobj;
13956 }
13957
13958 #define wxGridEditorCreatedEvent_SetControl(_swigobj,_swigarg0)  (_swigobj->SetControl(_swigarg0))
13959 static PyObject *_wrap_wxGridEditorCreatedEvent_SetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
13960     PyObject * _resultobj;
13961     wxGridEditorCreatedEvent * _arg0;
13962     wxControl * _arg1;
13963     PyObject * _argo0 = 0;
13964     PyObject * _argo1 = 0;
13965     char *_kwnames[] = { "self","ctrl", NULL };
13966
13967     self = self;
13968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridEditorCreatedEvent_SetControl",_kwnames,&_argo0,&_argo1))
13969         return NULL;
13970     if (_argo0) {
13971         if (_argo0 == Py_None) { _arg0 = NULL; }
13972         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13973             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetControl. Expected _wxGridEditorCreatedEvent_p.");
13974         return NULL;
13975         }
13976     }
13977     if (_argo1) {
13978         if (_argo1 == Py_None) { _arg1 = NULL; }
13979         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxControl_p")) {
13980             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridEditorCreatedEvent_SetControl. Expected _wxControl_p.");
13981         return NULL;
13982         }
13983     }
13984 {
13985     wxPy_BEGIN_ALLOW_THREADS;
13986         wxGridEditorCreatedEvent_SetControl(_arg0,_arg1);
13987
13988     wxPy_END_ALLOW_THREADS;
13989     if (PyErr_Occurred()) return NULL;
13990 }    Py_INCREF(Py_None);
13991     _resultobj = Py_None;
13992     return _resultobj;
13993 }
13994
13995 static PyMethodDef gridcMethods[] = {
13996          { "wxGridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS },
13997          { "wxGridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS },
13998          { "wxGridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS },
13999          { "wxGridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS },
14000          { "wxGridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS },
14001          { "wxGridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS },
14002          { "new_wxGridEditorCreatedEvent", (PyCFunction) _wrap_new_wxGridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS },
14003          { "wxGridRangeSelectEvent_AltDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
14004          { "wxGridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
14005          { "wxGridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
14006          { "wxGridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
14007          { "wxGridRangeSelectEvent_Selecting", (PyCFunction) _wrap_wxGridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS },
14008          { "wxGridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS },
14009          { "wxGridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS },
14010          { "wxGridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS },
14011          { "wxGridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS },
14012          { "wxGridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS },
14013          { "wxGridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS },
14014          { "new_wxGridRangeSelectEvent", (PyCFunction) _wrap_new_wxGridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS },
14015          { "wxGridSizeEvent_AltDown", (PyCFunction) _wrap_wxGridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
14016          { "wxGridSizeEvent_ShiftDown", (PyCFunction) _wrap_wxGridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
14017          { "wxGridSizeEvent_MetaDown", (PyCFunction) _wrap_wxGridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
14018          { "wxGridSizeEvent_ControlDown", (PyCFunction) _wrap_wxGridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
14019          { "wxGridSizeEvent_GetPosition", (PyCFunction) _wrap_wxGridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS },
14020          { "wxGridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_wxGridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS },
14021          { "new_wxGridSizeEvent", (PyCFunction) _wrap_new_wxGridSizeEvent, METH_VARARGS | METH_KEYWORDS },
14022          { "wxGridEvent_AltDown", (PyCFunction) _wrap_wxGridEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
14023          { "wxGridEvent_ShiftDown", (PyCFunction) _wrap_wxGridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
14024          { "wxGridEvent_MetaDown", (PyCFunction) _wrap_wxGridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
14025          { "wxGridEvent_ControlDown", (PyCFunction) _wrap_wxGridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
14026          { "wxGridEvent_Selecting", (PyCFunction) _wrap_wxGridEvent_Selecting, METH_VARARGS | METH_KEYWORDS },
14027          { "wxGridEvent_GetPosition", (PyCFunction) _wrap_wxGridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS },
14028          { "wxGridEvent_GetCol", (PyCFunction) _wrap_wxGridEvent_GetCol, METH_VARARGS | METH_KEYWORDS },
14029          { "wxGridEvent_GetRow", (PyCFunction) _wrap_wxGridEvent_GetRow, METH_VARARGS | METH_KEYWORDS },
14030          { "new_wxGridEvent", (PyCFunction) _wrap_new_wxGridEvent, METH_VARARGS | METH_KEYWORDS },
14031          { "wxGrid_GetGridCornerLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS },
14032          { "wxGrid_GetGridColLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS },
14033          { "wxGrid_GetGridRowLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS },
14034          { "wxGrid_GetGridWindow", (PyCFunction) _wrap_wxGrid_GetGridWindow, METH_VARARGS | METH_KEYWORDS },
14035          { "wxGrid_SetMargins", (PyCFunction) _wrap_wxGrid_SetMargins, METH_VARARGS | METH_KEYWORDS },
14036          { "wxGrid_GetDefaultRendererForType", (PyCFunction) _wrap_wxGrid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS },
14037          { "wxGrid_GetDefaultEditorForType", (PyCFunction) _wrap_wxGrid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS },
14038          { "wxGrid_GetDefaultRendererForCell", (PyCFunction) _wrap_wxGrid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS },
14039          { "wxGrid_GetDefaultEditorForCell", (PyCFunction) _wrap_wxGrid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS },
14040          { "wxGrid_RegisterDataType", (PyCFunction) _wrap_wxGrid_RegisterDataType, METH_VARARGS | METH_KEYWORDS },
14041          { "wxGrid_SetSelectionForeground", (PyCFunction) _wrap_wxGrid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS },
14042          { "wxGrid_SetSelectionBackground", (PyCFunction) _wrap_wxGrid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS },
14043          { "wxGrid_GetSelectionForeground", (PyCFunction) _wrap_wxGrid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS },
14044          { "wxGrid_GetSelectionBackground", (PyCFunction) _wrap_wxGrid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS },
14045          { "wxGrid_BlockToDeviceRect", (PyCFunction) _wrap_wxGrid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS },
14046          { "wxGrid_IsInSelection", (PyCFunction) _wrap_wxGrid_IsInSelection, METH_VARARGS | METH_KEYWORDS },
14047          { "wxGrid_ClearSelection", (PyCFunction) _wrap_wxGrid_ClearSelection, METH_VARARGS | METH_KEYWORDS },
14048          { "wxGrid_IsSelection", (PyCFunction) _wrap_wxGrid_IsSelection, METH_VARARGS | METH_KEYWORDS },
14049          { "wxGrid_SelectAll", (PyCFunction) _wrap_wxGrid_SelectAll, METH_VARARGS | METH_KEYWORDS },
14050          { "wxGrid_SelectBlock", (PyCFunction) _wrap_wxGrid_SelectBlock, METH_VARARGS | METH_KEYWORDS },
14051          { "wxGrid_SelectCol", (PyCFunction) _wrap_wxGrid_SelectCol, METH_VARARGS | METH_KEYWORDS },
14052          { "wxGrid_SelectRow", (PyCFunction) _wrap_wxGrid_SelectRow, METH_VARARGS | METH_KEYWORDS },
14053          { "wxGrid_SetReadOnly", (PyCFunction) _wrap_wxGrid_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
14054          { "wxGrid_IsReadOnly", (PyCFunction) _wrap_wxGrid_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
14055          { "wxGrid_SetCellValue", (PyCFunction) _wrap_wxGrid_SetCellValue, METH_VARARGS | METH_KEYWORDS },
14056          { "wxGrid_GetCellValue", (PyCFunction) _wrap_wxGrid_GetCellValue, METH_VARARGS | METH_KEYWORDS },
14057          { "wxGrid_GetCellEditor", (PyCFunction) _wrap_wxGrid_GetCellEditor, METH_VARARGS | METH_KEYWORDS },
14058          { "wxGrid_GetDefaultEditor", (PyCFunction) _wrap_wxGrid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS },
14059          { "wxGrid_SetCellEditor", (PyCFunction) _wrap_wxGrid_SetCellEditor, METH_VARARGS | METH_KEYWORDS },
14060          { "wxGrid_SetDefaultEditor", (PyCFunction) _wrap_wxGrid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS },
14061          { "wxGrid_GetCellRenderer", (PyCFunction) _wrap_wxGrid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS },
14062          { "wxGrid_GetDefaultRenderer", (PyCFunction) _wrap_wxGrid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
14063          { "wxGrid_SetCellRenderer", (PyCFunction) _wrap_wxGrid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS },
14064          { "wxGrid_SetDefaultRenderer", (PyCFunction) _wrap_wxGrid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
14065          { "wxGrid_SetCellAlignment", (PyCFunction) _wrap_wxGrid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS },
14066          { "wxGrid_SetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
14067          { "wxGrid_SetCellFont", (PyCFunction) _wrap_wxGrid_SetCellFont, METH_VARARGS | METH_KEYWORDS },
14068          { "wxGrid_SetDefaultCellFont", (PyCFunction) _wrap_wxGrid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS },
14069          { "wxGrid_SetCellTextColour", (PyCFunction) _wrap_wxGrid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS },
14070          { "wxGrid_SetDefaultCellTextColour", (PyCFunction) _wrap_wxGrid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS },
14071          { "wxGrid_SetCellBackgroundColour", (PyCFunction) _wrap_wxGrid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14072          { "wxGrid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_wxGrid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14073          { "wxGrid_SetRowMinimalHeight", (PyCFunction) _wrap_wxGrid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS },
14074          { "wxGrid_SetColMinimalWidth", (PyCFunction) _wrap_wxGrid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS },
14075          { "wxGrid_AutoSize", (PyCFunction) _wrap_wxGrid_AutoSize, METH_VARARGS | METH_KEYWORDS },
14076          { "wxGrid_AutoSizeRows", (PyCFunction) _wrap_wxGrid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS },
14077          { "wxGrid_AutoSizeColumns", (PyCFunction) _wrap_wxGrid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS },
14078          { "wxGrid_AutoSizeRow", (PyCFunction) _wrap_wxGrid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS },
14079          { "wxGrid_AutoSizeColumn", (PyCFunction) _wrap_wxGrid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS },
14080          { "wxGrid_SetColSize", (PyCFunction) _wrap_wxGrid_SetColSize, METH_VARARGS | METH_KEYWORDS },
14081          { "wxGrid_SetDefaultColSize", (PyCFunction) _wrap_wxGrid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
14082          { "wxGrid_SetRowSize", (PyCFunction) _wrap_wxGrid_SetRowSize, METH_VARARGS | METH_KEYWORDS },
14083          { "wxGrid_SetDefaultRowSize", (PyCFunction) _wrap_wxGrid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
14084          { "wxGrid_GetCellAlignment", (PyCFunction) _wrap_wxGrid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS },
14085          { "wxGrid_GetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
14086          { "wxGrid_GetCellFont", (PyCFunction) _wrap_wxGrid_GetCellFont, METH_VARARGS | METH_KEYWORDS },
14087          { "wxGrid_GetDefaultCellFont", (PyCFunction) _wrap_wxGrid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS },
14088          { "wxGrid_GetCellTextColour", (PyCFunction) _wrap_wxGrid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS },
14089          { "wxGrid_GetDefaultCellTextColour", (PyCFunction) _wrap_wxGrid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS },
14090          { "wxGrid_GetCellBackgroundColour", (PyCFunction) _wrap_wxGrid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14091          { "wxGrid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_wxGrid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14092          { "wxGrid_GetColSize", (PyCFunction) _wrap_wxGrid_GetColSize, METH_VARARGS | METH_KEYWORDS },
14093          { "wxGrid_GetDefaultColSize", (PyCFunction) _wrap_wxGrid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
14094          { "wxGrid_GetRowSize", (PyCFunction) _wrap_wxGrid_GetRowSize, METH_VARARGS | METH_KEYWORDS },
14095          { "wxGrid_GetDefaultRowSize", (PyCFunction) _wrap_wxGrid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
14096          { "wxGrid_GridLinesEnabled", (PyCFunction) _wrap_wxGrid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS },
14097          { "wxGrid_EnableGridLines", (PyCFunction) _wrap_wxGrid_EnableGridLines, METH_VARARGS | METH_KEYWORDS },
14098          { "wxGrid_SetColFormatCustom", (PyCFunction) _wrap_wxGrid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS },
14099          { "wxGrid_SetColFormatFloat", (PyCFunction) _wrap_wxGrid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS },
14100          { "wxGrid_SetColFormatNumber", (PyCFunction) _wrap_wxGrid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS },
14101          { "wxGrid_SetColFormatBool", (PyCFunction) _wrap_wxGrid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS },
14102          { "wxGrid_SetColAttr", (PyCFunction) _wrap_wxGrid_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14103          { "wxGrid_SetRowAttr", (PyCFunction) _wrap_wxGrid_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14104          { "wxGrid_CanDragGridSize", (PyCFunction) _wrap_wxGrid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS },
14105          { "wxGrid_DisableDragGridSize", (PyCFunction) _wrap_wxGrid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS },
14106          { "wxGrid_EnableDragGridSize", (PyCFunction) _wrap_wxGrid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS },
14107          { "wxGrid_CanDragColSize", (PyCFunction) _wrap_wxGrid_CanDragColSize, METH_VARARGS | METH_KEYWORDS },
14108          { "wxGrid_DisableDragColSize", (PyCFunction) _wrap_wxGrid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS },
14109          { "wxGrid_EnableDragColSize", (PyCFunction) _wrap_wxGrid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS },
14110          { "wxGrid_CanDragRowSize", (PyCFunction) _wrap_wxGrid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS },
14111          { "wxGrid_DisableDragRowSize", (PyCFunction) _wrap_wxGrid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS },
14112          { "wxGrid_EnableDragRowSize", (PyCFunction) _wrap_wxGrid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS },
14113          { "wxGrid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_wxGrid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS },
14114          { "wxGrid_SetCellHighlightPenWidth", (PyCFunction) _wrap_wxGrid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS },
14115          { "wxGrid_SetCellHighlightColour", (PyCFunction) _wrap_wxGrid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS },
14116          { "wxGrid_SetGridLineColour", (PyCFunction) _wrap_wxGrid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS },
14117          { "wxGrid_SetColLabelValue", (PyCFunction) _wrap_wxGrid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14118          { "wxGrid_SetRowLabelValue", (PyCFunction) _wrap_wxGrid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14119          { "wxGrid_SetColLabelAlignment", (PyCFunction) _wrap_wxGrid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14120          { "wxGrid_SetRowLabelAlignment", (PyCFunction) _wrap_wxGrid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14121          { "wxGrid_SetLabelFont", (PyCFunction) _wrap_wxGrid_SetLabelFont, METH_VARARGS | METH_KEYWORDS },
14122          { "wxGrid_SetLabelTextColour", (PyCFunction) _wrap_wxGrid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS },
14123          { "wxGrid_SetLabelBackgroundColour", (PyCFunction) _wrap_wxGrid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14124          { "wxGrid_SetColLabelSize", (PyCFunction) _wrap_wxGrid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS },
14125          { "wxGrid_SetRowLabelSize", (PyCFunction) _wrap_wxGrid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14126          { "wxGrid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_wxGrid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS },
14127          { "wxGrid_GetCellHighlightPenWidth", (PyCFunction) _wrap_wxGrid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS },
14128          { "wxGrid_GetCellHighlightColour", (PyCFunction) _wrap_wxGrid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS },
14129          { "wxGrid_GetGridLineColour", (PyCFunction) _wrap_wxGrid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS },
14130          { "wxGrid_GetColLabelValue", (PyCFunction) _wrap_wxGrid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14131          { "wxGrid_GetRowLabelValue", (PyCFunction) _wrap_wxGrid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14132          { "wxGrid_GetColLabelAlignment", (PyCFunction) _wrap_wxGrid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14133          { "wxGrid_GetRowLabelAlignment", (PyCFunction) _wrap_wxGrid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14134          { "wxGrid_GetLabelFont", (PyCFunction) _wrap_wxGrid_GetLabelFont, METH_VARARGS | METH_KEYWORDS },
14135          { "wxGrid_GetLabelTextColour", (PyCFunction) _wrap_wxGrid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS },
14136          { "wxGrid_GetLabelBackgroundColour", (PyCFunction) _wrap_wxGrid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14137          { "wxGrid_GetColLabelSize", (PyCFunction) _wrap_wxGrid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS },
14138          { "wxGrid_GetDefaultColLabelSize", (PyCFunction) _wrap_wxGrid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS },
14139          { "wxGrid_GetRowLabelSize", (PyCFunction) _wrap_wxGrid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14140          { "wxGrid_GetDefaultRowLabelSize", (PyCFunction) _wrap_wxGrid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14141          { "wxGrid_MoveCursorRightBlock", (PyCFunction) _wrap_wxGrid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS },
14142          { "wxGrid_MoveCursorLeftBlock", (PyCFunction) _wrap_wxGrid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS },
14143          { "wxGrid_MoveCursorDownBlock", (PyCFunction) _wrap_wxGrid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS },
14144          { "wxGrid_MoveCursorUpBlock", (PyCFunction) _wrap_wxGrid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS },
14145          { "wxGrid_MovePageUp", (PyCFunction) _wrap_wxGrid_MovePageUp, METH_VARARGS | METH_KEYWORDS },
14146          { "wxGrid_MovePageDown", (PyCFunction) _wrap_wxGrid_MovePageDown, METH_VARARGS | METH_KEYWORDS },
14147          { "wxGrid_MoveCursorRight", (PyCFunction) _wrap_wxGrid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS },
14148          { "wxGrid_MoveCursorLeft", (PyCFunction) _wrap_wxGrid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS },
14149          { "wxGrid_MoveCursorDown", (PyCFunction) _wrap_wxGrid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS },
14150          { "wxGrid_MoveCursorUp", (PyCFunction) _wrap_wxGrid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS },
14151          { "wxGrid_SetGridCursor", (PyCFunction) _wrap_wxGrid_SetGridCursor, METH_VARARGS | METH_KEYWORDS },
14152          { "wxGrid_MakeCellVisible", (PyCFunction) _wrap_wxGrid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS },
14153          { "wxGrid_IsVisible", (PyCFunction) _wrap_wxGrid_IsVisible, METH_VARARGS | METH_KEYWORDS },
14154          { "wxGrid_GetGridCursorCol", (PyCFunction) _wrap_wxGrid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS },
14155          { "wxGrid_GetGridCursorRow", (PyCFunction) _wrap_wxGrid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS },
14156          { "wxGrid_CellToRect", (PyCFunction) _wrap_wxGrid_CellToRect, METH_VARARGS | METH_KEYWORDS },
14157          { "wxGrid_XToEdgeOfCol", (PyCFunction) _wrap_wxGrid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS },
14158          { "wxGrid_YToEdgeOfRow", (PyCFunction) _wrap_wxGrid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS },
14159          { "wxGrid_XToCol", (PyCFunction) _wrap_wxGrid_XToCol, METH_VARARGS | METH_KEYWORDS },
14160          { "wxGrid_YToRow", (PyCFunction) _wrap_wxGrid_YToRow, METH_VARARGS | METH_KEYWORDS },
14161          { "wxGrid_XYToCell", (PyCFunction) _wrap_wxGrid_XYToCell, METH_VARARGS | METH_KEYWORDS },
14162          { "wxGrid_SaveEditControlValue", (PyCFunction) _wrap_wxGrid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS },
14163          { "wxGrid_HideCellEditControl", (PyCFunction) _wrap_wxGrid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS },
14164          { "wxGrid_ShowCellEditControl", (PyCFunction) _wrap_wxGrid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS },
14165          { "wxGrid_IsCurrentCellReadOnly", (PyCFunction) _wrap_wxGrid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS },
14166          { "wxGrid_IsCellEditControlShown", (PyCFunction) _wrap_wxGrid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS },
14167          { "wxGrid_IsCellEditControlEnabled", (PyCFunction) _wrap_wxGrid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS },
14168          { "wxGrid_CanEnableCellControl", (PyCFunction) _wrap_wxGrid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS },
14169          { "wxGrid_DisableCellEditControl", (PyCFunction) _wrap_wxGrid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS },
14170          { "wxGrid_EnableCellEditControl", (PyCFunction) _wrap_wxGrid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS },
14171          { "wxGrid_EnableEditing", (PyCFunction) _wrap_wxGrid_EnableEditing, METH_VARARGS | METH_KEYWORDS },
14172          { "wxGrid_IsEditable", (PyCFunction) _wrap_wxGrid_IsEditable, METH_VARARGS | METH_KEYWORDS },
14173          { "wxGrid_ForceRefresh", (PyCFunction) _wrap_wxGrid_ForceRefresh, METH_VARARGS | METH_KEYWORDS },
14174          { "wxGrid_GetBatchCount", (PyCFunction) _wrap_wxGrid_GetBatchCount, METH_VARARGS | METH_KEYWORDS },
14175          { "wxGrid_EndBatch", (PyCFunction) _wrap_wxGrid_EndBatch, METH_VARARGS | METH_KEYWORDS },
14176          { "wxGrid_BeginBatch", (PyCFunction) _wrap_wxGrid_BeginBatch, METH_VARARGS | METH_KEYWORDS },
14177          { "wxGrid_GetTextBoxSize", (PyCFunction) _wrap_wxGrid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS },
14178          { "wxGrid_StringToLines", (PyCFunction) _wrap_wxGrid_StringToLines, METH_VARARGS | METH_KEYWORDS },
14179          { "wxGrid_DrawTextRectangle", (PyCFunction) _wrap_wxGrid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS },
14180          { "wxGrid_DrawCellHighlight", (PyCFunction) _wrap_wxGrid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS },
14181          { "wxGrid_DeleteCols", (PyCFunction) _wrap_wxGrid_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14182          { "wxGrid_AppendCols", (PyCFunction) _wrap_wxGrid_AppendCols, METH_VARARGS | METH_KEYWORDS },
14183          { "wxGrid_InsertCols", (PyCFunction) _wrap_wxGrid_InsertCols, METH_VARARGS | METH_KEYWORDS },
14184          { "wxGrid_DeleteRows", (PyCFunction) _wrap_wxGrid_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14185          { "wxGrid_AppendRows", (PyCFunction) _wrap_wxGrid_AppendRows, METH_VARARGS | METH_KEYWORDS },
14186          { "wxGrid_InsertRows", (PyCFunction) _wrap_wxGrid_InsertRows, METH_VARARGS | METH_KEYWORDS },
14187          { "wxGrid_ClearGrid", (PyCFunction) _wrap_wxGrid_ClearGrid, METH_VARARGS | METH_KEYWORDS },
14188          { "wxGrid_SetTable", (PyCFunction) _wrap_wxGrid_SetTable, METH_VARARGS | METH_KEYWORDS },
14189          { "wxGrid_GetTable", (PyCFunction) _wrap_wxGrid_GetTable, METH_VARARGS | METH_KEYWORDS },
14190          { "wxGrid_ProcessTableMessage", (PyCFunction) _wrap_wxGrid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS },
14191          { "wxGrid_GetNumberCols", (PyCFunction) _wrap_wxGrid_GetNumberCols, METH_VARARGS | METH_KEYWORDS },
14192          { "wxGrid_GetNumberRows", (PyCFunction) _wrap_wxGrid_GetNumberRows, METH_VARARGS | METH_KEYWORDS },
14193          { "wxGrid_SetSelectionMode", (PyCFunction) _wrap_wxGrid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS },
14194          { "wxGrid_CreateGrid", (PyCFunction) _wrap_wxGrid_CreateGrid, METH_VARARGS | METH_KEYWORDS },
14195          { "new_wxGrid", (PyCFunction) _wrap_new_wxGrid, METH_VARARGS | METH_KEYWORDS },
14196          { "wxGridCellCoords___cmp__", (PyCFunction) _wrap_wxGridCellCoords___cmp__, METH_VARARGS | METH_KEYWORDS },
14197          { "wxGridCellCoords_asTuple", (PyCFunction) _wrap_wxGridCellCoords_asTuple, METH_VARARGS | METH_KEYWORDS },
14198          { "wxGridCellCoords_Set", (PyCFunction) _wrap_wxGridCellCoords_Set, METH_VARARGS | METH_KEYWORDS },
14199          { "wxGridCellCoords_SetCol", (PyCFunction) _wrap_wxGridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS },
14200          { "wxGridCellCoords_GetCol", (PyCFunction) _wrap_wxGridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS },
14201          { "wxGridCellCoords_SetRow", (PyCFunction) _wrap_wxGridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS },
14202          { "wxGridCellCoords_GetRow", (PyCFunction) _wrap_wxGridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS },
14203          { "delete_wxGridCellCoords", (PyCFunction) _wrap_delete_wxGridCellCoords, METH_VARARGS | METH_KEYWORDS },
14204          { "new_wxGridCellCoords", (PyCFunction) _wrap_new_wxGridCellCoords, METH_VARARGS | METH_KEYWORDS },
14205          { "wxGridTableMessage_GetCommandInt2", (PyCFunction) _wrap_wxGridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS },
14206          { "wxGridTableMessage_SetCommandInt2", (PyCFunction) _wrap_wxGridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS },
14207          { "wxGridTableMessage_GetCommandInt", (PyCFunction) _wrap_wxGridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS },
14208          { "wxGridTableMessage_SetCommandInt", (PyCFunction) _wrap_wxGridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS },
14209          { "wxGridTableMessage_GetId", (PyCFunction) _wrap_wxGridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS },
14210          { "wxGridTableMessage_SetId", (PyCFunction) _wrap_wxGridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS },
14211          { "wxGridTableMessage_GetTableObject", (PyCFunction) _wrap_wxGridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS },
14212          { "wxGridTableMessage_SetTableObject", (PyCFunction) _wrap_wxGridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS },
14213          { "delete_wxGridTableMessage", (PyCFunction) _wrap_delete_wxGridTableMessage, METH_VARARGS | METH_KEYWORDS },
14214          { "new_wxGridTableMessage", (PyCFunction) _wrap_new_wxGridTableMessage, METH_VARARGS | METH_KEYWORDS },
14215          { "new_wxGridStringTable", (PyCFunction) _wrap_new_wxGridStringTable, METH_VARARGS | METH_KEYWORDS },
14216          { "wxPyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14217          { "wxPyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14218          { "wxPyGridTableBase_base_SetAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
14219          { "wxPyGridTableBase_base_GetAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
14220          { "wxPyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_wxPyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS },
14221          { "wxPyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14222          { "wxPyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14223          { "wxPyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14224          { "wxPyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14225          { "wxPyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_wxPyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14226          { "wxPyGridTableBase_base_AppendCols", (PyCFunction) _wrap_wxPyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS },
14227          { "wxPyGridTableBase_base_InsertCols", (PyCFunction) _wrap_wxPyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS },
14228          { "wxPyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_wxPyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14229          { "wxPyGridTableBase_base_AppendRows", (PyCFunction) _wrap_wxPyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS },
14230          { "wxPyGridTableBase_base_InsertRows", (PyCFunction) _wrap_wxPyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS },
14231          { "wxPyGridTableBase_base_Clear", (PyCFunction) _wrap_wxPyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS },
14232          { "wxPyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS },
14233          { "wxPyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
14234          { "wxPyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_wxPyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS },
14235          { "wxPyGridTableBase_Destroy", (PyCFunction) _wrap_wxPyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS },
14236          { "wxPyGridTableBase__setSelf", (PyCFunction) _wrap_wxPyGridTableBase__setSelf, METH_VARARGS | METH_KEYWORDS },
14237          { "new_wxPyGridTableBase", (PyCFunction) _wrap_new_wxPyGridTableBase, METH_VARARGS | METH_KEYWORDS },
14238          { "wxGridTableBase_SetColAttr", (PyCFunction) _wrap_wxGridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14239          { "wxGridTableBase_SetRowAttr", (PyCFunction) _wrap_wxGridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14240          { "wxGridTableBase_SetAttr", (PyCFunction) _wrap_wxGridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS },
14241          { "wxGridTableBase_GetAttr", (PyCFunction) _wrap_wxGridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS },
14242          { "wxGridTableBase_CanHaveAttributes", (PyCFunction) _wrap_wxGridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS },
14243          { "wxGridTableBase_SetColLabelValue", (PyCFunction) _wrap_wxGridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14244          { "wxGridTableBase_SetRowLabelValue", (PyCFunction) _wrap_wxGridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14245          { "wxGridTableBase_GetColLabelValue", (PyCFunction) _wrap_wxGridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14246          { "wxGridTableBase_GetRowLabelValue", (PyCFunction) _wrap_wxGridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14247          { "wxGridTableBase_DeleteCols", (PyCFunction) _wrap_wxGridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14248          { "wxGridTableBase_AppendCols", (PyCFunction) _wrap_wxGridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS },
14249          { "wxGridTableBase_InsertCols", (PyCFunction) _wrap_wxGridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS },
14250          { "wxGridTableBase_DeleteRows", (PyCFunction) _wrap_wxGridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14251          { "wxGridTableBase_AppendRows", (PyCFunction) _wrap_wxGridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS },
14252          { "wxGridTableBase_InsertRows", (PyCFunction) _wrap_wxGridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS },
14253          { "wxGridTableBase_Clear", (PyCFunction) _wrap_wxGridTableBase_Clear, METH_VARARGS | METH_KEYWORDS },
14254          { "wxGridTableBase_SetValueAsBool", (PyCFunction) _wrap_wxGridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS },
14255          { "wxGridTableBase_SetValueAsDouble", (PyCFunction) _wrap_wxGridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS },
14256          { "wxGridTableBase_SetValueAsLong", (PyCFunction) _wrap_wxGridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS },
14257          { "wxGridTableBase_GetValueAsBool", (PyCFunction) _wrap_wxGridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS },
14258          { "wxGridTableBase_GetValueAsDouble", (PyCFunction) _wrap_wxGridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS },
14259          { "wxGridTableBase_GetValueAsLong", (PyCFunction) _wrap_wxGridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS },
14260          { "wxGridTableBase_CanSetValueAs", (PyCFunction) _wrap_wxGridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS },
14261          { "wxGridTableBase_CanGetValueAs", (PyCFunction) _wrap_wxGridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
14262          { "wxGridTableBase_GetTypeName", (PyCFunction) _wrap_wxGridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS },
14263          { "wxGridTableBase_SetValue", (PyCFunction) _wrap_wxGridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS },
14264          { "wxGridTableBase_GetValue", (PyCFunction) _wrap_wxGridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS },
14265          { "wxGridTableBase_IsEmptyCell", (PyCFunction) _wrap_wxGridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS },
14266          { "wxGridTableBase_GetNumberCols", (PyCFunction) _wrap_wxGridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS },
14267          { "wxGridTableBase_GetNumberRows", (PyCFunction) _wrap_wxGridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS },
14268          { "wxGridTableBase_GetView", (PyCFunction) _wrap_wxGridTableBase_GetView, METH_VARARGS | METH_KEYWORDS },
14269          { "wxGridTableBase_SetView", (PyCFunction) _wrap_wxGridTableBase_SetView, METH_VARARGS | METH_KEYWORDS },
14270          { "wxGridTableBase_GetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS },
14271          { "wxGridTableBase_SetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS },
14272          { "wxPyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14273          { "wxPyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14274          { "wxPyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
14275          { "wxPyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
14276          { "wxPyGridCellAttrProvider__setSelf", (PyCFunction) _wrap_wxPyGridCellAttrProvider__setSelf, METH_VARARGS | METH_KEYWORDS },
14277          { "new_wxPyGridCellAttrProvider", (PyCFunction) _wrap_new_wxPyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
14278          { "wxGridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS },
14279          { "wxGridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS },
14280          { "wxGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14281          { "wxGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14282          { "wxGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS },
14283          { "wxGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS },
14284          { "new_wxGridCellAttrProvider", (PyCFunction) _wrap_new_wxGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
14285          { "wxGridCellAttr_SetDefAttr", (PyCFunction) _wrap_wxGridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS },
14286          { "wxGridCellAttr_IsReadOnly", (PyCFunction) _wrap_wxGridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
14287          { "wxGridCellAttr_GetEditor", (PyCFunction) _wrap_wxGridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS },
14288          { "wxGridCellAttr_GetRenderer", (PyCFunction) _wrap_wxGridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS },
14289          { "wxGridCellAttr_GetAlignment", (PyCFunction) _wrap_wxGridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS },
14290          { "wxGridCellAttr_GetFont", (PyCFunction) _wrap_wxGridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS },
14291          { "wxGridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14292          { "wxGridCellAttr_GetTextColour", (PyCFunction) _wrap_wxGridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS },
14293          { "wxGridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_wxGridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS },
14294          { "wxGridCellAttr_HasEditor", (PyCFunction) _wrap_wxGridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS },
14295          { "wxGridCellAttr_HasRenderer", (PyCFunction) _wrap_wxGridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS },
14296          { "wxGridCellAttr_HasAlignment", (PyCFunction) _wrap_wxGridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS },
14297          { "wxGridCellAttr_HasFont", (PyCFunction) _wrap_wxGridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS },
14298          { "wxGridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14299          { "wxGridCellAttr_HasTextColour", (PyCFunction) _wrap_wxGridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS },
14300          { "wxGridCellAttr_SetKind", (PyCFunction) _wrap_wxGridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS },
14301          { "wxGridCellAttr_SetEditor", (PyCFunction) _wrap_wxGridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS },
14302          { "wxGridCellAttr_SetRenderer", (PyCFunction) _wrap_wxGridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS },
14303          { "wxGridCellAttr_SetReadOnly", (PyCFunction) _wrap_wxGridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
14304          { "wxGridCellAttr_SetAlignment", (PyCFunction) _wrap_wxGridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS },
14305          { "wxGridCellAttr_SetFont", (PyCFunction) _wrap_wxGridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS },
14306          { "wxGridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14307          { "wxGridCellAttr_SetTextColour", (PyCFunction) _wrap_wxGridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS },
14308          { "wxGridCellAttr_DecRef", (PyCFunction) _wrap_wxGridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS },
14309          { "wxGridCellAttr_IncRef", (PyCFunction) _wrap_wxGridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS },
14310          { "wxGridCellAttr_MergeWith", (PyCFunction) _wrap_wxGridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS },
14311          { "wxGridCellAttr_Clone", (PyCFunction) _wrap_wxGridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS },
14312          { "new_wxGridCellAttr", (PyCFunction) _wrap_new_wxGridCellAttr, METH_VARARGS | METH_KEYWORDS },
14313          { "new_wxGridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS },
14314          { "new_wxGridCellEnumEditor", (PyCFunction) _wrap_new_wxGridCellEnumEditor, METH_VARARGS | METH_KEYWORDS },
14315          { "new_wxGridCellChoiceEditor", (PyCFunction) _wrap_new_wxGridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS },
14316          { "new_wxGridCellBoolEditor", (PyCFunction) _wrap_new_wxGridCellBoolEditor, METH_VARARGS | METH_KEYWORDS },
14317          { "new_wxGridCellFloatEditor", (PyCFunction) _wrap_new_wxGridCellFloatEditor, METH_VARARGS | METH_KEYWORDS },
14318          { "new_wxGridCellNumberEditor", (PyCFunction) _wrap_new_wxGridCellNumberEditor, METH_VARARGS | METH_KEYWORDS },
14319          { "new_wxGridCellTextEditor", (PyCFunction) _wrap_new_wxGridCellTextEditor, METH_VARARGS | METH_KEYWORDS },
14320          { "wxPyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
14321          { "wxPyGridCellEditor_base_Destroy", (PyCFunction) _wrap_wxPyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS },
14322          { "wxPyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_wxPyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS },
14323          { "wxPyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS },
14324          { "wxPyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS },
14325          { "wxPyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
14326          { "wxPyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_wxPyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS },
14327          { "wxPyGridCellEditor_base_Show", (PyCFunction) _wrap_wxPyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS },
14328          { "wxPyGridCellEditor_base_SetSize", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS },
14329          { "wxPyGridCellEditor__setSelf", (PyCFunction) _wrap_wxPyGridCellEditor__setSelf, METH_VARARGS | METH_KEYWORDS },
14330          { "new_wxPyGridCellEditor", (PyCFunction) _wrap_new_wxPyGridCellEditor, METH_VARARGS | METH_KEYWORDS },
14331          { "wxGridCellEditor_Destroy", (PyCFunction) _wrap_wxGridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS },
14332          { "wxGridCellEditor_HandleReturn", (PyCFunction) _wrap_wxGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS },
14333          { "wxGridCellEditor_StartingClick", (PyCFunction) _wrap_wxGridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS },
14334          { "wxGridCellEditor_StartingKey", (PyCFunction) _wrap_wxGridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS },
14335          { "wxGridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_wxGridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
14336          { "wxGridCellEditor_PaintBackground", (PyCFunction) _wrap_wxGridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS },
14337          { "wxGridCellEditor_Show", (PyCFunction) _wrap_wxGridCellEditor_Show, METH_VARARGS | METH_KEYWORDS },
14338          { "wxGridCellEditor_SetSize", (PyCFunction) _wrap_wxGridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS },
14339          { "wxGridCellEditor_Clone", (PyCFunction) _wrap_wxGridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS },
14340          { "wxGridCellEditor_Reset", (PyCFunction) _wrap_wxGridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS },
14341          { "wxGridCellEditor_EndEdit", (PyCFunction) _wrap_wxGridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS },
14342          { "wxGridCellEditor_BeginEdit", (PyCFunction) _wrap_wxGridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS },
14343          { "wxGridCellEditor_Create", (PyCFunction) _wrap_wxGridCellEditor_Create, METH_VARARGS | METH_KEYWORDS },
14344          { "wxGridCellEditor_DecRef", (PyCFunction) _wrap_wxGridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS },
14345          { "wxGridCellEditor_IncRef", (PyCFunction) _wrap_wxGridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS },
14346          { "wxGridCellEditor_SetParameters", (PyCFunction) _wrap_wxGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS },
14347          { "wxGridCellEditor_SetControl", (PyCFunction) _wrap_wxGridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS },
14348          { "wxGridCellEditor_GetControl", (PyCFunction) _wrap_wxGridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS },
14349          { "wxGridCellEditor_IsCreated", (PyCFunction) _wrap_wxGridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS },
14350          { "new_wxGridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS },
14351          { "new_wxGridCellEnumRenderer", (PyCFunction) _wrap_new_wxGridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS },
14352          { "new_wxGridCellDateTimeRenderer", (PyCFunction) _wrap_new_wxGridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS },
14353          { "new_wxGridCellBoolRenderer", (PyCFunction) _wrap_new_wxGridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS },
14354          { "wxGridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_wxGridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS },
14355          { "wxGridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_wxGridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS },
14356          { "wxGridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_wxGridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS },
14357          { "wxGridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_wxGridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS },
14358          { "new_wxGridCellFloatRenderer", (PyCFunction) _wrap_new_wxGridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS },
14359          { "new_wxGridCellNumberRenderer", (PyCFunction) _wrap_new_wxGridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS },
14360          { "new_wxGridCellStringRenderer", (PyCFunction) _wrap_new_wxGridCellStringRenderer, METH_VARARGS | METH_KEYWORDS },
14361          { "wxPyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
14362          { "wxPyGridCellRenderer__setSelf", (PyCFunction) _wrap_wxPyGridCellRenderer__setSelf, METH_VARARGS | METH_KEYWORDS },
14363          { "new_wxPyGridCellRenderer", (PyCFunction) _wrap_new_wxPyGridCellRenderer, METH_VARARGS | METH_KEYWORDS },
14364          { "wxGridCellRenderer_Clone", (PyCFunction) _wrap_wxGridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS },
14365          { "wxGridCellRenderer_GetBestSize", (PyCFunction) _wrap_wxGridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS },
14366          { "wxGridCellRenderer_Draw", (PyCFunction) _wrap_wxGridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS },
14367          { "wxGridCellRenderer_DecRef", (PyCFunction) _wrap_wxGridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS },
14368          { "wxGridCellRenderer_IncRef", (PyCFunction) _wrap_wxGridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS },
14369          { "wxGridCellRenderer_SetParameters", (PyCFunction) _wrap_wxGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS },
14370          { NULL, NULL }
14371 };
14372 #ifdef __cplusplus
14373 }
14374 #endif
14375 /*
14376  * This table is used by the pointer type-checker
14377  */
14378 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
14379     { "_wxEvent","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxEvent},
14380     { "_wxEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxEvent},
14381     { "_wxEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxEvent},
14382     { "_wxEvent","_wxGridEvent",SwigwxGridEventTowxEvent},
14383     { "_signed_long","_long",0},
14384     { "_wxGridCellChoiceEditor","_wxGridCellEnumEditor",SwigwxGridCellEnumEditorTowxGridCellChoiceEditor},
14385     { "_wxPrintQuality","_WXGRIDSELECTIONMODES",0},
14386     { "_wxPrintQuality","_wxCoord",0},
14387     { "_wxPrintQuality","_int",0},
14388     { "_wxPrintQuality","_signed_int",0},
14389     { "_wxPrintQuality","_unsigned_int",0},
14390     { "_wxPrintQuality","_wxWindowID",0},
14391     { "_wxPrintQuality","_uint",0},
14392     { "_wxPrintQuality","_EBool",0},
14393     { "_wxPrintQuality","_size_t",0},
14394     { "_wxPrintQuality","_time_t",0},
14395     { "_wxNotifyEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxNotifyEvent},
14396     { "_wxNotifyEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxNotifyEvent},
14397     { "_wxNotifyEvent","_wxGridEvent",SwigwxGridEventTowxNotifyEvent},
14398     { "_byte","_unsigned_char",0},
14399     { "_long","_unsigned_long",0},
14400     { "_long","_signed_long",0},
14401     { "_size_t","_WXGRIDSELECTIONMODES",0},
14402     { "_size_t","_wxCoord",0},
14403     { "_size_t","_wxPrintQuality",0},
14404     { "_size_t","_time_t",0},
14405     { "_size_t","_unsigned_int",0},
14406     { "_size_t","_int",0},
14407     { "_size_t","_wxWindowID",0},
14408     { "_size_t","_uint",0},
14409     { "_wxPanel","_wxGrid",SwigwxGridTowxPanel},
14410     { "_uint","_WXGRIDSELECTIONMODES",0},
14411     { "_uint","_wxCoord",0},
14412     { "_uint","_wxPrintQuality",0},
14413     { "_uint","_time_t",0},
14414     { "_uint","_size_t",0},
14415     { "_uint","_unsigned_int",0},
14416     { "_uint","_int",0},
14417     { "_uint","_wxWindowID",0},
14418     { "_wxChar","_char",0},
14419     { "_wxCommandEvent","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxCommandEvent},
14420     { "_wxCommandEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxCommandEvent},
14421     { "_wxCommandEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxCommandEvent},
14422     { "_wxCommandEvent","_wxGridEvent",SwigwxGridEventTowxCommandEvent},
14423     { "_char","_wxChar",0},
14424     { "_wxGridCellStringRenderer","_wxGridCellAutoWrapStringRenderer",SwigwxGridCellAutoWrapStringRendererTowxGridCellStringRenderer},
14425     { "_wxGridCellStringRenderer","_wxGridCellEnumRenderer",SwigwxGridCellEnumRendererTowxGridCellStringRenderer},
14426     { "_wxGridCellStringRenderer","_wxGridCellDateTimeRenderer",SwigwxGridCellDateTimeRendererTowxGridCellStringRenderer},
14427     { "_wxGridCellStringRenderer","_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellStringRenderer},
14428     { "_wxGridCellStringRenderer","_wxGridCellNumberRenderer",SwigwxGridCellNumberRendererTowxGridCellStringRenderer},
14429     { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
14430     { "_wxGridTableBase","_wxGridStringTable",SwigwxGridStringTableTowxGridTableBase},
14431     { "_wxGridTableBase","_wxPyGridTableBase",SwigwxPyGridTableBaseTowxGridTableBase},
14432     { "_EBool","_WXGRIDSELECTIONMODES",0},
14433     { "_EBool","_wxCoord",0},
14434     { "_EBool","_wxPrintQuality",0},
14435     { "_EBool","_signed_int",0},
14436     { "_EBool","_int",0},
14437     { "_EBool","_wxWindowID",0},
14438     { "_unsigned_long","_long",0},
14439     { "_WXGRIDSELECTIONMODES","_int",0},
14440     { "_WXGRIDSELECTIONMODES","_signed_int",0},
14441     { "_WXGRIDSELECTIONMODES","_unsigned_int",0},
14442     { "_WXGRIDSELECTIONMODES","_wxWindowID",0},
14443     { "_WXGRIDSELECTIONMODES","_uint",0},
14444     { "_WXGRIDSELECTIONMODES","_EBool",0},
14445     { "_WXGRIDSELECTIONMODES","_size_t",0},
14446     { "_WXGRIDSELECTIONMODES","_time_t",0},
14447     { "_WXGRIDSELECTIONMODES","_wxPrintQuality",0},
14448     { "_WXGRIDSELECTIONMODES","_wxCoord",0},
14449     { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
14450     { "_signed_int","_WXGRIDSELECTIONMODES",0},
14451     { "_signed_int","_wxCoord",0},
14452     { "_signed_int","_wxPrintQuality",0},
14453     { "_signed_int","_EBool",0},
14454     { "_signed_int","_wxWindowID",0},
14455     { "_signed_int","_int",0},
14456     { "_wxGridCellEditor","_wxGridCellAutoWrapStringEditor",SwigwxGridCellAutoWrapStringEditorTowxGridCellEditor},
14457     { "_wxGridCellEditor","_wxGridCellEnumEditor",SwigwxGridCellEnumEditorTowxGridCellEditor},
14458     { "_wxGridCellEditor","_wxGridCellChoiceEditor",SwigwxGridCellChoiceEditorTowxGridCellEditor},
14459     { "_wxGridCellEditor","_wxGridCellBoolEditor",SwigwxGridCellBoolEditorTowxGridCellEditor},
14460     { "_wxGridCellEditor","_wxGridCellFloatEditor",SwigwxGridCellFloatEditorTowxGridCellEditor},
14461     { "_wxGridCellEditor","_wxGridCellNumberEditor",SwigwxGridCellNumberEditorTowxGridCellEditor},
14462     { "_wxGridCellEditor","_wxGridCellTextEditor",SwigwxGridCellTextEditorTowxGridCellEditor},
14463     { "_wxGridCellEditor","_wxPyGridCellEditor",SwigwxPyGridCellEditorTowxGridCellEditor},
14464     { "_WXTYPE","_short",0},
14465     { "_WXTYPE","_signed_short",0},
14466     { "_WXTYPE","_unsigned_short",0},
14467     { "_wxGridCellAttrProvider","_wxPyGridCellAttrProvider",SwigwxPyGridCellAttrProviderTowxGridCellAttrProvider},
14468     { "_unsigned_short","_WXTYPE",0},
14469     { "_unsigned_short","_short",0},
14470     { "_wxObject","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxObject},
14471     { "_wxObject","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxObject},
14472     { "_wxObject","_wxGridSizeEvent",SwigwxGridSizeEventTowxObject},
14473     { "_wxObject","_wxGridEvent",SwigwxGridEventTowxObject},
14474     { "_wxObject","_wxGrid",SwigwxGridTowxObject},
14475     { "_wxObject","_wxGridStringTable",SwigwxGridStringTableTowxObject},
14476     { "_wxObject","_wxPyGridTableBase",SwigwxPyGridTableBaseTowxObject},
14477     { "_wxObject","_wxGridTableBase",SwigwxGridTableBaseTowxObject},
14478     { "_signed_short","_WXTYPE",0},
14479     { "_signed_short","_short",0},
14480     { "_wxScrolledWindow","_wxGrid",SwigwxGridTowxScrolledWindow},
14481     { "_unsigned_char","_byte",0},
14482     { "_unsigned_int","_WXGRIDSELECTIONMODES",0},
14483     { "_unsigned_int","_wxCoord",0},
14484     { "_unsigned_int","_wxPrintQuality",0},
14485     { "_unsigned_int","_time_t",0},
14486     { "_unsigned_int","_size_t",0},
14487     { "_unsigned_int","_uint",0},
14488     { "_unsigned_int","_wxWindowID",0},
14489     { "_unsigned_int","_int",0},
14490     { "_short","_WXTYPE",0},
14491     { "_short","_unsigned_short",0},
14492     { "_short","_signed_short",0},
14493     { "_wxWindowID","_WXGRIDSELECTIONMODES",0},
14494     { "_wxWindowID","_wxCoord",0},
14495     { "_wxWindowID","_wxPrintQuality",0},
14496     { "_wxWindowID","_time_t",0},
14497     { "_wxWindowID","_size_t",0},
14498     { "_wxWindowID","_EBool",0},
14499     { "_wxWindowID","_uint",0},
14500     { "_wxWindowID","_int",0},
14501     { "_wxWindowID","_signed_int",0},
14502     { "_wxWindowID","_unsigned_int",0},
14503     { "_int","_WXGRIDSELECTIONMODES",0},
14504     { "_int","_wxCoord",0},
14505     { "_int","_wxPrintQuality",0},
14506     { "_int","_time_t",0},
14507     { "_int","_size_t",0},
14508     { "_int","_EBool",0},
14509     { "_int","_uint",0},
14510     { "_int","_wxWindowID",0},
14511     { "_int","_unsigned_int",0},
14512     { "_int","_signed_int",0},
14513     { "_time_t","_WXGRIDSELECTIONMODES",0},
14514     { "_time_t","_wxCoord",0},
14515     { "_time_t","_wxPrintQuality",0},
14516     { "_time_t","_unsigned_int",0},
14517     { "_time_t","_int",0},
14518     { "_time_t","_wxWindowID",0},
14519     { "_time_t","_uint",0},
14520     { "_time_t","_size_t",0},
14521     { "_wxCoord","_WXGRIDSELECTIONMODES",0},
14522     { "_wxCoord","_int",0},
14523     { "_wxCoord","_signed_int",0},
14524     { "_wxCoord","_unsigned_int",0},
14525     { "_wxCoord","_wxWindowID",0},
14526     { "_wxCoord","_uint",0},
14527     { "_wxCoord","_EBool",0},
14528     { "_wxCoord","_size_t",0},
14529     { "_wxCoord","_time_t",0},
14530     { "_wxCoord","_wxPrintQuality",0},
14531     { "_wxGridCellRenderer","_wxGridCellAutoWrapStringRenderer",SwigwxGridCellAutoWrapStringRendererTowxGridCellRenderer},
14532     { "_wxGridCellRenderer","_wxGridCellEnumRenderer",SwigwxGridCellEnumRendererTowxGridCellRenderer},
14533     { "_wxGridCellRenderer","_wxGridCellDateTimeRenderer",SwigwxGridCellDateTimeRendererTowxGridCellRenderer},
14534     { "_wxGridCellRenderer","_wxGridCellBoolRenderer",SwigwxGridCellBoolRendererTowxGridCellRenderer},
14535     { "_wxGridCellRenderer","_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellRenderer},
14536     { "_wxGridCellRenderer","_wxGridCellNumberRenderer",SwigwxGridCellNumberRendererTowxGridCellRenderer},
14537     { "_wxGridCellRenderer","_wxGridCellStringRenderer",SwigwxGridCellStringRendererTowxGridCellRenderer},
14538     { "_wxGridCellRenderer","_wxPyGridCellRenderer",SwigwxPyGridCellRendererTowxGridCellRenderer},
14539     { "_wxGridCellTextEditor","_wxGridCellAutoWrapStringEditor",SwigwxGridCellAutoWrapStringEditorTowxGridCellTextEditor},
14540     { "_wxGridCellTextEditor","_wxGridCellFloatEditor",SwigwxGridCellFloatEditorTowxGridCellTextEditor},
14541     { "_wxGridCellTextEditor","_wxGridCellNumberEditor",SwigwxGridCellNumberEditorTowxGridCellTextEditor},
14542     { "_wxEvtHandler","_wxGrid",SwigwxGridTowxEvtHandler},
14543     { "_wxWindow","_wxGrid",SwigwxGridTowxWindow},
14544 {0,0,0}};
14545
14546 static PyObject *SWIG_globals;
14547 #ifdef __cplusplus
14548 extern "C"
14549 #endif
14550 SWIGEXPORT(void) initgridc() {
14551          PyObject *m, *d;
14552          SWIG_globals = SWIG_newvarlink();
14553          m = Py_InitModule("gridc", gridcMethods);
14554          d = PyModule_GetDict(m);
14555          PyDict_SetItemString(d,"wxGRID_VALUE_STRING", PyString_FromString("string"));
14556          PyDict_SetItemString(d,"wxGRID_VALUE_BOOL", PyString_FromString("bool"));
14557          PyDict_SetItemString(d,"wxGRID_VALUE_NUMBER", PyString_FromString("long"));
14558          PyDict_SetItemString(d,"wxGRID_VALUE_FLOAT", PyString_FromString("double"));
14559          PyDict_SetItemString(d,"wxGRID_VALUE_CHOICE", PyString_FromString("choice"));
14560          PyDict_SetItemString(d,"wxGRID_VALUE_TEXT", PyString_FromString("string"));
14561          PyDict_SetItemString(d,"wxGRID_VALUE_LONG", PyString_FromString("long"));
14562          PyDict_SetItemString(d,"cvar", SWIG_globals);
14563          SWIG_addvarlink(SWIG_globals,"wxGridNoCellCoords",_wrap_wxGridNoCellCoords_get, _wrap_wxGridNoCellCoords_set);
14564          SWIG_addvarlink(SWIG_globals,"wxGridNoCellRect",_wrap_wxGridNoCellRect_get, _wrap_wxGridNoCellRect_set);
14565          PyDict_SetItemString(d,"wxGRIDTABLE_REQUEST_VIEW_GET_VALUES", PyInt_FromLong((long) wxGRIDTABLE_REQUEST_VIEW_GET_VALUES));
14566          PyDict_SetItemString(d,"wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES", PyInt_FromLong((long) wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES));
14567          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_INSERTED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_INSERTED));
14568          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_APPENDED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_APPENDED));
14569          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_DELETED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_DELETED));
14570          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_INSERTED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_INSERTED));
14571          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_APPENDED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_APPENDED));
14572          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_DELETED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_DELETED));
14573          PyDict_SetItemString(d,"wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_LEFT_CLICK));
14574          PyDict_SetItemString(d,"wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_RIGHT_CLICK));
14575          PyDict_SetItemString(d,"wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_LEFT_DCLICK));
14576          PyDict_SetItemString(d,"wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_RIGHT_DCLICK));
14577          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_LEFT_CLICK));
14578          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_RIGHT_CLICK));
14579          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_LEFT_DCLICK));
14580          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_RIGHT_DCLICK));
14581          PyDict_SetItemString(d,"wxEVT_GRID_ROW_SIZE", PyInt_FromLong((long) wxEVT_GRID_ROW_SIZE));
14582          PyDict_SetItemString(d,"wxEVT_GRID_COL_SIZE", PyInt_FromLong((long) wxEVT_GRID_COL_SIZE));
14583          PyDict_SetItemString(d,"wxEVT_GRID_RANGE_SELECT", PyInt_FromLong((long) wxEVT_GRID_RANGE_SELECT));
14584          PyDict_SetItemString(d,"wxEVT_GRID_CELL_CHANGE", PyInt_FromLong((long) wxEVT_GRID_CELL_CHANGE));
14585          PyDict_SetItemString(d,"wxEVT_GRID_SELECT_CELL", PyInt_FromLong((long) wxEVT_GRID_SELECT_CELL));
14586          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_SHOWN));
14587          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_HIDDEN));
14588          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong((long) wxEVT_GRID_EDITOR_CREATED));
14589
14590     wxClassInfo::CleanUpClasses();
14591     wxClassInfo::InitializeClasses();
14592          PyDict_SetItemString(d,"wxGridCellAttr_Any", PyInt_FromLong((long) wxGridCellAttr::Any));
14593          PyDict_SetItemString(d,"wxGridCellAttr_Default", PyInt_FromLong((long) wxGridCellAttr::Default));
14594          PyDict_SetItemString(d,"wxGridCellAttr_Cell", PyInt_FromLong((long) wxGridCellAttr::Cell));
14595          PyDict_SetItemString(d,"wxGridCellAttr_Row", PyInt_FromLong((long) wxGridCellAttr::Row));
14596          PyDict_SetItemString(d,"wxGridCellAttr_Col", PyInt_FromLong((long) wxGridCellAttr::Col));
14597          PyDict_SetItemString(d,"wxGridCellAttr_Merged", PyInt_FromLong((long) wxGridCellAttr::Merged));
14598          PyDict_SetItemString(d,"wxGrid_wxGridSelectCells", PyInt_FromLong((long) wxGrid::wxGridSelectCells));
14599          PyDict_SetItemString(d,"wxGrid_wxGridSelectRows", PyInt_FromLong((long) wxGrid::wxGridSelectRows));
14600          PyDict_SetItemString(d,"wxGrid_wxGridSelectColumns", PyInt_FromLong((long) wxGrid::wxGridSelectColumns));
14601 {
14602    int i;
14603    for (i = 0; _swig_mapping[i].n1; i++)
14604         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
14605 }
14606 }