wxPython/src/gtk/grid.cpp

   1 /*
   2  * FILE : src/gtk/grid.cpp
   3  *
   4  * This file was automatically generated by :
   5  * Simplified Wrapper and Interface Generator (SWIG)
   6  * Version 1.1 (Build 883)
   7  *
   8  * Portions Copyright (c) 1995-1998
   9  * The University of Utah and The Regents of the University of California.
  10  * Permission is granted to distribute this file in any manner provided
  11  * this notice remains intact.
  12  *
  13  * Do not make changes to this file--changes will be lost!
  14  *
  15  */
  16
  17
  18 #define SWIGCODE
  19 /* Implementation : PYTHON */
  20
  21 #define SWIGPYTHON
  22 #include <string.h>
  23 #include <stdlib.h>
  24 /* Definitions for Windows/Unix exporting */
  25 #if defined(__WIN32__)
  26 #   if defined(_MSC_VER)
  27 #       define SWIGEXPORT(a) __declspec(dllexport) a
  28 #   else
  29 #       if defined(__BORLANDC__)
  30 #           define SWIGEXPORT(a) a _export
  31 #       else
  32 #           define SWIGEXPORT(a) a
  33 #       endif
  34 #   endif
  35 #else
  36 #   define SWIGEXPORT(a) a
  37 #endif
  38
  39 #include "Python.h"
  40
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #endif
  44
  45 extern void SWIG_MakePtr(char *, void *, char *);
  46 extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
  47 extern char *SWIG_GetPtr(char *, void **, char *);
  48 extern char *SWIG_GetPtrObj(PyObject *, void **, char *);
  49 extern void SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
  50 extern PyObject *SWIG_newvarlink(void);
  51 #ifdef __cplusplus
  52 }
  53 #endif
  54 #define SWIG_init    initgridc
  55
  56 #define SWIG_name    "gridc"
  57
  58 #include "export.h"
  59 #include <wx/grid.h>
  60 #include <wx/generic/gridctrl.h>
  61
  62
  63 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
  64     PyObject*   o2;
  65     PyObject*   o3;
  66
  67     if (!target) {
  68         target = o;
  69     } else if (target == Py_None) {
  70         Py_DECREF(Py_None);
  71         target = o;
  72     } else {
  73         if (!PyTuple_Check(target)) {
  74             o2 = target;
  75             target = PyTuple_New(1);
  76             PyTuple_SetItem(target, 0, o2);
  77         }
  78         o3 = PyTuple_New(1);
  79         PyTuple_SetItem(o3, 0, o);
  80
  81         o2 = target;
  82         target = PySequence_Concat(o2, o3);
  83         Py_DECREF(o2);
  84         Py_DECREF(o3);
  85     }
  86     return target;
  87 }
  88
  89 #if PYTHON_API_VERSION >= 1009
  90     static char* wxStringErrorMsg = "String or Unicode type required";
  91 #else
  92     static char* wxStringErrorMsg = "String type required";
  93 #endif
  94
  95 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME)                               \
  96     wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) {        \
  97         wxGridCellAttr* rval = NULL;                                            \
  98         bool found;                                                             \
  99         wxPyTState* state = wxPyBeginBlockThreads();                            \
 100         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 101             PyObject* ro;                                                       \
 102             wxGridCellAttr* ptr;                                                \
 103             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
 104             if (ro) {                                                           \
 105                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellAttr_p"))    \
 106                     rval = ptr;                                                 \
 107                 Py_DECREF(ro);                                                  \
 108             }                                                                   \
 109         }                                                                       \
 110         wxPyEndBlockThreads(state);                                             \
 111         if (! found)                                                            \
 112             rval = PCLASS::CBNAME(a, b, c);                                     \
 113         return rval;                                                            \
 114     }                                                                           \
 115     wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
 116         return PCLASS::CBNAME(a, b, c);                                         \
 117     }
 118
 119
 120
 121 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                                   \
 122     void CBNAME(wxGridCellAttr *attr, int a, int b) {                           \
 123         wxPyTState* state = wxPyBeginBlockThreads();                            \
 124         bool found;                                                             \
 125         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 126             PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
 127             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b));   \
 128             Py_DECREF(obj);                                                     \
 129         }                                                                       \
 130         wxPyEndBlockThreads(state);                                             \
 131         if (! found)                                                            \
 132             PCLASS::CBNAME(attr, a, b);                                         \
 133     }                                                                           \
 134     void base_##CBNAME(wxGridCellAttr *attr, int a, int b) {                    \
 135         PCLASS::CBNAME(attr, a, b);                                             \
 136     }
 137
 138
 139
 140 #define PYCALLBACK__GCAINT(PCLASS, CBNAME)                                      \
 141     void CBNAME(wxGridCellAttr *attr, int val) {                                \
 142         wxPyTState* state = wxPyBeginBlockThreads();                            \
 143         bool found;                                                             \
 144         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 145             PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
 146             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));    \
 147             Py_DECREF(obj);                                                     \
 148         }                                                                       \
 149         wxPyEndBlockThreads(state);                                             \
 150         if (! found)                                                            \
 151             PCLASS::CBNAME(attr, val);                                          \
 152     }                                                                           \
 153     void base_##CBNAME(wxGridCellAttr *attr, int val) {                         \
 154         PCLASS::CBNAME(attr, val);                                              \
 155     }
 156
 157
 158
 159 #define PYCALLBACK_INT__pure(CBNAME)                                            \
 160     int  CBNAME() {                                                             \
 161         wxPyTState* state = wxPyBeginBlockThreads();                            \
 162         int rval = 0;                                                           \
 163         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 164             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
 165         wxPyEndBlockThreads(state);                                             \
 166         return rval;                                                            \
 167     }
 168
 169
 170
 171 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                                     \
 172     bool CBNAME(int a, int b) {                                                 \
 173         wxPyTState* state = wxPyBeginBlockThreads();                            \
 174         bool rval = 0;                                                          \
 175         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 176             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));   \
 177         wxPyEndBlockThreads(state);                                             \
 178         return rval;                                                            \
 179     }
 180
 181
 182
 183 #define PYCALLBACK_STRING_INTINT_pure(CBNAME)                                   \
 184     wxString CBNAME(int a, int b) {                                             \
 185         wxPyTState* state = wxPyBeginBlockThreads();                            \
 186         wxString rval;                                                          \
 187         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 188             PyObject* ro;                                                       \
 189             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 190             if (ro) {                                                           \
 191                 PyObject* str = PyObject_Str(ro);                               \
 192                 rval = PyString_AsString(str);                                  \
 193                 Py_DECREF(ro);  Py_DECREF(str);                                 \
 194             }                                                                   \
 195         }                                                                       \
 196         wxPyEndBlockThreads(state);                                             \
 197         return rval;                                                            \
 198     }
 199
 200
 201
 202 #define PYCALLBACK__INTINTSTRING_pure(CBNAME)                                   \
 203     void CBNAME(int a, int b, const wxString& c) {                              \
 204         wxPyTState* state = wxPyBeginBlockThreads();                            \
 205         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 206             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str()));\
 207         wxPyEndBlockThreads(state);                                             \
 208     }
 209
 210
 211 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                                \
 212     wxString CBNAME(int a, int b) {                                             \
 213         bool found;                                                             \
 214         wxPyTState* state = wxPyBeginBlockThreads();                            \
 215         wxString rval;                                                          \
 216         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 217             PyObject* ro;                                                       \
 218             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 219             if (ro) {                                                           \
 220                 PyObject* str = PyObject_Str(ro);                               \
 221                 rval = PyString_AsString(str);                                  \
 222                 Py_DECREF(ro);  Py_DECREF(str);                                 \
 223             }                                                                   \
 224         }                                                                       \
 225         wxPyEndBlockThreads(state);                                             \
 226         if (! found)                                                            \
 227             rval = PCLASS::CBNAME(a, b);                                        \
 228         return rval;                                                            \
 229     }                                                                           \
 230     wxString base_##CBNAME(int a, int b) {                                      \
 231         return PCLASS::CBNAME(a, b);                                            \
 232     }
 233
 234
 235
 236 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                            \
 237     bool CBNAME(int a, int b, const wxString& c)  {                             \
 238         bool rval = 0;                                                          \
 239         bool found;                                                             \
 240         wxPyTState* state = wxPyBeginBlockThreads();                            \
 241         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 242             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)", a,b,c.c_str()));\
 243         wxPyEndBlockThreads(state);                                             \
 244         if (! found)                                                            \
 245             rval = PCLASS::CBNAME(a,b,c);                                       \
 246         return rval;                                                            \
 247     }                                                                           \
 248     bool base_##CBNAME(int a, int b, const wxString& c) {                       \
 249         return PCLASS::CBNAME(a,b,c);                                           \
 250     }
 251
 252
 253
 254
 255 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME)                                  \
 256     long CBNAME(int a, int b)  {                                                \
 257         long rval;                                                              \
 258         bool found;                                                             \
 259         wxPyTState* state = wxPyBeginBlockThreads();                            \
 260         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 261             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 262         wxPyEndBlockThreads(state);                                             \
 263         if (! found)                                                            \
 264             rval = PCLASS::CBNAME(a,b);                                         \
 265         return rval;                                                            \
 266     }                                                                           \
 267     long base_##CBNAME(int a, int b) {                                          \
 268         return PCLASS::CBNAME(a,b);                                             \
 269     }
 270
 271
 272
 273 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                                  \
 274     bool CBNAME(int a, int b)  {                                                \
 275         bool rval = 0;                                                          \
 276         bool found;                                                             \
 277         wxPyTState* state = wxPyBeginBlockThreads();                            \
 278         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 279             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 280         wxPyEndBlockThreads(state);                                             \
 281         if (! found)                                                            \
 282             rval = PCLASS::CBNAME(a,b);                                         \
 283         return rval;                                                            \
 284     }                                                                           \
 285     bool base_##CBNAME(int a, int b) {                                          \
 286         return PCLASS::CBNAME(a,b);                                             \
 287     }
 288
 289
 290
 291 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                                \
 292     double CBNAME(int a, int b) {                                               \
 293         bool found;                                                             \
 294         wxPyTState* state = wxPyBeginBlockThreads();                            \
 295         double rval;                                                            \
 296         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 297             PyObject* ro;                                                       \
 298             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 299             if (ro) {                                                           \
 300                 PyObject* str = PyObject_Str(ro);                               \
 301                 rval = PyFloat_AsDouble(str);                                   \
 302                 Py_DECREF(ro);   Py_DECREF(str);                                \
 303             }                                                                   \
 304         }                                                                       \
 305         wxPyEndBlockThreads(state);                                             \
 306         if (! found)                                                            \
 307             rval = PCLASS::CBNAME(a, b);                                        \
 308         return rval;                                                            \
 309     }                                                                           \
 310     double base_##CBNAME(int a, int b) {                                        \
 311         return PCLASS::CBNAME(a, b);                                            \
 312     }
 313
 314
 315
 316 #define PYCALLBACK__(PCLASS, CBNAME)                                            \
 317     void CBNAME()  {                                                            \
 318         bool found;                                                             \
 319         wxPyTState* state = wxPyBeginBlockThreads();                            \
 320         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 321             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
 322         wxPyEndBlockThreads(state);                                             \
 323         if (! found)                                                            \
 324             PCLASS::CBNAME();                                                   \
 325     }                                                                           \
 326     void base_##CBNAME() {                                                      \
 327         PCLASS::CBNAME();                                                       \
 328     }
 329
 330
 331
 332
 333 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                              \
 334     bool CBNAME(size_t a, size_t b)  {                                          \
 335         bool rval = 0;                                                          \
 336         bool found;                                                             \
 337         wxPyTState* state = wxPyBeginBlockThreads();                            \
 338         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 339             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 340         wxPyEndBlockThreads(state);                                             \
 341         if (! found)                                                            \
 342             rval = PCLASS::CBNAME(a,b);                                         \
 343         return rval;                                                            \
 344     }                                                                           \
 345     bool base_##CBNAME(size_t a, size_t b) {                                    \
 346         return PCLASS::CBNAME(a,b);                                             \
 347     }
 348
 349
 350
 351 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                                   \
 352     bool CBNAME(size_t a)  {                                                    \
 353         bool rval = 0;                                                          \
 354         bool found;                                                             \
 355         wxPyTState* state = wxPyBeginBlockThreads();                            \
 356         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 357             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
 358         wxPyEndBlockThreads(state);                                             \
 359         if (! found)                                                            \
 360             rval = PCLASS::CBNAME(a);                                           \
 361         return rval;                                                            \
 362     }                                                                           \
 363     bool base_##CBNAME(size_t a) {                                              \
 364         return PCLASS::CBNAME(a);                                               \
 365     }
 366
 367
 368
 369 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                                   \
 370     wxString CBNAME(int a) {                                                    \
 371         bool found;                                                             \
 372         wxPyTState* state = wxPyBeginBlockThreads();                            \
 373         wxString rval;                                                          \
 374         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 375             PyObject* ro;                                                       \
 376             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));     \
 377             if (ro) {                                                           \
 378                 PyObject* str = PyObject_Str(ro);                               \
 379                 rval = PyString_AsString(str);                                  \
 380                 Py_DECREF(ro);   Py_DECREF(str);                                \
 381             }                                                                   \
 382         }                                                                       \
 383         wxPyEndBlockThreads(state);                                             \
 384         if (! found)                                                            \
 385             rval = PCLASS::CBNAME(a);                                           \
 386         return rval;                                                            \
 387     }                                                                           \
 388     wxString base_##CBNAME(int a) {                                             \
 389         return PCLASS::CBNAME(a);                                               \
 390     }
 391
 392
 393
 394 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                                   \
 395     void CBNAME(int a, const wxString& c)  {                                    \
 396         bool found;                                                             \
 397         wxPyTState* state = wxPyBeginBlockThreads();                            \
 398         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 399             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(is)", a,c.c_str())); \
 400         wxPyEndBlockThreads(state);                                             \
 401         if (! found)                                                            \
 402             PCLASS::CBNAME(a,c);                                                \
 403     }                                                                           \
 404     void base_##CBNAME(int a, const wxString& c) {                              \
 405         PCLASS::CBNAME(a,c);                                                    \
 406     }
 407
 408
 409
 410
 411 #define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                        \
 412     bool CBNAME()  {                                                            \
 413         bool rval = 0;                                                          \
 414         bool found;                                                             \
 415         wxPyTState* state = wxPyBeginBlockThreads();                            \
 416         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 417             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
 418         wxPyEndBlockThreads(state);                                             \
 419         if (! found)                                                            \
 420             rval = PCLASS::CBNAME();                                            \
 421         return rval;                                                            \
 422     }                                                                           \
 423     bool base_##CBNAME() {                                                      \
 424         return PCLASS::CBNAME();                                                \
 425     }
 426
 427
 428
 429 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                                    \
 430     void CBNAME(size_t a, int b)  {                                             \
 431         bool found;                                                             \
 432         wxPyTState* state = wxPyBeginBlockThreads();                            \
 433         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 434             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));         \
 435         wxPyEndBlockThreads(state);                                             \
 436         if (! found)                                                            \
 437             PCLASS::CBNAME(a,b);                                                \
 438     }                                                                           \
 439     void base_##CBNAME(size_t a, int b) {                                       \
 440         PCLASS::CBNAME(a,b);                                                    \
 441     }
 442
 443
 444
 445
 446 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                                  \
 447     void CBNAME(int a, int b, long c)  {                                        \
 448         bool found;                                                             \
 449         wxPyTState* state = wxPyBeginBlockThreads();                            \
 450         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 451             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
 452         wxPyEndBlockThreads(state);                                             \
 453         if (! found)                                                            \
 454             PCLASS::CBNAME(a,b,c);                                              \
 455     }                                                                           \
 456     void base_##CBNAME(int a, int b, long c) {                                  \
 457         PCLASS::CBNAME(a,b,c);                                                  \
 458     }
 459
 460
 461
 462
 463 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                                \
 464     void CBNAME(int a, int b, double c)  {                                      \
 465         bool found;                                                             \
 466         wxPyTState* state = wxPyBeginBlockThreads();                            \
 467         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 468             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));      \
 469         wxPyEndBlockThreads(state);                                             \
 470         if (! found)                                                            \
 471             PCLASS::CBNAME(a,b,c);                                              \
 472     }                                                                           \
 473     void base_##CBNAME(int a, int b, double c) {                                \
 474         PCLASS::CBNAME(a,b,c);                                                  \
 475     }
 476
 477
 478
 479 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                                  \
 480     void CBNAME(int a, int b, bool c)  {                                        \
 481         bool found;                                                             \
 482         wxPyTState* state = wxPyBeginBlockThreads();                            \
 483         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 484             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
 485         wxPyEndBlockThreads(state);                                             \
 486         if (! found)                                                            \
 487             PCLASS::CBNAME(a,b,c);                                              \
 488     }                                                                           \
 489     void base_##CBNAME(int a, int b, bool c) {                                  \
 490         PCLASS::CBNAME(a,b,c);                                                  \
 491     }
 492
 493
 494
 495
 496
 497 class wxPyGridCellRenderer : public wxGridCellRenderer
 498 {
 499 public:
 500     wxPyGridCellRenderer() : wxGridCellRenderer() {};
 501
 502     // Implement Python callback aware virtual methods
 503     void Draw(wxGrid& grid, wxGridCellAttr& attr,
 504               wxDC& dc, const wxRect& rect,
 505               int row, int col, bool isSelected) {
 506         wxPyTState* state = wxPyBeginBlockThreads();
 507         if (wxPyCBH_findCallback(m_myInst, "Draw")) {
 508             wxPyCBH_callCallback(m_myInst,
 509                 Py_BuildValue("(OOOOiii)",
 510                               wxPyConstructObject((void*)&grid, "wxGrid", 0),
 511                               wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
 512                               wxPyConstructObject((void*)&dc,   "wxDC", 0),
 513                               wxPyConstructObject((void*)&rect, "wxRect", 0),
 514                               row, col, isSelected));
 515         }
 516         wxPyEndBlockThreads(state);
 517     }
 518
 519     wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
 520                        int row, int col) {
 521         wxSize rval;
 522         wxPyTState* state = wxPyBeginBlockThreads();
 523         if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
 524             PyObject* ro;
 525             wxSize*   ptr;
 526             ro = wxPyCBH_callCallbackObj(m_myInst,
 527                 Py_BuildValue("(OOOii)",
 528                               wxPyConstructObject((void*)&grid, "wxGrid", 0),
 529                               wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
 530                               wxPyConstructObject((void*)&dc,   "wxDC", 0),
 531                               row, col));
 532             if (ro) {
 533                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
 534                     rval = *ptr;
 535                 Py_DECREF(ro);
 536             }
 537         }
 538         wxPyEndBlockThreads(state);
 539         return rval;
 540     }
 541
 542
 543     wxGridCellRenderer *Clone() const {
 544         wxGridCellRenderer* rval = NULL;
 545         wxPyTState* state = wxPyBeginBlockThreads();
 546         if (wxPyCBH_findCallback(m_myInst, "Clone")) {
 547             PyObject* ro;
 548             wxGridCellRenderer* ptr;
 549             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 550             if (ro) {
 551                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellRenderer_p"))
 552                     rval = ptr;
 553                 Py_DECREF(ro);
 554             }
 555         }
 556         wxPyEndBlockThreads(state);
 557         return rval;
 558     }
 559
 560     DEC_PYCALLBACK__STRING(SetParameters);
 561
 562     PYPRIVATE;
 563 };
 564
 565 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
 566
 567
 568 class wxPyGridCellEditor : public wxGridCellEditor
 569 {
 570 public:
 571     wxPyGridCellEditor() : wxGridCellEditor() {}
 572
 573     void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
 574         wxPyTState* state = wxPyBeginBlockThreads();
 575         if (wxPyCBH_findCallback(m_myInst, "Create")) {
 576             wxPyCBH_callCallback(m_myInst,
 577                 Py_BuildValue("(OiO)",
 578                               wxPyConstructObject((void*)parent, "wxWindow", 0),
 579                               id,
 580                               wxPyConstructObject((void*)evtHandler, "wxEvtHandler", 0)));
 581         }
 582         wxPyEndBlockThreads(state);
 583     }
 584
 585
 586     void BeginEdit(int row, int col, wxGrid* grid) {
 587         wxPyTState* state = wxPyBeginBlockThreads();
 588         if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
 589             wxPyCBH_callCallback(m_myInst,
 590                 Py_BuildValue("(iiO)", row, col,
 591                               wxPyConstructObject((void*)grid, "wxGrid", 0)));
 592         }
 593         wxPyEndBlockThreads(state);
 594     }
 595
 596
 597     bool EndEdit(int row, int col, wxGrid* grid) {
 598         bool rv = FALSE;
 599         wxPyTState* state = wxPyBeginBlockThreads();
 600         if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
 601             rv = wxPyCBH_callCallback(m_myInst,
 602                 Py_BuildValue("(iiO)", row, col,
 603                               wxPyConstructObject((void*)grid, "wxGrid", 0)));
 604         }
 605         wxPyEndBlockThreads(state);
 606         return rv;
 607     }
 608
 609
 610     wxGridCellEditor*Clone() const {
 611         wxGridCellEditor* rval = NULL;
 612         wxPyTState* state = wxPyBeginBlockThreads();
 613         if (wxPyCBH_findCallback(m_myInst, "Clone")) {
 614             PyObject* ro;
 615             wxGridCellEditor* ptr;
 616             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 617             if (ro) {
 618                 if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellEditor_p"))
 619                     rval = ptr;
 620                 Py_DECREF(ro);
 621             }
 622         }
 623         wxPyEndBlockThreads(state);
 624         return rval;
 625     }
 626
 627
 628     void Show(bool show, wxGridCellAttr *attr) {
 629         bool found;
 630         wxPyTState* state = wxPyBeginBlockThreads();
 631         if ((found = wxPyCBH_findCallback(m_myInst, "Show")))
 632             wxPyCBH_callCallback(m_myInst,
 633                 Py_BuildValue("(iO)", show,
 634                               wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
 635         wxPyEndBlockThreads(state);
 636         if (! found)
 637             wxGridCellEditor::Show(show, attr);
 638     }
 639     void base_Show(bool show, wxGridCellAttr *attr) {
 640         wxGridCellEditor::Show(show, attr);
 641     }
 642
 643
 644     void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
 645         bool found;                                                             \
 646         wxPyTState* state = wxPyBeginBlockThreads();
 647         if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)")))
 648             wxPyCBH_callCallback(m_myInst,
 649                 Py_BuildValue("(OO)",
 650                               wxPyConstructObject((void*)&rectCell, "wxRect", 0),
 651                               wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
 652         wxPyEndBlockThreads(state);
 653         if (! found)
 654             wxGridCellEditor::PaintBackground(rectCell, attr);
 655     }
 656     void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
 657         wxGridCellEditor::PaintBackground(rectCell, attr);
 658     }
 659
 660
 661     DEC_PYCALLBACK___pure(Reset);
 662     DEC_PYCALLBACK__constany(SetSize, wxRect);
 663     DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
 664     DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
 665     DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
 666     DEC_PYCALLBACK__(StartingClick);
 667     DEC_PYCALLBACK__(Destroy);
 668     DEC_PYCALLBACK__STRING(SetParameters);
 669
 670     PYPRIVATE;
 671 };
 672
 673
 674 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
 675 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
 676 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
 677 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
 678 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
 679 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
 680 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
 681 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
 682
 683
 684 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
 685 {
 686 public:
 687     wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
 688
 689     PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
 690     PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
 691     PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
 692     PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
 693
 694     PYPRIVATE;
 695 };
 696
 697 class wxPyGridTableBase : public wxGridTableBase
 698 {
 699 public:
 700     wxPyGridTableBase() : wxGridTableBase() {}
 701
 702     PYCALLBACK_INT__pure(GetNumberRows);
 703     PYCALLBACK_INT__pure(GetNumberCols);
 704     PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
 705     PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
 706     PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
 707     PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
 708     PYCALLBACK__(wxGridTableBase, Clear);
 709     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
 710     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
 711     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
 712     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
 713     PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
 714     PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
 715     PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
 716     PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
 717     PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
 718     PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
 719     PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
 720     PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
 721     PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
 722     PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
 723     PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
 724
 725
 726     wxString GetValue(int row, int col) {
 727         wxPyTState* state = wxPyBeginBlockThreads();
 728         wxString rval;
 729         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
 730             PyObject* ro;
 731             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
 732             if (ro) {
 733                 PyObject* str = PyObject_Str(ro);
 734                 rval = PyString_AsString(str);
 735                 Py_DECREF(ro);
 736                 Py_DECREF(str);
 737             }
 738         }
 739         wxPyEndBlockThreads(state);
 740         return rval;
 741     }
 742
 743     void SetValue(int row, int col, const wxString& val) {
 744         wxPyTState* state = wxPyBeginBlockThreads();
 745         if (wxPyCBH_findCallback(m_myInst, "SetValue"))
 746             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",row,col,val.c_str()));
 747         wxPyEndBlockThreads(state);
 748     }
 749
 750
 751     // Map the Get/Set methods for the standard non-string types to
 752     // the GetValue and SetValue python methods.
 753     long GetValueAsLong( int row, int col ) {
 754         long rval = 0;
 755         wxPyTState* state = wxPyBeginBlockThreads();
 756         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
 757             PyObject* ro;
 758             PyObject* num;
 759             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
 760             if (ro && PyNumber_Check(ro)) {
 761                 num = PyNumber_Int(ro);
 762                 if (num) {
 763                     rval = PyInt_AsLong(num);
 764                     Py_DECREF(num);
 765                 }
 766                 Py_DECREF(ro);
 767             }
 768         }
 769         wxPyEndBlockThreads(state);
 770         return rval;
 771     }
 772
 773     double GetValueAsDouble( int row, int col ) {
 774         double rval = 0.0;
 775         wxPyTState* state = wxPyBeginBlockThreads();
 776         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
 777             PyObject* ro;
 778             PyObject* num;
 779             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
 780             if (ro && PyNumber_Check(ro)) {
 781                 num = PyNumber_Float(ro);
 782                 if (num) {
 783                     rval = PyFloat_AsDouble(num);
 784                     Py_DECREF(num);
 785                 }
 786                 Py_DECREF(ro);
 787             }
 788         }
 789         wxPyEndBlockThreads(state);
 790         return rval;
 791     }
 792
 793     bool GetValueAsBool( int row, int col ) {
 794         return (bool)GetValueAsLong(row, col);
 795     }
 796
 797     void SetValueAsLong( int row, int col, long value ) {
 798         wxPyTState* state = wxPyBeginBlockThreads();
 799         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
 800             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
 801         }
 802         wxPyEndBlockThreads(state);
 803     }
 804
 805     void SetValueAsDouble( int row, int col, double value ) {
 806         wxPyTState* state = wxPyBeginBlockThreads();
 807         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
 808             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
 809         }
 810         wxPyEndBlockThreads(state);
 811     }
 812
 813     void SetValueAsBool( int row, int col, bool value ) {
 814         SetValueAsLong( row, col, (long)value );
 815     }
 816
 817
 818     PYPRIVATE;
 819 };
 820
 821 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
 822
 823     // If source is an object instance then it may already be the right type
 824     if (PyInstance_Check(source)) {
 825         wxGridCellCoords* ptr;
 826         if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxGridCellCoords_p"))
 827             goto error;
 828         *obj = ptr;
 829         return TRUE;
 830     }
 831     // otherwise a 2-tuple of integers is expected
 832     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
 833         PyObject* o1 = PySequence_GetItem(source, 0);
 834         PyObject* o2 = PySequence_GetItem(source, 1);
 835         **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
 836         return TRUE;
 837     }
 838
 839  error:
 840     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
 841     return FALSE;
 842 }
 843
 844 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
 845 #ifdef __cplusplus
 846 extern "C" {
 847 #endif
 848 static int _wrap_wxGridNoCellCoords_set(PyObject *val) {
 849
 850     PyErr_SetString(PyExc_TypeError,"Variable wxGridNoCellCoords is read-only.");
 851     return 1;
 852 }
 853
 854 static PyObject *_wrap_wxGridNoCellCoords_get() {
 855     PyObject * pyobj;
 856     char ptemp[128];
 857
 858     SWIG_MakePtr(ptemp,(char *) &wxGridNoCellCoords,"_wxGridCellCoords_p");
 859     pyobj = PyString_FromString(ptemp);
 860     return pyobj;
 861 }
 862
 863 static int _wrap_wxGridNoCellRect_set(PyObject *val) {
 864
 865     PyErr_SetString(PyExc_TypeError,"Variable wxGridNoCellRect is read-only.");
 866     return 1;
 867 }
 868
 869 static PyObject *_wrap_wxGridNoCellRect_get() {
 870     PyObject * pyobj;
 871     char ptemp[128];
 872
 873     SWIG_MakePtr(ptemp,(char *) &wxGridNoCellRect,"_wxRect_p");
 874     pyobj = PyString_FromString(ptemp);
 875     return pyobj;
 876 }
 877
 878 #define wxGridCellRenderer_SetParameters(_swigobj,_swigarg0)  (_swigobj->SetParameters(_swigarg0))
 879 static PyObject *_wrap_wxGridCellRenderer_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
 880     PyObject * _resultobj;
 881     wxGridCellRenderer * _arg0;
 882     wxString * _arg1;
 883     PyObject * _argo0 = 0;
 884     PyObject * _obj1 = 0;
 885     char *_kwnames[] = { "self","params", NULL };
 886
 887     self = self;
 888     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellRenderer_SetParameters",_kwnames,&_argo0,&_obj1))
 889         return NULL;
 890     if (_argo0) {
 891         if (_argo0 == Py_None) { _arg0 = NULL; }
 892         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
 893             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_SetParameters. Expected _wxGridCellRenderer_p.");
 894         return NULL;
 895         }
 896     }
 897 {
 898 #if PYTHON_API_VERSION >= 1009
 899     char* tmpPtr; int tmpSize;
 900     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
 901         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 902         return NULL;
 903     }
 904     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
 905         return NULL;
 906     _arg1 = new wxString(tmpPtr, tmpSize);
 907 #else
 908     if (!PyString_Check(_obj1)) {
 909         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
 910         return NULL;
 911     }
 912     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
 913 #endif
 914 }
 915 {
 916     wxPy_BEGIN_ALLOW_THREADS;
 917         wxGridCellRenderer_SetParameters(_arg0,*_arg1);
 918
 919     wxPy_END_ALLOW_THREADS;
 920     if (PyErr_Occurred()) return NULL;
 921 }    Py_INCREF(Py_None);
 922     _resultobj = Py_None;
 923 {
 924     if (_obj1)
 925         delete _arg1;
 926 }
 927     return _resultobj;
 928 }
 929
 930 #define wxGridCellRenderer_IncRef(_swigobj)  (_swigobj->IncRef())
 931 static PyObject *_wrap_wxGridCellRenderer_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) {
 932     PyObject * _resultobj;
 933     wxGridCellRenderer * _arg0;
 934     PyObject * _argo0 = 0;
 935     char *_kwnames[] = { "self", NULL };
 936
 937     self = self;
 938     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_IncRef",_kwnames,&_argo0))
 939         return NULL;
 940     if (_argo0) {
 941         if (_argo0 == Py_None) { _arg0 = NULL; }
 942         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
 943             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_IncRef. Expected _wxGridCellRenderer_p.");
 944         return NULL;
 945         }
 946     }
 947 {
 948     wxPy_BEGIN_ALLOW_THREADS;
 949         wxGridCellRenderer_IncRef(_arg0);
 950
 951     wxPy_END_ALLOW_THREADS;
 952     if (PyErr_Occurred()) return NULL;
 953 }    Py_INCREF(Py_None);
 954     _resultobj = Py_None;
 955     return _resultobj;
 956 }
 957
 958 #define wxGridCellRenderer_DecRef(_swigobj)  (_swigobj->DecRef())
 959 static PyObject *_wrap_wxGridCellRenderer_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) {
 960     PyObject * _resultobj;
 961     wxGridCellRenderer * _arg0;
 962     PyObject * _argo0 = 0;
 963     char *_kwnames[] = { "self", NULL };
 964
 965     self = self;
 966     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_DecRef",_kwnames,&_argo0))
 967         return NULL;
 968     if (_argo0) {
 969         if (_argo0 == Py_None) { _arg0 = NULL; }
 970         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
 971             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_DecRef. Expected _wxGridCellRenderer_p.");
 972         return NULL;
 973         }
 974     }
 975 {
 976     wxPy_BEGIN_ALLOW_THREADS;
 977         wxGridCellRenderer_DecRef(_arg0);
 978
 979     wxPy_END_ALLOW_THREADS;
 980     if (PyErr_Occurred()) return NULL;
 981 }    Py_INCREF(Py_None);
 982     _resultobj = Py_None;
 983     return _resultobj;
 984 }
 985
 986 #define wxGridCellRenderer_Draw(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6)  (_swigobj->Draw(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5,_swigarg6))
 987 static PyObject *_wrap_wxGridCellRenderer_Draw(PyObject *self, PyObject *args, PyObject *kwargs) {
 988     PyObject * _resultobj;
 989     wxGridCellRenderer * _arg0;
 990     wxGrid * _arg1;
 991     wxGridCellAttr * _arg2;
 992     wxDC * _arg3;
 993     wxRect * _arg4;
 994     int  _arg5;
 995     int  _arg6;
 996     bool  _arg7;
 997     PyObject * _argo0 = 0;
 998     PyObject * _argo1 = 0;
 999     PyObject * _argo2 = 0;
1000     PyObject * _argo3 = 0;
1001     wxRect  temp;
1002     PyObject * _obj4 = 0;
1003     int tempbool7;
1004     char *_kwnames[] = { "self","grid","attr","dc","rect","row","col","isSelected", NULL };
1005
1006     self = self;
1007     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOOiii:wxGridCellRenderer_Draw",_kwnames,&_argo0,&_argo1,&_argo2,&_argo3,&_obj4,&_arg5,&_arg6,&tempbool7))
1008         return NULL;
1009     if (_argo0) {
1010         if (_argo0 == Py_None) { _arg0 = NULL; }
1011         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
1012             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_Draw. Expected _wxGridCellRenderer_p.");
1013         return NULL;
1014         }
1015     }
1016     if (_argo1) {
1017         if (_argo1 == Py_None) { _arg1 = NULL; }
1018         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
1019             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellRenderer_Draw. Expected _wxGrid_p.");
1020         return NULL;
1021         }
1022     }
1023     if (_argo2) {
1024         if (_argo2 == Py_None) { _arg2 = NULL; }
1025         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
1026             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellRenderer_Draw. Expected _wxGridCellAttr_p.");
1027         return NULL;
1028         }
1029     }
1030     if (_argo3) {
1031         if (_argo3 == Py_None) { _arg3 = NULL; }
1032         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxDC_p")) {
1033             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellRenderer_Draw. Expected _wxDC_p.");
1034         return NULL;
1035         }
1036     }
1037 {
1038     _arg4 = &temp;
1039     if (! wxRect_helper(_obj4, &_arg4))
1040         return NULL;
1041 }
1042     _arg7 = (bool ) tempbool7;
1043 {
1044     wxPy_BEGIN_ALLOW_THREADS;
1045         wxGridCellRenderer_Draw(_arg0,*_arg1,*_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7);
1046
1047     wxPy_END_ALLOW_THREADS;
1048     if (PyErr_Occurred()) return NULL;
1049 }    Py_INCREF(Py_None);
1050     _resultobj = Py_None;
1051     return _resultobj;
1052 }
1053
1054 #define wxGridCellRenderer_GetBestSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->GetBestSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
1055 static PyObject *_wrap_wxGridCellRenderer_GetBestSize(PyObject *self, PyObject *args, PyObject *kwargs) {
1056     PyObject * _resultobj;
1057     wxSize * _result;
1058     wxGridCellRenderer * _arg0;
1059     wxGrid * _arg1;
1060     wxGridCellAttr * _arg2;
1061     wxDC * _arg3;
1062     int  _arg4;
1063     int  _arg5;
1064     PyObject * _argo0 = 0;
1065     PyObject * _argo1 = 0;
1066     PyObject * _argo2 = 0;
1067     PyObject * _argo3 = 0;
1068     char *_kwnames[] = { "self","grid","attr","dc","row","col", NULL };
1069     char _ptemp[128];
1070
1071     self = self;
1072     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOOii:wxGridCellRenderer_GetBestSize",_kwnames,&_argo0,&_argo1,&_argo2,&_argo3,&_arg4,&_arg5))
1073         return NULL;
1074     if (_argo0) {
1075         if (_argo0 == Py_None) { _arg0 = NULL; }
1076         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
1077             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_GetBestSize. Expected _wxGridCellRenderer_p.");
1078         return NULL;
1079         }
1080     }
1081     if (_argo1) {
1082         if (_argo1 == Py_None) { _arg1 = NULL; }
1083         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGrid_p")) {
1084             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellRenderer_GetBestSize. Expected _wxGrid_p.");
1085         return NULL;
1086         }
1087     }
1088     if (_argo2) {
1089         if (_argo2 == Py_None) { _arg2 = NULL; }
1090         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
1091             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellRenderer_GetBestSize. Expected _wxGridCellAttr_p.");
1092         return NULL;
1093         }
1094     }
1095     if (_argo3) {
1096         if (_argo3 == Py_None) { _arg3 = NULL; }
1097         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxDC_p")) {
1098             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellRenderer_GetBestSize. Expected _wxDC_p.");
1099         return NULL;
1100         }
1101     }
1102 {
1103     wxPy_BEGIN_ALLOW_THREADS;
1104         _result = new wxSize (wxGridCellRenderer_GetBestSize(_arg0,*_arg1,*_arg2,*_arg3,_arg4,_arg5));
1105
1106     wxPy_END_ALLOW_THREADS;
1107     if (PyErr_Occurred()) return NULL;
1108 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxSize_p");
1109     _resultobj = Py_BuildValue("s",_ptemp);
1110     return _resultobj;
1111 }
1112
1113 #define wxGridCellRenderer_Clone(_swigobj)  (_swigobj->Clone())
1114 static PyObject *_wrap_wxGridCellRenderer_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
1115     PyObject * _resultobj;
1116     wxGridCellRenderer * _result;
1117     wxGridCellRenderer * _arg0;
1118     PyObject * _argo0 = 0;
1119     char *_kwnames[] = { "self", NULL };
1120     char _ptemp[128];
1121
1122     self = self;
1123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellRenderer_Clone",_kwnames,&_argo0))
1124         return NULL;
1125     if (_argo0) {
1126         if (_argo0 == Py_None) { _arg0 = NULL; }
1127         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellRenderer_p")) {
1128             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellRenderer_Clone. Expected _wxGridCellRenderer_p.");
1129         return NULL;
1130         }
1131     }
1132 {
1133     wxPy_BEGIN_ALLOW_THREADS;
1134         _result = (wxGridCellRenderer *)wxGridCellRenderer_Clone(_arg0);
1135
1136     wxPy_END_ALLOW_THREADS;
1137     if (PyErr_Occurred()) return NULL;
1138 }    if (_result) {
1139         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
1140         _resultobj = Py_BuildValue("s",_ptemp);
1141     } else {
1142         Py_INCREF(Py_None);
1143         _resultobj = Py_None;
1144     }
1145     return _resultobj;
1146 }
1147
1148 static void *SwigwxPyGridCellRendererTowxGridCellRenderer(void *ptr) {
1149     wxPyGridCellRenderer *src;
1150     wxGridCellRenderer *dest;
1151     src = (wxPyGridCellRenderer *) ptr;
1152     dest = (wxGridCellRenderer *) src;
1153     return (void *) dest;
1154 }
1155
1156 #define new_wxPyGridCellRenderer() (new wxPyGridCellRenderer())
1157 static PyObject *_wrap_new_wxPyGridCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1158     PyObject * _resultobj;
1159     wxPyGridCellRenderer * _result;
1160     char *_kwnames[] = {  NULL };
1161     char _ptemp[128];
1162
1163     self = self;
1164     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellRenderer",_kwnames))
1165         return NULL;
1166 {
1167     wxPy_BEGIN_ALLOW_THREADS;
1168         _result = (wxPyGridCellRenderer *)new_wxPyGridCellRenderer();
1169
1170     wxPy_END_ALLOW_THREADS;
1171     if (PyErr_Occurred()) return NULL;
1172 }    if (_result) {
1173         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellRenderer_p");
1174         _resultobj = Py_BuildValue("s",_ptemp);
1175     } else {
1176         Py_INCREF(Py_None);
1177         _resultobj = Py_None;
1178     }
1179     return _resultobj;
1180 }
1181
1182 #define wxPyGridCellRenderer__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
1183 static PyObject *_wrap_wxPyGridCellRenderer__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
1184     PyObject * _resultobj;
1185     wxPyGridCellRenderer * _arg0;
1186     PyObject * _arg1;
1187     PyObject * _arg2;
1188     PyObject * _argo0 = 0;
1189     PyObject * _obj1 = 0;
1190     PyObject * _obj2 = 0;
1191     char *_kwnames[] = { "self","self","_class", NULL };
1192
1193     self = self;
1194     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellRenderer__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
1195         return NULL;
1196     if (_argo0) {
1197         if (_argo0 == Py_None) { _arg0 = NULL; }
1198         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellRenderer_p")) {
1199             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellRenderer__setCallbackInfo. Expected _wxPyGridCellRenderer_p.");
1200         return NULL;
1201         }
1202     }
1203 {
1204   _arg1 = _obj1;
1205 }
1206 {
1207   _arg2 = _obj2;
1208 }
1209 {
1210     wxPy_BEGIN_ALLOW_THREADS;
1211         wxPyGridCellRenderer__setCallbackInfo(_arg0,_arg1,_arg2);
1212
1213     wxPy_END_ALLOW_THREADS;
1214     if (PyErr_Occurred()) return NULL;
1215 }    Py_INCREF(Py_None);
1216     _resultobj = Py_None;
1217     return _resultobj;
1218 }
1219
1220 #define wxPyGridCellRenderer_base_SetParameters(_swigobj,_swigarg0)  (_swigobj->base_SetParameters(_swigarg0))
1221 static PyObject *_wrap_wxPyGridCellRenderer_base_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
1222     PyObject * _resultobj;
1223     wxPyGridCellRenderer * _arg0;
1224     wxString * _arg1;
1225     PyObject * _argo0 = 0;
1226     PyObject * _obj1 = 0;
1227     char *_kwnames[] = { "self","params", NULL };
1228
1229     self = self;
1230     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellRenderer_base_SetParameters",_kwnames,&_argo0,&_obj1))
1231         return NULL;
1232     if (_argo0) {
1233         if (_argo0 == Py_None) { _arg0 = NULL; }
1234         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellRenderer_p")) {
1235             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellRenderer_base_SetParameters. Expected _wxPyGridCellRenderer_p.");
1236         return NULL;
1237         }
1238     }
1239 {
1240 #if PYTHON_API_VERSION >= 1009
1241     char* tmpPtr; int tmpSize;
1242     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1243         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1244         return NULL;
1245     }
1246     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1247         return NULL;
1248     _arg1 = new wxString(tmpPtr, tmpSize);
1249 #else
1250     if (!PyString_Check(_obj1)) {
1251         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1252         return NULL;
1253     }
1254     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1255 #endif
1256 }
1257 {
1258     wxPy_BEGIN_ALLOW_THREADS;
1259         wxPyGridCellRenderer_base_SetParameters(_arg0,*_arg1);
1260
1261     wxPy_END_ALLOW_THREADS;
1262     if (PyErr_Occurred()) return NULL;
1263 }    Py_INCREF(Py_None);
1264     _resultobj = Py_None;
1265 {
1266     if (_obj1)
1267         delete _arg1;
1268 }
1269     return _resultobj;
1270 }
1271
1272 static void *SwigwxGridCellStringRendererTowxGridCellRenderer(void *ptr) {
1273     wxGridCellStringRenderer *src;
1274     wxGridCellRenderer *dest;
1275     src = (wxGridCellStringRenderer *) ptr;
1276     dest = (wxGridCellRenderer *) src;
1277     return (void *) dest;
1278 }
1279
1280 #define new_wxGridCellStringRenderer() (new wxGridCellStringRenderer())
1281 static PyObject *_wrap_new_wxGridCellStringRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1282     PyObject * _resultobj;
1283     wxGridCellStringRenderer * _result;
1284     char *_kwnames[] = {  NULL };
1285     char _ptemp[128];
1286
1287     self = self;
1288     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellStringRenderer",_kwnames))
1289         return NULL;
1290 {
1291     wxPy_BEGIN_ALLOW_THREADS;
1292         _result = (wxGridCellStringRenderer *)new_wxGridCellStringRenderer();
1293
1294     wxPy_END_ALLOW_THREADS;
1295     if (PyErr_Occurred()) return NULL;
1296 }    if (_result) {
1297         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellStringRenderer_p");
1298         _resultobj = Py_BuildValue("s",_ptemp);
1299     } else {
1300         Py_INCREF(Py_None);
1301         _resultobj = Py_None;
1302     }
1303     return _resultobj;
1304 }
1305
1306 static void *SwigwxGridCellNumberRendererTowxGridCellStringRenderer(void *ptr) {
1307     wxGridCellNumberRenderer *src;
1308     wxGridCellStringRenderer *dest;
1309     src = (wxGridCellNumberRenderer *) ptr;
1310     dest = (wxGridCellStringRenderer *) src;
1311     return (void *) dest;
1312 }
1313
1314 static void *SwigwxGridCellNumberRendererTowxGridCellRenderer(void *ptr) {
1315     wxGridCellNumberRenderer *src;
1316     wxGridCellRenderer *dest;
1317     src = (wxGridCellNumberRenderer *) ptr;
1318     dest = (wxGridCellRenderer *) src;
1319     return (void *) dest;
1320 }
1321
1322 #define new_wxGridCellNumberRenderer() (new wxGridCellNumberRenderer())
1323 static PyObject *_wrap_new_wxGridCellNumberRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1324     PyObject * _resultobj;
1325     wxGridCellNumberRenderer * _result;
1326     char *_kwnames[] = {  NULL };
1327     char _ptemp[128];
1328
1329     self = self;
1330     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellNumberRenderer",_kwnames))
1331         return NULL;
1332 {
1333     wxPy_BEGIN_ALLOW_THREADS;
1334         _result = (wxGridCellNumberRenderer *)new_wxGridCellNumberRenderer();
1335
1336     wxPy_END_ALLOW_THREADS;
1337     if (PyErr_Occurred()) return NULL;
1338 }    if (_result) {
1339         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberRenderer_p");
1340         _resultobj = Py_BuildValue("s",_ptemp);
1341     } else {
1342         Py_INCREF(Py_None);
1343         _resultobj = Py_None;
1344     }
1345     return _resultobj;
1346 }
1347
1348 static void *SwigwxGridCellFloatRendererTowxGridCellStringRenderer(void *ptr) {
1349     wxGridCellFloatRenderer *src;
1350     wxGridCellStringRenderer *dest;
1351     src = (wxGridCellFloatRenderer *) ptr;
1352     dest = (wxGridCellStringRenderer *) src;
1353     return (void *) dest;
1354 }
1355
1356 static void *SwigwxGridCellFloatRendererTowxGridCellRenderer(void *ptr) {
1357     wxGridCellFloatRenderer *src;
1358     wxGridCellRenderer *dest;
1359     src = (wxGridCellFloatRenderer *) ptr;
1360     dest = (wxGridCellRenderer *) src;
1361     return (void *) dest;
1362 }
1363
1364 #define new_wxGridCellFloatRenderer(_swigarg0,_swigarg1) (new wxGridCellFloatRenderer(_swigarg0,_swigarg1))
1365 static PyObject *_wrap_new_wxGridCellFloatRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1366     PyObject * _resultobj;
1367     wxGridCellFloatRenderer * _result;
1368     int  _arg0 = (int ) -1;
1369     int  _arg1 = (int ) -1;
1370     char *_kwnames[] = { "width","precision", NULL };
1371     char _ptemp[128];
1372
1373     self = self;
1374     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellFloatRenderer",_kwnames,&_arg0,&_arg1))
1375         return NULL;
1376 {
1377     wxPy_BEGIN_ALLOW_THREADS;
1378         _result = (wxGridCellFloatRenderer *)new_wxGridCellFloatRenderer(_arg0,_arg1);
1379
1380     wxPy_END_ALLOW_THREADS;
1381     if (PyErr_Occurred()) return NULL;
1382 }    if (_result) {
1383         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatRenderer_p");
1384         _resultobj = Py_BuildValue("s",_ptemp);
1385     } else {
1386         Py_INCREF(Py_None);
1387         _resultobj = Py_None;
1388     }
1389     return _resultobj;
1390 }
1391
1392 #define wxGridCellFloatRenderer_GetWidth(_swigobj)  (_swigobj->GetWidth())
1393 static PyObject *_wrap_wxGridCellFloatRenderer_GetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1394     PyObject * _resultobj;
1395     int  _result;
1396     wxGridCellFloatRenderer * _arg0;
1397     PyObject * _argo0 = 0;
1398     char *_kwnames[] = { "self", NULL };
1399
1400     self = self;
1401     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellFloatRenderer_GetWidth",_kwnames,&_argo0))
1402         return NULL;
1403     if (_argo0) {
1404         if (_argo0 == Py_None) { _arg0 = NULL; }
1405         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1406             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_GetWidth. Expected _wxGridCellFloatRenderer_p.");
1407         return NULL;
1408         }
1409     }
1410 {
1411     wxPy_BEGIN_ALLOW_THREADS;
1412         _result = (int )wxGridCellFloatRenderer_GetWidth(_arg0);
1413
1414     wxPy_END_ALLOW_THREADS;
1415     if (PyErr_Occurred()) return NULL;
1416 }    _resultobj = Py_BuildValue("i",_result);
1417     return _resultobj;
1418 }
1419
1420 #define wxGridCellFloatRenderer_SetWidth(_swigobj,_swigarg0)  (_swigobj->SetWidth(_swigarg0))
1421 static PyObject *_wrap_wxGridCellFloatRenderer_SetWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
1422     PyObject * _resultobj;
1423     wxGridCellFloatRenderer * _arg0;
1424     int  _arg1;
1425     PyObject * _argo0 = 0;
1426     char *_kwnames[] = { "self","width", NULL };
1427
1428     self = self;
1429     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellFloatRenderer_SetWidth",_kwnames,&_argo0,&_arg1))
1430         return NULL;
1431     if (_argo0) {
1432         if (_argo0 == Py_None) { _arg0 = NULL; }
1433         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1434             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_SetWidth. Expected _wxGridCellFloatRenderer_p.");
1435         return NULL;
1436         }
1437     }
1438 {
1439     wxPy_BEGIN_ALLOW_THREADS;
1440         wxGridCellFloatRenderer_SetWidth(_arg0,_arg1);
1441
1442     wxPy_END_ALLOW_THREADS;
1443     if (PyErr_Occurred()) return NULL;
1444 }    Py_INCREF(Py_None);
1445     _resultobj = Py_None;
1446     return _resultobj;
1447 }
1448
1449 #define wxGridCellFloatRenderer_GetPrecision(_swigobj)  (_swigobj->GetPrecision())
1450 static PyObject *_wrap_wxGridCellFloatRenderer_GetPrecision(PyObject *self, PyObject *args, PyObject *kwargs) {
1451     PyObject * _resultobj;
1452     int  _result;
1453     wxGridCellFloatRenderer * _arg0;
1454     PyObject * _argo0 = 0;
1455     char *_kwnames[] = { "self", NULL };
1456
1457     self = self;
1458     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellFloatRenderer_GetPrecision",_kwnames,&_argo0))
1459         return NULL;
1460     if (_argo0) {
1461         if (_argo0 == Py_None) { _arg0 = NULL; }
1462         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1463             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_GetPrecision. Expected _wxGridCellFloatRenderer_p.");
1464         return NULL;
1465         }
1466     }
1467 {
1468     wxPy_BEGIN_ALLOW_THREADS;
1469         _result = (int )wxGridCellFloatRenderer_GetPrecision(_arg0);
1470
1471     wxPy_END_ALLOW_THREADS;
1472     if (PyErr_Occurred()) return NULL;
1473 }    _resultobj = Py_BuildValue("i",_result);
1474     return _resultobj;
1475 }
1476
1477 #define wxGridCellFloatRenderer_SetPrecision(_swigobj,_swigarg0)  (_swigobj->SetPrecision(_swigarg0))
1478 static PyObject *_wrap_wxGridCellFloatRenderer_SetPrecision(PyObject *self, PyObject *args, PyObject *kwargs) {
1479     PyObject * _resultobj;
1480     wxGridCellFloatRenderer * _arg0;
1481     int  _arg1;
1482     PyObject * _argo0 = 0;
1483     char *_kwnames[] = { "self","precision", NULL };
1484
1485     self = self;
1486     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellFloatRenderer_SetPrecision",_kwnames,&_argo0,&_arg1))
1487         return NULL;
1488     if (_argo0) {
1489         if (_argo0 == Py_None) { _arg0 = NULL; }
1490         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellFloatRenderer_p")) {
1491             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellFloatRenderer_SetPrecision. Expected _wxGridCellFloatRenderer_p.");
1492         return NULL;
1493         }
1494     }
1495 {
1496     wxPy_BEGIN_ALLOW_THREADS;
1497         wxGridCellFloatRenderer_SetPrecision(_arg0,_arg1);
1498
1499     wxPy_END_ALLOW_THREADS;
1500     if (PyErr_Occurred()) return NULL;
1501 }    Py_INCREF(Py_None);
1502     _resultobj = Py_None;
1503     return _resultobj;
1504 }
1505
1506 static void *SwigwxGridCellBoolRendererTowxGridCellRenderer(void *ptr) {
1507     wxGridCellBoolRenderer *src;
1508     wxGridCellRenderer *dest;
1509     src = (wxGridCellBoolRenderer *) ptr;
1510     dest = (wxGridCellRenderer *) src;
1511     return (void *) dest;
1512 }
1513
1514 #define new_wxGridCellBoolRenderer() (new wxGridCellBoolRenderer())
1515 static PyObject *_wrap_new_wxGridCellBoolRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1516     PyObject * _resultobj;
1517     wxGridCellBoolRenderer * _result;
1518     char *_kwnames[] = {  NULL };
1519     char _ptemp[128];
1520
1521     self = self;
1522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolRenderer",_kwnames))
1523         return NULL;
1524 {
1525     wxPy_BEGIN_ALLOW_THREADS;
1526         _result = (wxGridCellBoolRenderer *)new_wxGridCellBoolRenderer();
1527
1528     wxPy_END_ALLOW_THREADS;
1529     if (PyErr_Occurred()) return NULL;
1530 }    if (_result) {
1531         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolRenderer_p");
1532         _resultobj = Py_BuildValue("s",_ptemp);
1533     } else {
1534         Py_INCREF(Py_None);
1535         _resultobj = Py_None;
1536     }
1537     return _resultobj;
1538 }
1539
1540 static void *SwigwxGridCellDateTimeRendererTowxGridCellStringRenderer(void *ptr) {
1541     wxGridCellDateTimeRenderer *src;
1542     wxGridCellStringRenderer *dest;
1543     src = (wxGridCellDateTimeRenderer *) ptr;
1544     dest = (wxGridCellStringRenderer *) src;
1545     return (void *) dest;
1546 }
1547
1548 static void *SwigwxGridCellDateTimeRendererTowxGridCellRenderer(void *ptr) {
1549     wxGridCellDateTimeRenderer *src;
1550     wxGridCellRenderer *dest;
1551     src = (wxGridCellDateTimeRenderer *) ptr;
1552     dest = (wxGridCellRenderer *) src;
1553     return (void *) dest;
1554 }
1555
1556 #define new_wxGridCellDateTimeRenderer(_swigarg0,_swigarg1) (new wxGridCellDateTimeRenderer(_swigarg0,_swigarg1))
1557 static PyObject *_wrap_new_wxGridCellDateTimeRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1558     PyObject * _resultobj;
1559     wxGridCellDateTimeRenderer * _result;
1560     wxString * _arg0 = (wxString *) &"%c";
1561     wxString * _arg1 = (wxString *) &"%c";
1562     PyObject * _obj0 = 0;
1563     PyObject * _obj1 = 0;
1564     char *_kwnames[] = { "outformat","informat", NULL };
1565     char _ptemp[128];
1566
1567     self = self;
1568     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|OO:new_wxGridCellDateTimeRenderer",_kwnames,&_obj0,&_obj1))
1569         return NULL;
1570     if (_obj0)
1571 {
1572 #if PYTHON_API_VERSION >= 1009
1573     char* tmpPtr; int tmpSize;
1574     if (!PyString_Check(_obj0) && !PyUnicode_Check(_obj0)) {
1575         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1576         return NULL;
1577     }
1578     if (PyString_AsStringAndSize(_obj0, &tmpPtr, &tmpSize) == -1)
1579         return NULL;
1580     _arg0 = new wxString(tmpPtr, tmpSize);
1581 #else
1582     if (!PyString_Check(_obj0)) {
1583         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1584         return NULL;
1585     }
1586     _arg0 = new wxString(PyString_AS_STRING(_obj0), PyString_GET_SIZE(_obj0));
1587 #endif
1588 }
1589     if (_obj1)
1590 {
1591 #if PYTHON_API_VERSION >= 1009
1592     char* tmpPtr; int tmpSize;
1593     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1594         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1595         return NULL;
1596     }
1597     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1598         return NULL;
1599     _arg1 = new wxString(tmpPtr, tmpSize);
1600 #else
1601     if (!PyString_Check(_obj1)) {
1602         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1603         return NULL;
1604     }
1605     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1606 #endif
1607 }
1608 {
1609     wxPy_BEGIN_ALLOW_THREADS;
1610         _result = (wxGridCellDateTimeRenderer *)new_wxGridCellDateTimeRenderer(*_arg0,*_arg1);
1611
1612     wxPy_END_ALLOW_THREADS;
1613     if (PyErr_Occurred()) return NULL;
1614 }    if (_result) {
1615         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellDateTimeRenderer_p");
1616         _resultobj = Py_BuildValue("s",_ptemp);
1617     } else {
1618         Py_INCREF(Py_None);
1619         _resultobj = Py_None;
1620     }
1621 {
1622     if (_obj0)
1623         delete _arg0;
1624 }
1625 {
1626     if (_obj1)
1627         delete _arg1;
1628 }
1629     return _resultobj;
1630 }
1631
1632 static void *SwigwxGridCellEnumRendererTowxGridCellStringRenderer(void *ptr) {
1633     wxGridCellEnumRenderer *src;
1634     wxGridCellStringRenderer *dest;
1635     src = (wxGridCellEnumRenderer *) ptr;
1636     dest = (wxGridCellStringRenderer *) src;
1637     return (void *) dest;
1638 }
1639
1640 static void *SwigwxGridCellEnumRendererTowxGridCellRenderer(void *ptr) {
1641     wxGridCellEnumRenderer *src;
1642     wxGridCellRenderer *dest;
1643     src = (wxGridCellEnumRenderer *) ptr;
1644     dest = (wxGridCellRenderer *) src;
1645     return (void *) dest;
1646 }
1647
1648 #define new_wxGridCellEnumRenderer(_swigarg0) (new wxGridCellEnumRenderer(_swigarg0))
1649 static PyObject *_wrap_new_wxGridCellEnumRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1650     PyObject * _resultobj;
1651     wxGridCellEnumRenderer * _result;
1652     wxString * _arg0 = (wxString *) &"";
1653     PyObject * _obj0 = 0;
1654     char *_kwnames[] = { "choices", NULL };
1655     char _ptemp[128];
1656
1657     self = self;
1658     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|O:new_wxGridCellEnumRenderer",_kwnames,&_obj0))
1659         return NULL;
1660     if (_obj0)
1661 {
1662     _arg0 = wxString_LIST_helper(_obj0);
1663     if (_arg0 == NULL) {
1664         return NULL;
1665     }
1666 }
1667 {
1668     wxPy_BEGIN_ALLOW_THREADS;
1669         _result = (wxGridCellEnumRenderer *)new_wxGridCellEnumRenderer(*_arg0);
1670
1671     wxPy_END_ALLOW_THREADS;
1672     if (PyErr_Occurred()) return NULL;
1673 }    if (_result) {
1674         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumRenderer_p");
1675         _resultobj = Py_BuildValue("s",_ptemp);
1676     } else {
1677         Py_INCREF(Py_None);
1678         _resultobj = Py_None;
1679     }
1680 {
1681     delete [] _arg0;
1682 }
1683     return _resultobj;
1684 }
1685
1686 static void *SwigwxGridCellAutoWrapStringRendererTowxGridCellStringRenderer(void *ptr) {
1687     wxGridCellAutoWrapStringRenderer *src;
1688     wxGridCellStringRenderer *dest;
1689     src = (wxGridCellAutoWrapStringRenderer *) ptr;
1690     dest = (wxGridCellStringRenderer *) src;
1691     return (void *) dest;
1692 }
1693
1694 static void *SwigwxGridCellAutoWrapStringRendererTowxGridCellRenderer(void *ptr) {
1695     wxGridCellAutoWrapStringRenderer *src;
1696     wxGridCellRenderer *dest;
1697     src = (wxGridCellAutoWrapStringRenderer *) ptr;
1698     dest = (wxGridCellRenderer *) src;
1699     return (void *) dest;
1700 }
1701
1702 #define new_wxGridCellAutoWrapStringRenderer() (new wxGridCellAutoWrapStringRenderer())
1703 static PyObject *_wrap_new_wxGridCellAutoWrapStringRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
1704     PyObject * _resultobj;
1705     wxGridCellAutoWrapStringRenderer * _result;
1706     char *_kwnames[] = {  NULL };
1707     char _ptemp[128];
1708
1709     self = self;
1710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringRenderer",_kwnames))
1711         return NULL;
1712 {
1713     wxPy_BEGIN_ALLOW_THREADS;
1714         _result = (wxGridCellAutoWrapStringRenderer *)new_wxGridCellAutoWrapStringRenderer();
1715
1716     wxPy_END_ALLOW_THREADS;
1717     if (PyErr_Occurred()) return NULL;
1718 }    if (_result) {
1719         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringRenderer_p");
1720         _resultobj = Py_BuildValue("s",_ptemp);
1721     } else {
1722         Py_INCREF(Py_None);
1723         _resultobj = Py_None;
1724     }
1725     return _resultobj;
1726 }
1727
1728 #define wxGridCellEditor_IsCreated(_swigobj)  (_swigobj->IsCreated())
1729 static PyObject *_wrap_wxGridCellEditor_IsCreated(PyObject *self, PyObject *args, PyObject *kwargs) {
1730     PyObject * _resultobj;
1731     bool  _result;
1732     wxGridCellEditor * _arg0;
1733     PyObject * _argo0 = 0;
1734     char *_kwnames[] = { "self", NULL };
1735
1736     self = self;
1737     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_IsCreated",_kwnames,&_argo0))
1738         return NULL;
1739     if (_argo0) {
1740         if (_argo0 == Py_None) { _arg0 = NULL; }
1741         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1742             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IsCreated. Expected _wxGridCellEditor_p.");
1743         return NULL;
1744         }
1745     }
1746 {
1747     wxPy_BEGIN_ALLOW_THREADS;
1748         _result = (bool )wxGridCellEditor_IsCreated(_arg0);
1749
1750     wxPy_END_ALLOW_THREADS;
1751     if (PyErr_Occurred()) return NULL;
1752 }    _resultobj = Py_BuildValue("i",_result);
1753     return _resultobj;
1754 }
1755
1756 #define wxGridCellEditor_GetControl(_swigobj)  (_swigobj->GetControl())
1757 static PyObject *_wrap_wxGridCellEditor_GetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
1758     PyObject * _resultobj;
1759     wxControl * _result;
1760     wxGridCellEditor * _arg0;
1761     PyObject * _argo0 = 0;
1762     char *_kwnames[] = { "self", NULL };
1763
1764     self = self;
1765     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_GetControl",_kwnames,&_argo0))
1766         return NULL;
1767     if (_argo0) {
1768         if (_argo0 == Py_None) { _arg0 = NULL; }
1769         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1770             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_GetControl. Expected _wxGridCellEditor_p.");
1771         return NULL;
1772         }
1773     }
1774 {
1775     wxPy_BEGIN_ALLOW_THREADS;
1776         _result = (wxControl *)wxGridCellEditor_GetControl(_arg0);
1777
1778     wxPy_END_ALLOW_THREADS;
1779     if (PyErr_Occurred()) return NULL;
1780 }{ _resultobj = wxPyMake_wxObject(_result); }
1781     return _resultobj;
1782 }
1783
1784 #define wxGridCellEditor_SetControl(_swigobj,_swigarg0)  (_swigobj->SetControl(_swigarg0))
1785 static PyObject *_wrap_wxGridCellEditor_SetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
1786     PyObject * _resultobj;
1787     wxGridCellEditor * _arg0;
1788     wxControl * _arg1;
1789     PyObject * _argo0 = 0;
1790     PyObject * _argo1 = 0;
1791     char *_kwnames[] = { "self","control", NULL };
1792
1793     self = self;
1794     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_SetControl",_kwnames,&_argo0,&_argo1))
1795         return NULL;
1796     if (_argo0) {
1797         if (_argo0 == Py_None) { _arg0 = NULL; }
1798         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1799             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_SetControl. Expected _wxGridCellEditor_p.");
1800         return NULL;
1801         }
1802     }
1803     if (_argo1) {
1804         if (_argo1 == Py_None) { _arg1 = NULL; }
1805         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxControl_p")) {
1806             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_SetControl. Expected _wxControl_p.");
1807         return NULL;
1808         }
1809     }
1810 {
1811     wxPy_BEGIN_ALLOW_THREADS;
1812         wxGridCellEditor_SetControl(_arg0,_arg1);
1813
1814     wxPy_END_ALLOW_THREADS;
1815     if (PyErr_Occurred()) return NULL;
1816 }    Py_INCREF(Py_None);
1817     _resultobj = Py_None;
1818     return _resultobj;
1819 }
1820
1821 #define wxGridCellEditor_SetParameters(_swigobj,_swigarg0)  (_swigobj->SetParameters(_swigarg0))
1822 static PyObject *_wrap_wxGridCellEditor_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
1823     PyObject * _resultobj;
1824     wxGridCellEditor * _arg0;
1825     wxString * _arg1;
1826     PyObject * _argo0 = 0;
1827     PyObject * _obj1 = 0;
1828     char *_kwnames[] = { "self","params", NULL };
1829
1830     self = self;
1831     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_SetParameters",_kwnames,&_argo0,&_obj1))
1832         return NULL;
1833     if (_argo0) {
1834         if (_argo0 == Py_None) { _arg0 = NULL; }
1835         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1836             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_SetParameters. Expected _wxGridCellEditor_p.");
1837         return NULL;
1838         }
1839     }
1840 {
1841 #if PYTHON_API_VERSION >= 1009
1842     char* tmpPtr; int tmpSize;
1843     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
1844         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1845         return NULL;
1846     }
1847     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
1848         return NULL;
1849     _arg1 = new wxString(tmpPtr, tmpSize);
1850 #else
1851     if (!PyString_Check(_obj1)) {
1852         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
1853         return NULL;
1854     }
1855     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
1856 #endif
1857 }
1858 {
1859     wxPy_BEGIN_ALLOW_THREADS;
1860         wxGridCellEditor_SetParameters(_arg0,*_arg1);
1861
1862     wxPy_END_ALLOW_THREADS;
1863     if (PyErr_Occurred()) return NULL;
1864 }    Py_INCREF(Py_None);
1865     _resultobj = Py_None;
1866 {
1867     if (_obj1)
1868         delete _arg1;
1869 }
1870     return _resultobj;
1871 }
1872
1873 #define wxGridCellEditor_IncRef(_swigobj)  (_swigobj->IncRef())
1874 static PyObject *_wrap_wxGridCellEditor_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) {
1875     PyObject * _resultobj;
1876     wxGridCellEditor * _arg0;
1877     PyObject * _argo0 = 0;
1878     char *_kwnames[] = { "self", NULL };
1879
1880     self = self;
1881     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_IncRef",_kwnames,&_argo0))
1882         return NULL;
1883     if (_argo0) {
1884         if (_argo0 == Py_None) { _arg0 = NULL; }
1885         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1886             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IncRef. Expected _wxGridCellEditor_p.");
1887         return NULL;
1888         }
1889     }
1890 {
1891     wxPy_BEGIN_ALLOW_THREADS;
1892         wxGridCellEditor_IncRef(_arg0);
1893
1894     wxPy_END_ALLOW_THREADS;
1895     if (PyErr_Occurred()) return NULL;
1896 }    Py_INCREF(Py_None);
1897     _resultobj = Py_None;
1898     return _resultobj;
1899 }
1900
1901 #define wxGridCellEditor_DecRef(_swigobj)  (_swigobj->DecRef())
1902 static PyObject *_wrap_wxGridCellEditor_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) {
1903     PyObject * _resultobj;
1904     wxGridCellEditor * _arg0;
1905     PyObject * _argo0 = 0;
1906     char *_kwnames[] = { "self", NULL };
1907
1908     self = self;
1909     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_DecRef",_kwnames,&_argo0))
1910         return NULL;
1911     if (_argo0) {
1912         if (_argo0 == Py_None) { _arg0 = NULL; }
1913         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1914             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_DecRef. Expected _wxGridCellEditor_p.");
1915         return NULL;
1916         }
1917     }
1918 {
1919     wxPy_BEGIN_ALLOW_THREADS;
1920         wxGridCellEditor_DecRef(_arg0);
1921
1922     wxPy_END_ALLOW_THREADS;
1923     if (PyErr_Occurred()) return NULL;
1924 }    Py_INCREF(Py_None);
1925     _resultobj = Py_None;
1926     return _resultobj;
1927 }
1928
1929 #define wxGridCellEditor_Create(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->Create(_swigarg0,_swigarg1,_swigarg2))
1930 static PyObject *_wrap_wxGridCellEditor_Create(PyObject *self, PyObject *args, PyObject *kwargs) {
1931     PyObject * _resultobj;
1932     wxGridCellEditor * _arg0;
1933     wxWindow * _arg1;
1934     wxWindowID  _arg2;
1935     wxEvtHandler * _arg3;
1936     PyObject * _argo0 = 0;
1937     PyObject * _argo1 = 0;
1938     PyObject * _argo3 = 0;
1939     char *_kwnames[] = { "self","parent","id","evtHandler", NULL };
1940
1941     self = self;
1942     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOiO:wxGridCellEditor_Create",_kwnames,&_argo0,&_argo1,&_arg2,&_argo3))
1943         return NULL;
1944     if (_argo0) {
1945         if (_argo0 == Py_None) { _arg0 = NULL; }
1946         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1947             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Create. Expected _wxGridCellEditor_p.");
1948         return NULL;
1949         }
1950     }
1951     if (_argo1) {
1952         if (_argo1 == Py_None) { _arg1 = NULL; }
1953         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
1954             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_Create. Expected _wxWindow_p.");
1955         return NULL;
1956         }
1957     }
1958     if (_argo3) {
1959         if (_argo3 == Py_None) { _arg3 = NULL; }
1960         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxEvtHandler_p")) {
1961             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellEditor_Create. Expected _wxEvtHandler_p.");
1962         return NULL;
1963         }
1964     }
1965 {
1966     wxPy_BEGIN_ALLOW_THREADS;
1967         wxGridCellEditor_Create(_arg0,_arg1,_arg2,_arg3);
1968
1969     wxPy_END_ALLOW_THREADS;
1970     if (PyErr_Occurred()) return NULL;
1971 }    Py_INCREF(Py_None);
1972     _resultobj = Py_None;
1973     return _resultobj;
1974 }
1975
1976 #define wxGridCellEditor_BeginEdit(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->BeginEdit(_swigarg0,_swigarg1,_swigarg2))
1977 static PyObject *_wrap_wxGridCellEditor_BeginEdit(PyObject *self, PyObject *args, PyObject *kwargs) {
1978     PyObject * _resultobj;
1979     wxGridCellEditor * _arg0;
1980     int  _arg1;
1981     int  _arg2;
1982     wxGrid * _arg3;
1983     PyObject * _argo0 = 0;
1984     PyObject * _argo3 = 0;
1985     char *_kwnames[] = { "self","row","col","grid", NULL };
1986
1987     self = self;
1988     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridCellEditor_BeginEdit",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
1989         return NULL;
1990     if (_argo0) {
1991         if (_argo0 == Py_None) { _arg0 = NULL; }
1992         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
1993             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_BeginEdit. Expected _wxGridCellEditor_p.");
1994         return NULL;
1995         }
1996     }
1997     if (_argo3) {
1998         if (_argo3 == Py_None) { _arg3 = NULL; }
1999         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGrid_p")) {
2000             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellEditor_BeginEdit. Expected _wxGrid_p.");
2001         return NULL;
2002         }
2003     }
2004 {
2005     wxPy_BEGIN_ALLOW_THREADS;
2006         wxGridCellEditor_BeginEdit(_arg0,_arg1,_arg2,_arg3);
2007
2008     wxPy_END_ALLOW_THREADS;
2009     if (PyErr_Occurred()) return NULL;
2010 }    Py_INCREF(Py_None);
2011     _resultobj = Py_None;
2012     return _resultobj;
2013 }
2014
2015 #define wxGridCellEditor_EndEdit(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->EndEdit(_swigarg0,_swigarg1,_swigarg2))
2016 static PyObject *_wrap_wxGridCellEditor_EndEdit(PyObject *self, PyObject *args, PyObject *kwargs) {
2017     PyObject * _resultobj;
2018     bool  _result;
2019     wxGridCellEditor * _arg0;
2020     int  _arg1;
2021     int  _arg2;
2022     wxGrid * _arg3;
2023     PyObject * _argo0 = 0;
2024     PyObject * _argo3 = 0;
2025     char *_kwnames[] = { "self","row","col","grid", NULL };
2026
2027     self = self;
2028     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGridCellEditor_EndEdit",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
2029         return NULL;
2030     if (_argo0) {
2031         if (_argo0 == Py_None) { _arg0 = NULL; }
2032         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2033             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_EndEdit. Expected _wxGridCellEditor_p.");
2034         return NULL;
2035         }
2036     }
2037     if (_argo3) {
2038         if (_argo3 == Py_None) { _arg3 = NULL; }
2039         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGrid_p")) {
2040             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGridCellEditor_EndEdit. Expected _wxGrid_p.");
2041         return NULL;
2042         }
2043     }
2044 {
2045     wxPy_BEGIN_ALLOW_THREADS;
2046         _result = (bool )wxGridCellEditor_EndEdit(_arg0,_arg1,_arg2,_arg3);
2047
2048     wxPy_END_ALLOW_THREADS;
2049     if (PyErr_Occurred()) return NULL;
2050 }    _resultobj = Py_BuildValue("i",_result);
2051     return _resultobj;
2052 }
2053
2054 #define wxGridCellEditor_Reset(_swigobj)  (_swigobj->Reset())
2055 static PyObject *_wrap_wxGridCellEditor_Reset(PyObject *self, PyObject *args, PyObject *kwargs) {
2056     PyObject * _resultobj;
2057     wxGridCellEditor * _arg0;
2058     PyObject * _argo0 = 0;
2059     char *_kwnames[] = { "self", NULL };
2060
2061     self = self;
2062     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Reset",_kwnames,&_argo0))
2063         return NULL;
2064     if (_argo0) {
2065         if (_argo0 == Py_None) { _arg0 = NULL; }
2066         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2067             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Reset. Expected _wxGridCellEditor_p.");
2068         return NULL;
2069         }
2070     }
2071 {
2072     wxPy_BEGIN_ALLOW_THREADS;
2073         wxGridCellEditor_Reset(_arg0);
2074
2075     wxPy_END_ALLOW_THREADS;
2076     if (PyErr_Occurred()) return NULL;
2077 }    Py_INCREF(Py_None);
2078     _resultobj = Py_None;
2079     return _resultobj;
2080 }
2081
2082 #define wxGridCellEditor_Clone(_swigobj)  (_swigobj->Clone())
2083 static PyObject *_wrap_wxGridCellEditor_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
2084     PyObject * _resultobj;
2085     wxGridCellEditor * _result;
2086     wxGridCellEditor * _arg0;
2087     PyObject * _argo0 = 0;
2088     char *_kwnames[] = { "self", NULL };
2089     char _ptemp[128];
2090
2091     self = self;
2092     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Clone",_kwnames,&_argo0))
2093         return NULL;
2094     if (_argo0) {
2095         if (_argo0 == Py_None) { _arg0 = NULL; }
2096         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2097             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Clone. Expected _wxGridCellEditor_p.");
2098         return NULL;
2099         }
2100     }
2101 {
2102     wxPy_BEGIN_ALLOW_THREADS;
2103         _result = (wxGridCellEditor *)wxGridCellEditor_Clone(_arg0);
2104
2105     wxPy_END_ALLOW_THREADS;
2106     if (PyErr_Occurred()) return NULL;
2107 }    if (_result) {
2108         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
2109         _resultobj = Py_BuildValue("s",_ptemp);
2110     } else {
2111         Py_INCREF(Py_None);
2112         _resultobj = Py_None;
2113     }
2114     return _resultobj;
2115 }
2116
2117 #define wxGridCellEditor_SetSize(_swigobj,_swigarg0)  (_swigobj->SetSize(_swigarg0))
2118 static PyObject *_wrap_wxGridCellEditor_SetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
2119     PyObject * _resultobj;
2120     wxGridCellEditor * _arg0;
2121     wxRect * _arg1;
2122     PyObject * _argo0 = 0;
2123     wxRect  temp;
2124     PyObject * _obj1 = 0;
2125     char *_kwnames[] = { "self","rect", NULL };
2126
2127     self = self;
2128     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_SetSize",_kwnames,&_argo0,&_obj1))
2129         return NULL;
2130     if (_argo0) {
2131         if (_argo0 == Py_None) { _arg0 = NULL; }
2132         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2133             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_SetSize. Expected _wxGridCellEditor_p.");
2134         return NULL;
2135         }
2136     }
2137 {
2138     _arg1 = &temp;
2139     if (! wxRect_helper(_obj1, &_arg1))
2140         return NULL;
2141 }
2142 {
2143     wxPy_BEGIN_ALLOW_THREADS;
2144         wxGridCellEditor_SetSize(_arg0,*_arg1);
2145
2146     wxPy_END_ALLOW_THREADS;
2147     if (PyErr_Occurred()) return NULL;
2148 }    Py_INCREF(Py_None);
2149     _resultobj = Py_None;
2150     return _resultobj;
2151 }
2152
2153 #define wxGridCellEditor_Show(_swigobj,_swigarg0,_swigarg1)  (_swigobj->Show(_swigarg0,_swigarg1))
2154 static PyObject *_wrap_wxGridCellEditor_Show(PyObject *self, PyObject *args, PyObject *kwargs) {
2155     PyObject * _resultobj;
2156     wxGridCellEditor * _arg0;
2157     bool  _arg1;
2158     wxGridCellAttr * _arg2 = (wxGridCellAttr *) NULL;
2159     PyObject * _argo0 = 0;
2160     int tempbool1;
2161     PyObject * _argo2 = 0;
2162     char *_kwnames[] = { "self","show","attr", NULL };
2163
2164     self = self;
2165     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|O:wxGridCellEditor_Show",_kwnames,&_argo0,&tempbool1,&_argo2))
2166         return NULL;
2167     if (_argo0) {
2168         if (_argo0 == Py_None) { _arg0 = NULL; }
2169         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2170             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Show. Expected _wxGridCellEditor_p.");
2171         return NULL;
2172         }
2173     }
2174     _arg1 = (bool ) tempbool1;
2175     if (_argo2) {
2176         if (_argo2 == Py_None) { _arg2 = NULL; }
2177         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2178             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellEditor_Show. Expected _wxGridCellAttr_p.");
2179         return NULL;
2180         }
2181     }
2182 {
2183     wxPy_BEGIN_ALLOW_THREADS;
2184         wxGridCellEditor_Show(_arg0,_arg1,_arg2);
2185
2186     wxPy_END_ALLOW_THREADS;
2187     if (PyErr_Occurred()) return NULL;
2188 }    Py_INCREF(Py_None);
2189     _resultobj = Py_None;
2190     return _resultobj;
2191 }
2192
2193 #define wxGridCellEditor_PaintBackground(_swigobj,_swigarg0,_swigarg1)  (_swigobj->PaintBackground(_swigarg0,_swigarg1))
2194 static PyObject *_wrap_wxGridCellEditor_PaintBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
2195     PyObject * _resultobj;
2196     wxGridCellEditor * _arg0;
2197     wxRect * _arg1;
2198     wxGridCellAttr * _arg2;
2199     PyObject * _argo0 = 0;
2200     wxRect  temp;
2201     PyObject * _obj1 = 0;
2202     PyObject * _argo2 = 0;
2203     char *_kwnames[] = { "self","rectCell","attr", NULL };
2204
2205     self = self;
2206     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGridCellEditor_PaintBackground",_kwnames,&_argo0,&_obj1,&_argo2))
2207         return NULL;
2208     if (_argo0) {
2209         if (_argo0 == Py_None) { _arg0 = NULL; }
2210         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2211             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_PaintBackground. Expected _wxGridCellEditor_p.");
2212         return NULL;
2213         }
2214     }
2215 {
2216     _arg1 = &temp;
2217     if (! wxRect_helper(_obj1, &_arg1))
2218         return NULL;
2219 }
2220     if (_argo2) {
2221         if (_argo2 == Py_None) { _arg2 = NULL; }
2222         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2223             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGridCellEditor_PaintBackground. Expected _wxGridCellAttr_p.");
2224         return NULL;
2225         }
2226     }
2227 {
2228     wxPy_BEGIN_ALLOW_THREADS;
2229         wxGridCellEditor_PaintBackground(_arg0,*_arg1,_arg2);
2230
2231     wxPy_END_ALLOW_THREADS;
2232     if (PyErr_Occurred()) return NULL;
2233 }    Py_INCREF(Py_None);
2234     _resultobj = Py_None;
2235     return _resultobj;
2236 }
2237
2238 #define wxGridCellEditor_IsAcceptedKey(_swigobj,_swigarg0)  (_swigobj->IsAcceptedKey(_swigarg0))
2239 static PyObject *_wrap_wxGridCellEditor_IsAcceptedKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2240     PyObject * _resultobj;
2241     bool  _result;
2242     wxGridCellEditor * _arg0;
2243     wxKeyEvent * _arg1;
2244     PyObject * _argo0 = 0;
2245     PyObject * _argo1 = 0;
2246     char *_kwnames[] = { "self","event", NULL };
2247
2248     self = self;
2249     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_IsAcceptedKey",_kwnames,&_argo0,&_argo1))
2250         return NULL;
2251     if (_argo0) {
2252         if (_argo0 == Py_None) { _arg0 = NULL; }
2253         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2254             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_IsAcceptedKey. Expected _wxGridCellEditor_p.");
2255         return NULL;
2256         }
2257     }
2258     if (_argo1) {
2259         if (_argo1 == Py_None) { _arg1 = NULL; }
2260         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2261             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_IsAcceptedKey. Expected _wxKeyEvent_p.");
2262         return NULL;
2263         }
2264     }
2265 {
2266     wxPy_BEGIN_ALLOW_THREADS;
2267         _result = (bool )wxGridCellEditor_IsAcceptedKey(_arg0,*_arg1);
2268
2269     wxPy_END_ALLOW_THREADS;
2270     if (PyErr_Occurred()) return NULL;
2271 }    _resultobj = Py_BuildValue("i",_result);
2272     return _resultobj;
2273 }
2274
2275 #define wxGridCellEditor_StartingKey(_swigobj,_swigarg0)  (_swigobj->StartingKey(_swigarg0))
2276 static PyObject *_wrap_wxGridCellEditor_StartingKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2277     PyObject * _resultobj;
2278     wxGridCellEditor * _arg0;
2279     wxKeyEvent * _arg1;
2280     PyObject * _argo0 = 0;
2281     PyObject * _argo1 = 0;
2282     char *_kwnames[] = { "self","event", NULL };
2283
2284     self = self;
2285     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_StartingKey",_kwnames,&_argo0,&_argo1))
2286         return NULL;
2287     if (_argo0) {
2288         if (_argo0 == Py_None) { _arg0 = NULL; }
2289         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2290             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_StartingKey. Expected _wxGridCellEditor_p.");
2291         return NULL;
2292         }
2293     }
2294     if (_argo1) {
2295         if (_argo1 == Py_None) { _arg1 = NULL; }
2296         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2297             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_StartingKey. Expected _wxKeyEvent_p.");
2298         return NULL;
2299         }
2300     }
2301 {
2302     wxPy_BEGIN_ALLOW_THREADS;
2303         wxGridCellEditor_StartingKey(_arg0,*_arg1);
2304
2305     wxPy_END_ALLOW_THREADS;
2306     if (PyErr_Occurred()) return NULL;
2307 }    Py_INCREF(Py_None);
2308     _resultobj = Py_None;
2309     return _resultobj;
2310 }
2311
2312 #define wxGridCellEditor_StartingClick(_swigobj)  (_swigobj->StartingClick())
2313 static PyObject *_wrap_wxGridCellEditor_StartingClick(PyObject *self, PyObject *args, PyObject *kwargs) {
2314     PyObject * _resultobj;
2315     wxGridCellEditor * _arg0;
2316     PyObject * _argo0 = 0;
2317     char *_kwnames[] = { "self", NULL };
2318
2319     self = self;
2320     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_StartingClick",_kwnames,&_argo0))
2321         return NULL;
2322     if (_argo0) {
2323         if (_argo0 == Py_None) { _arg0 = NULL; }
2324         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2325             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_StartingClick. Expected _wxGridCellEditor_p.");
2326         return NULL;
2327         }
2328     }
2329 {
2330     wxPy_BEGIN_ALLOW_THREADS;
2331         wxGridCellEditor_StartingClick(_arg0);
2332
2333     wxPy_END_ALLOW_THREADS;
2334     if (PyErr_Occurred()) return NULL;
2335 }    Py_INCREF(Py_None);
2336     _resultobj = Py_None;
2337     return _resultobj;
2338 }
2339
2340 #define wxGridCellEditor_HandleReturn(_swigobj,_swigarg0)  (_swigobj->HandleReturn(_swigarg0))
2341 static PyObject *_wrap_wxGridCellEditor_HandleReturn(PyObject *self, PyObject *args, PyObject *kwargs) {
2342     PyObject * _resultobj;
2343     wxGridCellEditor * _arg0;
2344     wxKeyEvent * _arg1;
2345     PyObject * _argo0 = 0;
2346     PyObject * _argo1 = 0;
2347     char *_kwnames[] = { "self","event", NULL };
2348
2349     self = self;
2350     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellEditor_HandleReturn",_kwnames,&_argo0,&_argo1))
2351         return NULL;
2352     if (_argo0) {
2353         if (_argo0 == Py_None) { _arg0 = NULL; }
2354         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2355             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_HandleReturn. Expected _wxGridCellEditor_p.");
2356         return NULL;
2357         }
2358     }
2359     if (_argo1) {
2360         if (_argo1 == Py_None) { _arg1 = NULL; }
2361         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2362             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellEditor_HandleReturn. Expected _wxKeyEvent_p.");
2363         return NULL;
2364         }
2365     }
2366 {
2367     wxPy_BEGIN_ALLOW_THREADS;
2368         wxGridCellEditor_HandleReturn(_arg0,*_arg1);
2369
2370     wxPy_END_ALLOW_THREADS;
2371     if (PyErr_Occurred()) return NULL;
2372 }    Py_INCREF(Py_None);
2373     _resultobj = Py_None;
2374     return _resultobj;
2375 }
2376
2377 #define wxGridCellEditor_Destroy(_swigobj)  (_swigobj->Destroy())
2378 static PyObject *_wrap_wxGridCellEditor_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
2379     PyObject * _resultobj;
2380     wxGridCellEditor * _arg0;
2381     PyObject * _argo0 = 0;
2382     char *_kwnames[] = { "self", NULL };
2383
2384     self = self;
2385     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellEditor_Destroy",_kwnames,&_argo0))
2386         return NULL;
2387     if (_argo0) {
2388         if (_argo0 == Py_None) { _arg0 = NULL; }
2389         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellEditor_p")) {
2390             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellEditor_Destroy. Expected _wxGridCellEditor_p.");
2391         return NULL;
2392         }
2393     }
2394 {
2395     wxPy_BEGIN_ALLOW_THREADS;
2396         wxGridCellEditor_Destroy(_arg0);
2397
2398     wxPy_END_ALLOW_THREADS;
2399     if (PyErr_Occurred()) return NULL;
2400 }    Py_INCREF(Py_None);
2401     _resultobj = Py_None;
2402     return _resultobj;
2403 }
2404
2405 static void *SwigwxPyGridCellEditorTowxGridCellEditor(void *ptr) {
2406     wxPyGridCellEditor *src;
2407     wxGridCellEditor *dest;
2408     src = (wxPyGridCellEditor *) ptr;
2409     dest = (wxGridCellEditor *) src;
2410     return (void *) dest;
2411 }
2412
2413 #define new_wxPyGridCellEditor() (new wxPyGridCellEditor())
2414 static PyObject *_wrap_new_wxPyGridCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2415     PyObject * _resultobj;
2416     wxPyGridCellEditor * _result;
2417     char *_kwnames[] = {  NULL };
2418     char _ptemp[128];
2419
2420     self = self;
2421     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxPyGridCellEditor",_kwnames))
2422         return NULL;
2423 {
2424     wxPy_BEGIN_ALLOW_THREADS;
2425         _result = (wxPyGridCellEditor *)new_wxPyGridCellEditor();
2426
2427     wxPy_END_ALLOW_THREADS;
2428     if (PyErr_Occurred()) return NULL;
2429 }    if (_result) {
2430         SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyGridCellEditor_p");
2431         _resultobj = Py_BuildValue("s",_ptemp);
2432     } else {
2433         Py_INCREF(Py_None);
2434         _resultobj = Py_None;
2435     }
2436     return _resultobj;
2437 }
2438
2439 #define wxPyGridCellEditor__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
2440 static PyObject *_wrap_wxPyGridCellEditor__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
2441     PyObject * _resultobj;
2442     wxPyGridCellEditor * _arg0;
2443     PyObject * _arg1;
2444     PyObject * _arg2;
2445     PyObject * _argo0 = 0;
2446     PyObject * _obj1 = 0;
2447     PyObject * _obj2 = 0;
2448     char *_kwnames[] = { "self","self","_class", NULL };
2449
2450     self = self;
2451     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellEditor__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2))
2452         return NULL;
2453     if (_argo0) {
2454         if (_argo0 == Py_None) { _arg0 = NULL; }
2455         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2456             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor__setCallbackInfo. Expected _wxPyGridCellEditor_p.");
2457         return NULL;
2458         }
2459     }
2460 {
2461   _arg1 = _obj1;
2462 }
2463 {
2464   _arg2 = _obj2;
2465 }
2466 {
2467     wxPy_BEGIN_ALLOW_THREADS;
2468         wxPyGridCellEditor__setCallbackInfo(_arg0,_arg1,_arg2);
2469
2470     wxPy_END_ALLOW_THREADS;
2471     if (PyErr_Occurred()) return NULL;
2472 }    Py_INCREF(Py_None);
2473     _resultobj = Py_None;
2474     return _resultobj;
2475 }
2476
2477 #define wxPyGridCellEditor_base_SetSize(_swigobj,_swigarg0)  (_swigobj->base_SetSize(_swigarg0))
2478 static PyObject *_wrap_wxPyGridCellEditor_base_SetSize(PyObject *self, PyObject *args, PyObject *kwargs) {
2479     PyObject * _resultobj;
2480     wxPyGridCellEditor * _arg0;
2481     wxRect * _arg1;
2482     PyObject * _argo0 = 0;
2483     wxRect  temp;
2484     PyObject * _obj1 = 0;
2485     char *_kwnames[] = { "self","rect", NULL };
2486
2487     self = self;
2488     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_SetSize",_kwnames,&_argo0,&_obj1))
2489         return NULL;
2490     if (_argo0) {
2491         if (_argo0 == Py_None) { _arg0 = NULL; }
2492         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2493             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_SetSize. Expected _wxPyGridCellEditor_p.");
2494         return NULL;
2495         }
2496     }
2497 {
2498     _arg1 = &temp;
2499     if (! wxRect_helper(_obj1, &_arg1))
2500         return NULL;
2501 }
2502 {
2503     wxPy_BEGIN_ALLOW_THREADS;
2504         wxPyGridCellEditor_base_SetSize(_arg0,*_arg1);
2505
2506     wxPy_END_ALLOW_THREADS;
2507     if (PyErr_Occurred()) return NULL;
2508 }    Py_INCREF(Py_None);
2509     _resultobj = Py_None;
2510     return _resultobj;
2511 }
2512
2513 #define wxPyGridCellEditor_base_Show(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_Show(_swigarg0,_swigarg1))
2514 static PyObject *_wrap_wxPyGridCellEditor_base_Show(PyObject *self, PyObject *args, PyObject *kwargs) {
2515     PyObject * _resultobj;
2516     wxPyGridCellEditor * _arg0;
2517     bool  _arg1;
2518     wxGridCellAttr * _arg2 = (wxGridCellAttr *) NULL;
2519     PyObject * _argo0 = 0;
2520     int tempbool1;
2521     PyObject * _argo2 = 0;
2522     char *_kwnames[] = { "self","show","attr", NULL };
2523
2524     self = self;
2525     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|O:wxPyGridCellEditor_base_Show",_kwnames,&_argo0,&tempbool1,&_argo2))
2526         return NULL;
2527     if (_argo0) {
2528         if (_argo0 == Py_None) { _arg0 = NULL; }
2529         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2530             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_Show. Expected _wxPyGridCellEditor_p.");
2531         return NULL;
2532         }
2533     }
2534     _arg1 = (bool ) tempbool1;
2535     if (_argo2) {
2536         if (_argo2 == Py_None) { _arg2 = NULL; }
2537         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2538             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxPyGridCellEditor_base_Show. Expected _wxGridCellAttr_p.");
2539         return NULL;
2540         }
2541     }
2542 {
2543     wxPy_BEGIN_ALLOW_THREADS;
2544         wxPyGridCellEditor_base_Show(_arg0,_arg1,_arg2);
2545
2546     wxPy_END_ALLOW_THREADS;
2547     if (PyErr_Occurred()) return NULL;
2548 }    Py_INCREF(Py_None);
2549     _resultobj = Py_None;
2550     return _resultobj;
2551 }
2552
2553 #define wxPyGridCellEditor_base_PaintBackground(_swigobj,_swigarg0,_swigarg1)  (_swigobj->base_PaintBackground(_swigarg0,_swigarg1))
2554 static PyObject *_wrap_wxPyGridCellEditor_base_PaintBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
2555     PyObject * _resultobj;
2556     wxPyGridCellEditor * _arg0;
2557     wxRect * _arg1;
2558     wxGridCellAttr * _arg2;
2559     PyObject * _argo0 = 0;
2560     wxRect  temp;
2561     PyObject * _obj1 = 0;
2562     PyObject * _argo2 = 0;
2563     char *_kwnames[] = { "self","rectCell","attr", NULL };
2564
2565     self = self;
2566     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxPyGridCellEditor_base_PaintBackground",_kwnames,&_argo0,&_obj1,&_argo2))
2567         return NULL;
2568     if (_argo0) {
2569         if (_argo0 == Py_None) { _arg0 = NULL; }
2570         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2571             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_PaintBackground. Expected _wxPyGridCellEditor_p.");
2572         return NULL;
2573         }
2574     }
2575 {
2576     _arg1 = &temp;
2577     if (! wxRect_helper(_obj1, &_arg1))
2578         return NULL;
2579 }
2580     if (_argo2) {
2581         if (_argo2 == Py_None) { _arg2 = NULL; }
2582         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
2583             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxPyGridCellEditor_base_PaintBackground. Expected _wxGridCellAttr_p.");
2584         return NULL;
2585         }
2586     }
2587 {
2588     wxPy_BEGIN_ALLOW_THREADS;
2589         wxPyGridCellEditor_base_PaintBackground(_arg0,*_arg1,_arg2);
2590
2591     wxPy_END_ALLOW_THREADS;
2592     if (PyErr_Occurred()) return NULL;
2593 }    Py_INCREF(Py_None);
2594     _resultobj = Py_None;
2595     return _resultobj;
2596 }
2597
2598 #define wxPyGridCellEditor_base_IsAcceptedKey(_swigobj,_swigarg0)  (_swigobj->base_IsAcceptedKey(_swigarg0))
2599 static PyObject *_wrap_wxPyGridCellEditor_base_IsAcceptedKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2600     PyObject * _resultobj;
2601     wxPyGridCellEditor * _arg0;
2602     wxKeyEvent * _arg1;
2603     PyObject * _argo0 = 0;
2604     PyObject * _argo1 = 0;
2605     char *_kwnames[] = { "self","event", NULL };
2606
2607     self = self;
2608     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_IsAcceptedKey",_kwnames,&_argo0,&_argo1))
2609         return NULL;
2610     if (_argo0) {
2611         if (_argo0 == Py_None) { _arg0 = NULL; }
2612         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2613             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_IsAcceptedKey. Expected _wxPyGridCellEditor_p.");
2614         return NULL;
2615         }
2616     }
2617     if (_argo1) {
2618         if (_argo1 == Py_None) { _arg1 = NULL; }
2619         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2620             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_IsAcceptedKey. Expected _wxKeyEvent_p.");
2621         return NULL;
2622         }
2623     }
2624 {
2625     wxPy_BEGIN_ALLOW_THREADS;
2626         wxPyGridCellEditor_base_IsAcceptedKey(_arg0,*_arg1);
2627
2628     wxPy_END_ALLOW_THREADS;
2629     if (PyErr_Occurred()) return NULL;
2630 }    Py_INCREF(Py_None);
2631     _resultobj = Py_None;
2632     return _resultobj;
2633 }
2634
2635 #define wxPyGridCellEditor_base_StartingKey(_swigobj,_swigarg0)  (_swigobj->base_StartingKey(_swigarg0))
2636 static PyObject *_wrap_wxPyGridCellEditor_base_StartingKey(PyObject *self, PyObject *args, PyObject *kwargs) {
2637     PyObject * _resultobj;
2638     wxPyGridCellEditor * _arg0;
2639     wxKeyEvent * _arg1;
2640     PyObject * _argo0 = 0;
2641     PyObject * _argo1 = 0;
2642     char *_kwnames[] = { "self","event", NULL };
2643
2644     self = self;
2645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_StartingKey",_kwnames,&_argo0,&_argo1))
2646         return NULL;
2647     if (_argo0) {
2648         if (_argo0 == Py_None) { _arg0 = NULL; }
2649         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2650             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_StartingKey. Expected _wxPyGridCellEditor_p.");
2651         return NULL;
2652         }
2653     }
2654     if (_argo1) {
2655         if (_argo1 == Py_None) { _arg1 = NULL; }
2656         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2657             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_StartingKey. Expected _wxKeyEvent_p.");
2658         return NULL;
2659         }
2660     }
2661 {
2662     wxPy_BEGIN_ALLOW_THREADS;
2663         wxPyGridCellEditor_base_StartingKey(_arg0,*_arg1);
2664
2665     wxPy_END_ALLOW_THREADS;
2666     if (PyErr_Occurred()) return NULL;
2667 }    Py_INCREF(Py_None);
2668     _resultobj = Py_None;
2669     return _resultobj;
2670 }
2671
2672 #define wxPyGridCellEditor_base_StartingClick(_swigobj)  (_swigobj->base_StartingClick())
2673 static PyObject *_wrap_wxPyGridCellEditor_base_StartingClick(PyObject *self, PyObject *args, PyObject *kwargs) {
2674     PyObject * _resultobj;
2675     wxPyGridCellEditor * _arg0;
2676     PyObject * _argo0 = 0;
2677     char *_kwnames[] = { "self", NULL };
2678
2679     self = self;
2680     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridCellEditor_base_StartingClick",_kwnames,&_argo0))
2681         return NULL;
2682     if (_argo0) {
2683         if (_argo0 == Py_None) { _arg0 = NULL; }
2684         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2685             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_StartingClick. Expected _wxPyGridCellEditor_p.");
2686         return NULL;
2687         }
2688     }
2689 {
2690     wxPy_BEGIN_ALLOW_THREADS;
2691         wxPyGridCellEditor_base_StartingClick(_arg0);
2692
2693     wxPy_END_ALLOW_THREADS;
2694     if (PyErr_Occurred()) return NULL;
2695 }    Py_INCREF(Py_None);
2696     _resultobj = Py_None;
2697     return _resultobj;
2698 }
2699
2700 #define wxPyGridCellEditor_base_HandleReturn(_swigobj,_swigarg0)  (_swigobj->base_HandleReturn(_swigarg0))
2701 static PyObject *_wrap_wxPyGridCellEditor_base_HandleReturn(PyObject *self, PyObject *args, PyObject *kwargs) {
2702     PyObject * _resultobj;
2703     wxPyGridCellEditor * _arg0;
2704     wxKeyEvent * _arg1;
2705     PyObject * _argo0 = 0;
2706     PyObject * _argo1 = 0;
2707     char *_kwnames[] = { "self","event", NULL };
2708
2709     self = self;
2710     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_HandleReturn",_kwnames,&_argo0,&_argo1))
2711         return NULL;
2712     if (_argo0) {
2713         if (_argo0 == Py_None) { _arg0 = NULL; }
2714         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2715             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_HandleReturn. Expected _wxPyGridCellEditor_p.");
2716         return NULL;
2717         }
2718     }
2719     if (_argo1) {
2720         if (_argo1 == Py_None) { _arg1 = NULL; }
2721         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxKeyEvent_p")) {
2722             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxPyGridCellEditor_base_HandleReturn. Expected _wxKeyEvent_p.");
2723         return NULL;
2724         }
2725     }
2726 {
2727     wxPy_BEGIN_ALLOW_THREADS;
2728         wxPyGridCellEditor_base_HandleReturn(_arg0,*_arg1);
2729
2730     wxPy_END_ALLOW_THREADS;
2731     if (PyErr_Occurred()) return NULL;
2732 }    Py_INCREF(Py_None);
2733     _resultobj = Py_None;
2734     return _resultobj;
2735 }
2736
2737 #define wxPyGridCellEditor_base_Destroy(_swigobj)  (_swigobj->base_Destroy())
2738 static PyObject *_wrap_wxPyGridCellEditor_base_Destroy(PyObject *self, PyObject *args, PyObject *kwargs) {
2739     PyObject * _resultobj;
2740     wxPyGridCellEditor * _arg0;
2741     PyObject * _argo0 = 0;
2742     char *_kwnames[] = { "self", NULL };
2743
2744     self = self;
2745     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxPyGridCellEditor_base_Destroy",_kwnames,&_argo0))
2746         return NULL;
2747     if (_argo0) {
2748         if (_argo0 == Py_None) { _arg0 = NULL; }
2749         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2750             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_Destroy. Expected _wxPyGridCellEditor_p.");
2751         return NULL;
2752         }
2753     }
2754 {
2755     wxPy_BEGIN_ALLOW_THREADS;
2756         wxPyGridCellEditor_base_Destroy(_arg0);
2757
2758     wxPy_END_ALLOW_THREADS;
2759     if (PyErr_Occurred()) return NULL;
2760 }    Py_INCREF(Py_None);
2761     _resultobj = Py_None;
2762     return _resultobj;
2763 }
2764
2765 #define wxPyGridCellEditor_base_SetParameters(_swigobj,_swigarg0)  (_swigobj->base_SetParameters(_swigarg0))
2766 static PyObject *_wrap_wxPyGridCellEditor_base_SetParameters(PyObject *self, PyObject *args, PyObject *kwargs) {
2767     PyObject * _resultobj;
2768     wxPyGridCellEditor * _arg0;
2769     wxString * _arg1;
2770     PyObject * _argo0 = 0;
2771     PyObject * _obj1 = 0;
2772     char *_kwnames[] = { "self","params", NULL };
2773
2774     self = self;
2775     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxPyGridCellEditor_base_SetParameters",_kwnames,&_argo0,&_obj1))
2776         return NULL;
2777     if (_argo0) {
2778         if (_argo0 == Py_None) { _arg0 = NULL; }
2779         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyGridCellEditor_p")) {
2780             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxPyGridCellEditor_base_SetParameters. Expected _wxPyGridCellEditor_p.");
2781         return NULL;
2782         }
2783     }
2784 {
2785 #if PYTHON_API_VERSION >= 1009
2786     char* tmpPtr; int tmpSize;
2787     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
2788         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2789         return NULL;
2790     }
2791     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
2792         return NULL;
2793     _arg1 = new wxString(tmpPtr, tmpSize);
2794 #else
2795     if (!PyString_Check(_obj1)) {
2796         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
2797         return NULL;
2798     }
2799     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
2800 #endif
2801 }
2802 {
2803     wxPy_BEGIN_ALLOW_THREADS;
2804         wxPyGridCellEditor_base_SetParameters(_arg0,*_arg1);
2805
2806     wxPy_END_ALLOW_THREADS;
2807     if (PyErr_Occurred()) return NULL;
2808 }    Py_INCREF(Py_None);
2809     _resultobj = Py_None;
2810 {
2811     if (_obj1)
2812         delete _arg1;
2813 }
2814     return _resultobj;
2815 }
2816
2817 static void *SwigwxGridCellTextEditorTowxGridCellEditor(void *ptr) {
2818     wxGridCellTextEditor *src;
2819     wxGridCellEditor *dest;
2820     src = (wxGridCellTextEditor *) ptr;
2821     dest = (wxGridCellEditor *) src;
2822     return (void *) dest;
2823 }
2824
2825 #define new_wxGridCellTextEditor() (new wxGridCellTextEditor())
2826 static PyObject *_wrap_new_wxGridCellTextEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2827     PyObject * _resultobj;
2828     wxGridCellTextEditor * _result;
2829     char *_kwnames[] = {  NULL };
2830     char _ptemp[128];
2831
2832     self = self;
2833     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellTextEditor",_kwnames))
2834         return NULL;
2835 {
2836     wxPy_BEGIN_ALLOW_THREADS;
2837         _result = (wxGridCellTextEditor *)new_wxGridCellTextEditor();
2838
2839     wxPy_END_ALLOW_THREADS;
2840     if (PyErr_Occurred()) return NULL;
2841 }    if (_result) {
2842         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellTextEditor_p");
2843         _resultobj = Py_BuildValue("s",_ptemp);
2844     } else {
2845         Py_INCREF(Py_None);
2846         _resultobj = Py_None;
2847     }
2848     return _resultobj;
2849 }
2850
2851 static void *SwigwxGridCellNumberEditorTowxGridCellTextEditor(void *ptr) {
2852     wxGridCellNumberEditor *src;
2853     wxGridCellTextEditor *dest;
2854     src = (wxGridCellNumberEditor *) ptr;
2855     dest = (wxGridCellTextEditor *) src;
2856     return (void *) dest;
2857 }
2858
2859 static void *SwigwxGridCellNumberEditorTowxGridCellEditor(void *ptr) {
2860     wxGridCellNumberEditor *src;
2861     wxGridCellEditor *dest;
2862     src = (wxGridCellNumberEditor *) ptr;
2863     dest = (wxGridCellEditor *) src;
2864     return (void *) dest;
2865 }
2866
2867 #define new_wxGridCellNumberEditor(_swigarg0,_swigarg1) (new wxGridCellNumberEditor(_swigarg0,_swigarg1))
2868 static PyObject *_wrap_new_wxGridCellNumberEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2869     PyObject * _resultobj;
2870     wxGridCellNumberEditor * _result;
2871     int  _arg0 = (int ) -1;
2872     int  _arg1 = (int ) -1;
2873     char *_kwnames[] = { "min","max", NULL };
2874     char _ptemp[128];
2875
2876     self = self;
2877     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|ii:new_wxGridCellNumberEditor",_kwnames,&_arg0,&_arg1))
2878         return NULL;
2879 {
2880     wxPy_BEGIN_ALLOW_THREADS;
2881         _result = (wxGridCellNumberEditor *)new_wxGridCellNumberEditor(_arg0,_arg1);
2882
2883     wxPy_END_ALLOW_THREADS;
2884     if (PyErr_Occurred()) return NULL;
2885 }    if (_result) {
2886         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellNumberEditor_p");
2887         _resultobj = Py_BuildValue("s",_ptemp);
2888     } else {
2889         Py_INCREF(Py_None);
2890         _resultobj = Py_None;
2891     }
2892     return _resultobj;
2893 }
2894
2895 static void *SwigwxGridCellFloatEditorTowxGridCellTextEditor(void *ptr) {
2896     wxGridCellFloatEditor *src;
2897     wxGridCellTextEditor *dest;
2898     src = (wxGridCellFloatEditor *) ptr;
2899     dest = (wxGridCellTextEditor *) src;
2900     return (void *) dest;
2901 }
2902
2903 static void *SwigwxGridCellFloatEditorTowxGridCellEditor(void *ptr) {
2904     wxGridCellFloatEditor *src;
2905     wxGridCellEditor *dest;
2906     src = (wxGridCellFloatEditor *) ptr;
2907     dest = (wxGridCellEditor *) src;
2908     return (void *) dest;
2909 }
2910
2911 #define new_wxGridCellFloatEditor() (new wxGridCellFloatEditor())
2912 static PyObject *_wrap_new_wxGridCellFloatEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2913     PyObject * _resultobj;
2914     wxGridCellFloatEditor * _result;
2915     char *_kwnames[] = {  NULL };
2916     char _ptemp[128];
2917
2918     self = self;
2919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellFloatEditor",_kwnames))
2920         return NULL;
2921 {
2922     wxPy_BEGIN_ALLOW_THREADS;
2923         _result = (wxGridCellFloatEditor *)new_wxGridCellFloatEditor();
2924
2925     wxPy_END_ALLOW_THREADS;
2926     if (PyErr_Occurred()) return NULL;
2927 }    if (_result) {
2928         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellFloatEditor_p");
2929         _resultobj = Py_BuildValue("s",_ptemp);
2930     } else {
2931         Py_INCREF(Py_None);
2932         _resultobj = Py_None;
2933     }
2934     return _resultobj;
2935 }
2936
2937 static void *SwigwxGridCellBoolEditorTowxGridCellEditor(void *ptr) {
2938     wxGridCellBoolEditor *src;
2939     wxGridCellEditor *dest;
2940     src = (wxGridCellBoolEditor *) ptr;
2941     dest = (wxGridCellEditor *) src;
2942     return (void *) dest;
2943 }
2944
2945 #define new_wxGridCellBoolEditor() (new wxGridCellBoolEditor())
2946 static PyObject *_wrap_new_wxGridCellBoolEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2947     PyObject * _resultobj;
2948     wxGridCellBoolEditor * _result;
2949     char *_kwnames[] = {  NULL };
2950     char _ptemp[128];
2951
2952     self = self;
2953     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellBoolEditor",_kwnames))
2954         return NULL;
2955 {
2956     wxPy_BEGIN_ALLOW_THREADS;
2957         _result = (wxGridCellBoolEditor *)new_wxGridCellBoolEditor();
2958
2959     wxPy_END_ALLOW_THREADS;
2960     if (PyErr_Occurred()) return NULL;
2961 }    if (_result) {
2962         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellBoolEditor_p");
2963         _resultobj = Py_BuildValue("s",_ptemp);
2964     } else {
2965         Py_INCREF(Py_None);
2966         _resultobj = Py_None;
2967     }
2968     return _resultobj;
2969 }
2970
2971 static void *SwigwxGridCellChoiceEditorTowxGridCellEditor(void *ptr) {
2972     wxGridCellChoiceEditor *src;
2973     wxGridCellEditor *dest;
2974     src = (wxGridCellChoiceEditor *) ptr;
2975     dest = (wxGridCellEditor *) src;
2976     return (void *) dest;
2977 }
2978
2979 #define new_wxGridCellChoiceEditor(_swigarg0,_swigarg1,_swigarg2) (new wxGridCellChoiceEditor(_swigarg0,_swigarg1,_swigarg2))
2980 static PyObject *_wrap_new_wxGridCellChoiceEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
2981     PyObject * _resultobj;
2982     wxGridCellChoiceEditor * _result;
2983     int  _arg0 = (int ) 0;
2984     wxString * _arg1 = (wxString *) NULL;
2985     bool  _arg2 = (bool ) FALSE;
2986     PyObject * _obj1 = 0;
2987     int tempbool2 = (int) FALSE;
2988     char *_kwnames[] = { "choices","allowOthers", NULL };
2989     char _ptemp[128];
2990
2991     self = self;
2992     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|Oi:new_wxGridCellChoiceEditor",_kwnames,&_obj1,&tempbool2))
2993         return NULL;
2994     if (_obj1)
2995 {
2996     _arg1 = wxString_LIST_helper(_obj1);
2997     if (_arg1 == NULL) {
2998         return NULL;
2999     }
3000 }
3001     _arg2 = (bool ) tempbool2;
3002 {
3003     if (_obj1) {
3004         _arg0 = PyList_Size(_obj1);
3005     }
3006     else {
3007         _arg0 = 0;
3008     }
3009 }
3010 {
3011     wxPy_BEGIN_ALLOW_THREADS;
3012         _result = (wxGridCellChoiceEditor *)new_wxGridCellChoiceEditor(_arg0,_arg1,_arg2);
3013
3014     wxPy_END_ALLOW_THREADS;
3015     if (PyErr_Occurred()) return NULL;
3016 }    if (_result) {
3017         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellChoiceEditor_p");
3018         _resultobj = Py_BuildValue("s",_ptemp);
3019     } else {
3020         Py_INCREF(Py_None);
3021         _resultobj = Py_None;
3022     }
3023 {
3024     delete [] _arg1;
3025 }
3026     return _resultobj;
3027 }
3028
3029 static void *SwigwxGridCellEnumEditorTowxGridCellChoiceEditor(void *ptr) {
3030     wxGridCellEnumEditor *src;
3031     wxGridCellChoiceEditor *dest;
3032     src = (wxGridCellEnumEditor *) ptr;
3033     dest = (wxGridCellChoiceEditor *) src;
3034     return (void *) dest;
3035 }
3036
3037 static void *SwigwxGridCellEnumEditorTowxGridCellEditor(void *ptr) {
3038     wxGridCellEnumEditor *src;
3039     wxGridCellEditor *dest;
3040     src = (wxGridCellEnumEditor *) ptr;
3041     dest = (wxGridCellEditor *) src;
3042     return (void *) dest;
3043 }
3044
3045 #define new_wxGridCellEnumEditor(_swigarg0) (new wxGridCellEnumEditor(_swigarg0))
3046 static PyObject *_wrap_new_wxGridCellEnumEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3047     PyObject * _resultobj;
3048     wxGridCellEnumEditor * _result;
3049     wxString * _arg0 = (wxString *) &"";
3050     PyObject * _obj0 = 0;
3051     char *_kwnames[] = { "choices", NULL };
3052     char _ptemp[128];
3053
3054     self = self;
3055     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"|O:new_wxGridCellEnumEditor",_kwnames,&_obj0))
3056         return NULL;
3057     if (_obj0)
3058 {
3059     _arg0 = wxString_LIST_helper(_obj0);
3060     if (_arg0 == NULL) {
3061         return NULL;
3062     }
3063 }
3064 {
3065     wxPy_BEGIN_ALLOW_THREADS;
3066         _result = (wxGridCellEnumEditor *)new_wxGridCellEnumEditor(*_arg0);
3067
3068     wxPy_END_ALLOW_THREADS;
3069     if (PyErr_Occurred()) return NULL;
3070 }    if (_result) {
3071         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEnumEditor_p");
3072         _resultobj = Py_BuildValue("s",_ptemp);
3073     } else {
3074         Py_INCREF(Py_None);
3075         _resultobj = Py_None;
3076     }
3077 {
3078     delete [] _arg0;
3079 }
3080     return _resultobj;
3081 }
3082
3083 static void *SwigwxGridCellAutoWrapStringEditorTowxGridCellTextEditor(void *ptr) {
3084     wxGridCellAutoWrapStringEditor *src;
3085     wxGridCellTextEditor *dest;
3086     src = (wxGridCellAutoWrapStringEditor *) ptr;
3087     dest = (wxGridCellTextEditor *) src;
3088     return (void *) dest;
3089 }
3090
3091 static void *SwigwxGridCellAutoWrapStringEditorTowxGridCellEditor(void *ptr) {
3092     wxGridCellAutoWrapStringEditor *src;
3093     wxGridCellEditor *dest;
3094     src = (wxGridCellAutoWrapStringEditor *) ptr;
3095     dest = (wxGridCellEditor *) src;
3096     return (void *) dest;
3097 }
3098
3099 #define new_wxGridCellAutoWrapStringEditor() (new wxGridCellAutoWrapStringEditor())
3100 static PyObject *_wrap_new_wxGridCellAutoWrapStringEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3101     PyObject * _resultobj;
3102     wxGridCellAutoWrapStringEditor * _result;
3103     char *_kwnames[] = {  NULL };
3104     char _ptemp[128];
3105
3106     self = self;
3107     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAutoWrapStringEditor",_kwnames))
3108         return NULL;
3109 {
3110     wxPy_BEGIN_ALLOW_THREADS;
3111         _result = (wxGridCellAutoWrapStringEditor *)new_wxGridCellAutoWrapStringEditor();
3112
3113     wxPy_END_ALLOW_THREADS;
3114     if (PyErr_Occurred()) return NULL;
3115 }    if (_result) {
3116         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAutoWrapStringEditor_p");
3117         _resultobj = Py_BuildValue("s",_ptemp);
3118     } else {
3119         Py_INCREF(Py_None);
3120         _resultobj = Py_None;
3121     }
3122     return _resultobj;
3123 }
3124
3125 #define new_wxGridCellAttr() (new wxGridCellAttr())
3126 static PyObject *_wrap_new_wxGridCellAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
3127     PyObject * _resultobj;
3128     wxGridCellAttr * _result;
3129     char *_kwnames[] = {  NULL };
3130     char _ptemp[128];
3131
3132     self = self;
3133     if(!PyArg_ParseTupleAndKeywords(args,kwargs,":new_wxGridCellAttr",_kwnames))
3134         return NULL;
3135 {
3136     wxPy_BEGIN_ALLOW_THREADS;
3137         _result = (wxGridCellAttr *)new_wxGridCellAttr();
3138
3139     wxPy_END_ALLOW_THREADS;
3140     if (PyErr_Occurred()) return NULL;
3141 }    if (_result) {
3142         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
3143         _resultobj = Py_BuildValue("s",_ptemp);
3144     } else {
3145         Py_INCREF(Py_None);
3146         _resultobj = Py_None;
3147     }
3148     return _resultobj;
3149 }
3150
3151 #define wxGridCellAttr_Clone(_swigobj)  (_swigobj->Clone())
3152 static PyObject *_wrap_wxGridCellAttr_Clone(PyObject *self, PyObject *args, PyObject *kwargs) {
3153     PyObject * _resultobj;
3154     wxGridCellAttr * _result;
3155     wxGridCellAttr * _arg0;
3156     PyObject * _argo0 = 0;
3157     char *_kwnames[] = { "self", NULL };
3158     char _ptemp[128];
3159
3160     self = self;
3161     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_Clone",_kwnames,&_argo0))
3162         return NULL;
3163     if (_argo0) {
3164         if (_argo0 == Py_None) { _arg0 = NULL; }
3165         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3166             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_Clone. Expected _wxGridCellAttr_p.");
3167         return NULL;
3168         }
3169     }
3170 {
3171     wxPy_BEGIN_ALLOW_THREADS;
3172         _result = (wxGridCellAttr *)wxGridCellAttr_Clone(_arg0);
3173
3174     wxPy_END_ALLOW_THREADS;
3175     if (PyErr_Occurred()) return NULL;
3176 }    if (_result) {
3177         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellAttr_p");
3178         _resultobj = Py_BuildValue("s",_ptemp);
3179     } else {
3180         Py_INCREF(Py_None);
3181         _resultobj = Py_None;
3182     }
3183     return _resultobj;
3184 }
3185
3186 #define wxGridCellAttr_MergeWith(_swigobj,_swigarg0)  (_swigobj->MergeWith(_swigarg0))
3187 static PyObject *_wrap_wxGridCellAttr_MergeWith(PyObject *self, PyObject *args, PyObject *kwargs) {
3188     PyObject * _resultobj;
3189     wxGridCellAttr * _arg0;
3190     wxGridCellAttr * _arg1;
3191     PyObject * _argo0 = 0;
3192     PyObject * _argo1 = 0;
3193     char *_kwnames[] = { "self","mergefrom", NULL };
3194
3195     self = self;
3196     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_MergeWith",_kwnames,&_argo0,&_argo1))
3197         return NULL;
3198     if (_argo0) {
3199         if (_argo0 == Py_None) { _arg0 = NULL; }
3200         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3201             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_MergeWith. Expected _wxGridCellAttr_p.");
3202         return NULL;
3203         }
3204     }
3205     if (_argo1) {
3206         if (_argo1 == Py_None) { _arg1 = NULL; }
3207         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellAttr_p")) {
3208             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_MergeWith. Expected _wxGridCellAttr_p.");
3209         return NULL;
3210         }
3211     }
3212 {
3213     wxPy_BEGIN_ALLOW_THREADS;
3214         wxGridCellAttr_MergeWith(_arg0,_arg1);
3215
3216     wxPy_END_ALLOW_THREADS;
3217     if (PyErr_Occurred()) return NULL;
3218 }    Py_INCREF(Py_None);
3219     _resultobj = Py_None;
3220     return _resultobj;
3221 }
3222
3223 #define wxGridCellAttr_IncRef(_swigobj)  (_swigobj->IncRef())
3224 static PyObject *_wrap_wxGridCellAttr_IncRef(PyObject *self, PyObject *args, PyObject *kwargs) {
3225     PyObject * _resultobj;
3226     wxGridCellAttr * _arg0;
3227     PyObject * _argo0 = 0;
3228     char *_kwnames[] = { "self", NULL };
3229
3230     self = self;
3231     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_IncRef",_kwnames,&_argo0))
3232         return NULL;
3233     if (_argo0) {
3234         if (_argo0 == Py_None) { _arg0 = NULL; }
3235         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3236             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_IncRef. Expected _wxGridCellAttr_p.");
3237         return NULL;
3238         }
3239     }
3240 {
3241     wxPy_BEGIN_ALLOW_THREADS;
3242         wxGridCellAttr_IncRef(_arg0);
3243
3244     wxPy_END_ALLOW_THREADS;
3245     if (PyErr_Occurred()) return NULL;
3246 }    Py_INCREF(Py_None);
3247     _resultobj = Py_None;
3248     return _resultobj;
3249 }
3250
3251 #define wxGridCellAttr_DecRef(_swigobj)  (_swigobj->DecRef())
3252 static PyObject *_wrap_wxGridCellAttr_DecRef(PyObject *self, PyObject *args, PyObject *kwargs) {
3253     PyObject * _resultobj;
3254     wxGridCellAttr * _arg0;
3255     PyObject * _argo0 = 0;
3256     char *_kwnames[] = { "self", NULL };
3257
3258     self = self;
3259     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_DecRef",_kwnames,&_argo0))
3260         return NULL;
3261     if (_argo0) {
3262         if (_argo0 == Py_None) { _arg0 = NULL; }
3263         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3264             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_DecRef. Expected _wxGridCellAttr_p.");
3265         return NULL;
3266         }
3267     }
3268 {
3269     wxPy_BEGIN_ALLOW_THREADS;
3270         wxGridCellAttr_DecRef(_arg0);
3271
3272     wxPy_END_ALLOW_THREADS;
3273     if (PyErr_Occurred()) return NULL;
3274 }    Py_INCREF(Py_None);
3275     _resultobj = Py_None;
3276     return _resultobj;
3277 }
3278
3279 #define wxGridCellAttr_SetTextColour(_swigobj,_swigarg0)  (_swigobj->SetTextColour(_swigarg0))
3280 static PyObject *_wrap_wxGridCellAttr_SetTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3281     PyObject * _resultobj;
3282     wxGridCellAttr * _arg0;
3283     wxColour * _arg1;
3284     PyObject * _argo0 = 0;
3285     wxColour  temp;
3286     PyObject * _obj1 = 0;
3287     char *_kwnames[] = { "self","colText", NULL };
3288
3289     self = self;
3290     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetTextColour",_kwnames,&_argo0,&_obj1))
3291         return NULL;
3292     if (_argo0) {
3293         if (_argo0 == Py_None) { _arg0 = NULL; }
3294         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3295             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetTextColour. Expected _wxGridCellAttr_p.");
3296         return NULL;
3297         }
3298     }
3299 {
3300     _arg1 = &temp;
3301     if (! wxColour_helper(_obj1, &_arg1))
3302         return NULL;
3303 }
3304 {
3305     wxPy_BEGIN_ALLOW_THREADS;
3306         wxGridCellAttr_SetTextColour(_arg0,*_arg1);
3307
3308     wxPy_END_ALLOW_THREADS;
3309     if (PyErr_Occurred()) return NULL;
3310 }    Py_INCREF(Py_None);
3311     _resultobj = Py_None;
3312     return _resultobj;
3313 }
3314
3315 #define wxGridCellAttr_SetBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetBackgroundColour(_swigarg0))
3316 static PyObject *_wrap_wxGridCellAttr_SetBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3317     PyObject * _resultobj;
3318     wxGridCellAttr * _arg0;
3319     wxColour * _arg1;
3320     PyObject * _argo0 = 0;
3321     wxColour  temp;
3322     PyObject * _obj1 = 0;
3323     char *_kwnames[] = { "self","colBack", NULL };
3324
3325     self = self;
3326     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetBackgroundColour",_kwnames,&_argo0,&_obj1))
3327         return NULL;
3328     if (_argo0) {
3329         if (_argo0 == Py_None) { _arg0 = NULL; }
3330         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3331             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetBackgroundColour. Expected _wxGridCellAttr_p.");
3332         return NULL;
3333         }
3334     }
3335 {
3336     _arg1 = &temp;
3337     if (! wxColour_helper(_obj1, &_arg1))
3338         return NULL;
3339 }
3340 {
3341     wxPy_BEGIN_ALLOW_THREADS;
3342         wxGridCellAttr_SetBackgroundColour(_arg0,*_arg1);
3343
3344     wxPy_END_ALLOW_THREADS;
3345     if (PyErr_Occurred()) return NULL;
3346 }    Py_INCREF(Py_None);
3347     _resultobj = Py_None;
3348     return _resultobj;
3349 }
3350
3351 #define wxGridCellAttr_SetFont(_swigobj,_swigarg0)  (_swigobj->SetFont(_swigarg0))
3352 static PyObject *_wrap_wxGridCellAttr_SetFont(PyObject *self, PyObject *args, PyObject *kwargs) {
3353     PyObject * _resultobj;
3354     wxGridCellAttr * _arg0;
3355     wxFont * _arg1;
3356     PyObject * _argo0 = 0;
3357     PyObject * _argo1 = 0;
3358     char *_kwnames[] = { "self","font", NULL };
3359
3360     self = self;
3361     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetFont",_kwnames,&_argo0,&_argo1))
3362         return NULL;
3363     if (_argo0) {
3364         if (_argo0 == Py_None) { _arg0 = NULL; }
3365         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3366             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetFont. Expected _wxGridCellAttr_p.");
3367         return NULL;
3368         }
3369     }
3370     if (_argo1) {
3371         if (_argo1 == Py_None) { _arg1 = NULL; }
3372         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
3373             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetFont. Expected _wxFont_p.");
3374         return NULL;
3375         }
3376     }
3377 {
3378     wxPy_BEGIN_ALLOW_THREADS;
3379         wxGridCellAttr_SetFont(_arg0,*_arg1);
3380
3381     wxPy_END_ALLOW_THREADS;
3382     if (PyErr_Occurred()) return NULL;
3383 }    Py_INCREF(Py_None);
3384     _resultobj = Py_None;
3385     return _resultobj;
3386 }
3387
3388 #define wxGridCellAttr_SetAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetAlignment(_swigarg0,_swigarg1))
3389 static PyObject *_wrap_wxGridCellAttr_SetAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
3390     PyObject * _resultobj;
3391     wxGridCellAttr * _arg0;
3392     int  _arg1;
3393     int  _arg2;
3394     PyObject * _argo0 = 0;
3395     char *_kwnames[] = { "self","hAlign","vAlign", NULL };
3396
3397     self = self;
3398     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGridCellAttr_SetAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
3399         return NULL;
3400     if (_argo0) {
3401         if (_argo0 == Py_None) { _arg0 = NULL; }
3402         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3403             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetAlignment. Expected _wxGridCellAttr_p.");
3404         return NULL;
3405         }
3406     }
3407 {
3408     wxPy_BEGIN_ALLOW_THREADS;
3409         wxGridCellAttr_SetAlignment(_arg0,_arg1,_arg2);
3410
3411     wxPy_END_ALLOW_THREADS;
3412     if (PyErr_Occurred()) return NULL;
3413 }    Py_INCREF(Py_None);
3414     _resultobj = Py_None;
3415     return _resultobj;
3416 }
3417
3418 #define wxGridCellAttr_SetReadOnly(_swigobj,_swigarg0)  (_swigobj->SetReadOnly(_swigarg0))
3419 static PyObject *_wrap_wxGridCellAttr_SetReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
3420     PyObject * _resultobj;
3421     wxGridCellAttr * _arg0;
3422     bool  _arg1 = (bool ) TRUE;
3423     PyObject * _argo0 = 0;
3424     int tempbool1 = (int) TRUE;
3425     char *_kwnames[] = { "self","isReadOnly", NULL };
3426
3427     self = self;
3428     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGridCellAttr_SetReadOnly",_kwnames,&_argo0,&tempbool1))
3429         return NULL;
3430     if (_argo0) {
3431         if (_argo0 == Py_None) { _arg0 = NULL; }
3432         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3433             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetReadOnly. Expected _wxGridCellAttr_p.");
3434         return NULL;
3435         }
3436     }
3437     _arg1 = (bool ) tempbool1;
3438 {
3439     wxPy_BEGIN_ALLOW_THREADS;
3440         wxGridCellAttr_SetReadOnly(_arg0,_arg1);
3441
3442     wxPy_END_ALLOW_THREADS;
3443     if (PyErr_Occurred()) return NULL;
3444 }    Py_INCREF(Py_None);
3445     _resultobj = Py_None;
3446     return _resultobj;
3447 }
3448
3449 #define wxGridCellAttr_SetRenderer(_swigobj,_swigarg0)  (_swigobj->SetRenderer(_swigarg0))
3450 static PyObject *_wrap_wxGridCellAttr_SetRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
3451     PyObject * _resultobj;
3452     wxGridCellAttr * _arg0;
3453     wxGridCellRenderer * _arg1;
3454     PyObject * _argo0 = 0;
3455     PyObject * _argo1 = 0;
3456     char *_kwnames[] = { "self","renderer", NULL };
3457
3458     self = self;
3459     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetRenderer",_kwnames,&_argo0,&_argo1))
3460         return NULL;
3461     if (_argo0) {
3462         if (_argo0 == Py_None) { _arg0 = NULL; }
3463         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3464             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetRenderer. Expected _wxGridCellAttr_p.");
3465         return NULL;
3466         }
3467     }
3468     if (_argo1) {
3469         if (_argo1 == Py_None) { _arg1 = NULL; }
3470         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellRenderer_p")) {
3471             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetRenderer. Expected _wxGridCellRenderer_p.");
3472         return NULL;
3473         }
3474     }
3475 {
3476     wxPy_BEGIN_ALLOW_THREADS;
3477         wxGridCellAttr_SetRenderer(_arg0,_arg1);
3478
3479     wxPy_END_ALLOW_THREADS;
3480     if (PyErr_Occurred()) return NULL;
3481 }    Py_INCREF(Py_None);
3482     _resultobj = Py_None;
3483     return _resultobj;
3484 }
3485
3486 #define wxGridCellAttr_SetEditor(_swigobj,_swigarg0)  (_swigobj->SetEditor(_swigarg0))
3487 static PyObject *_wrap_wxGridCellAttr_SetEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3488     PyObject * _resultobj;
3489     wxGridCellAttr * _arg0;
3490     wxGridCellEditor * _arg1;
3491     PyObject * _argo0 = 0;
3492     PyObject * _argo1 = 0;
3493     char *_kwnames[] = { "self","editor", NULL };
3494
3495     self = self;
3496     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridCellAttr_SetEditor",_kwnames,&_argo0,&_argo1))
3497         return NULL;
3498     if (_argo0) {
3499         if (_argo0 == Py_None) { _arg0 = NULL; }
3500         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3501             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetEditor. Expected _wxGridCellAttr_p.");
3502         return NULL;
3503         }
3504     }
3505     if (_argo1) {
3506         if (_argo1 == Py_None) { _arg1 = NULL; }
3507         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellEditor_p")) {
3508             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridCellAttr_SetEditor. Expected _wxGridCellEditor_p.");
3509         return NULL;
3510         }
3511     }
3512 {
3513     wxPy_BEGIN_ALLOW_THREADS;
3514         wxGridCellAttr_SetEditor(_arg0,_arg1);
3515
3516     wxPy_END_ALLOW_THREADS;
3517     if (PyErr_Occurred()) return NULL;
3518 }    Py_INCREF(Py_None);
3519     _resultobj = Py_None;
3520     return _resultobj;
3521 }
3522
3523 #define wxGridCellAttr_SetKind(_swigobj,_swigarg0)  (_swigobj->SetKind(_swigarg0))
3524 static PyObject *_wrap_wxGridCellAttr_SetKind(PyObject *self, PyObject *args, PyObject *kwargs) {
3525     PyObject * _resultobj;
3526     wxGridCellAttr * _arg0;
3527     wxGridCellAttr::wxAttrKind  _arg1;
3528     PyObject * _argo0 = 0;
3529     char *_kwnames[] = { "self","kind", NULL };
3530
3531     self = self;
3532     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridCellAttr_SetKind",_kwnames,&_argo0,&_arg1))
3533         return NULL;
3534     if (_argo0) {
3535         if (_argo0 == Py_None) { _arg0 = NULL; }
3536         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3537             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_SetKind. Expected _wxGridCellAttr_p.");
3538         return NULL;
3539         }
3540     }
3541 {
3542     wxPy_BEGIN_ALLOW_THREADS;
3543         wxGridCellAttr_SetKind(_arg0,_arg1);
3544
3545     wxPy_END_ALLOW_THREADS;
3546     if (PyErr_Occurred()) return NULL;
3547 }    Py_INCREF(Py_None);
3548     _resultobj = Py_None;
3549     return _resultobj;
3550 }
3551
3552 #define wxGridCellAttr_HasTextColour(_swigobj)  (_swigobj->HasTextColour())
3553 static PyObject *_wrap_wxGridCellAttr_HasTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3554     PyObject * _resultobj;
3555     bool  _result;
3556     wxGridCellAttr * _arg0;
3557     PyObject * _argo0 = 0;
3558     char *_kwnames[] = { "self", NULL };
3559
3560     self = self;
3561     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasTextColour",_kwnames,&_argo0))
3562         return NULL;
3563     if (_argo0) {
3564         if (_argo0 == Py_None) { _arg0 = NULL; }
3565         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3566             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasTextColour. Expected _wxGridCellAttr_p.");
3567         return NULL;
3568         }
3569     }
3570 {
3571     wxPy_BEGIN_ALLOW_THREADS;
3572         _result = (bool )wxGridCellAttr_HasTextColour(_arg0);
3573
3574     wxPy_END_ALLOW_THREADS;
3575     if (PyErr_Occurred()) return NULL;
3576 }    _resultobj = Py_BuildValue("i",_result);
3577     return _resultobj;
3578 }
3579
3580 #define wxGridCellAttr_HasBackgroundColour(_swigobj)  (_swigobj->HasBackgroundColour())
3581 static PyObject *_wrap_wxGridCellAttr_HasBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3582     PyObject * _resultobj;
3583     bool  _result;
3584     wxGridCellAttr * _arg0;
3585     PyObject * _argo0 = 0;
3586     char *_kwnames[] = { "self", NULL };
3587
3588     self = self;
3589     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasBackgroundColour",_kwnames,&_argo0))
3590         return NULL;
3591     if (_argo0) {
3592         if (_argo0 == Py_None) { _arg0 = NULL; }
3593         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3594             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasBackgroundColour. Expected _wxGridCellAttr_p.");
3595         return NULL;
3596         }
3597     }
3598 {
3599     wxPy_BEGIN_ALLOW_THREADS;
3600         _result = (bool )wxGridCellAttr_HasBackgroundColour(_arg0);
3601
3602     wxPy_END_ALLOW_THREADS;
3603     if (PyErr_Occurred()) return NULL;
3604 }    _resultobj = Py_BuildValue("i",_result);
3605     return _resultobj;
3606 }
3607
3608 #define wxGridCellAttr_HasFont(_swigobj)  (_swigobj->HasFont())
3609 static PyObject *_wrap_wxGridCellAttr_HasFont(PyObject *self, PyObject *args, PyObject *kwargs) {
3610     PyObject * _resultobj;
3611     bool  _result;
3612     wxGridCellAttr * _arg0;
3613     PyObject * _argo0 = 0;
3614     char *_kwnames[] = { "self", NULL };
3615
3616     self = self;
3617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasFont",_kwnames,&_argo0))
3618         return NULL;
3619     if (_argo0) {
3620         if (_argo0 == Py_None) { _arg0 = NULL; }
3621         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3622             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasFont. Expected _wxGridCellAttr_p.");
3623         return NULL;
3624         }
3625     }
3626 {
3627     wxPy_BEGIN_ALLOW_THREADS;
3628         _result = (bool )wxGridCellAttr_HasFont(_arg0);
3629
3630     wxPy_END_ALLOW_THREADS;
3631     if (PyErr_Occurred()) return NULL;
3632 }    _resultobj = Py_BuildValue("i",_result);
3633     return _resultobj;
3634 }
3635
3636 #define wxGridCellAttr_HasAlignment(_swigobj)  (_swigobj->HasAlignment())
3637 static PyObject *_wrap_wxGridCellAttr_HasAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
3638     PyObject * _resultobj;
3639     bool  _result;
3640     wxGridCellAttr * _arg0;
3641     PyObject * _argo0 = 0;
3642     char *_kwnames[] = { "self", NULL };
3643
3644     self = self;
3645     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasAlignment",_kwnames,&_argo0))
3646         return NULL;
3647     if (_argo0) {
3648         if (_argo0 == Py_None) { _arg0 = NULL; }
3649         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3650             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasAlignment. Expected _wxGridCellAttr_p.");
3651         return NULL;
3652         }
3653     }
3654 {
3655     wxPy_BEGIN_ALLOW_THREADS;
3656         _result = (bool )wxGridCellAttr_HasAlignment(_arg0);
3657
3658     wxPy_END_ALLOW_THREADS;
3659     if (PyErr_Occurred()) return NULL;
3660 }    _resultobj = Py_BuildValue("i",_result);
3661     return _resultobj;
3662 }
3663
3664 #define wxGridCellAttr_HasRenderer(_swigobj)  (_swigobj->HasRenderer())
3665 static PyObject *_wrap_wxGridCellAttr_HasRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
3666     PyObject * _resultobj;
3667     bool  _result;
3668     wxGridCellAttr * _arg0;
3669     PyObject * _argo0 = 0;
3670     char *_kwnames[] = { "self", NULL };
3671
3672     self = self;
3673     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasRenderer",_kwnames,&_argo0))
3674         return NULL;
3675     if (_argo0) {
3676         if (_argo0 == Py_None) { _arg0 = NULL; }
3677         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3678             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasRenderer. Expected _wxGridCellAttr_p.");
3679         return NULL;
3680         }
3681     }
3682 {
3683     wxPy_BEGIN_ALLOW_THREADS;
3684         _result = (bool )wxGridCellAttr_HasRenderer(_arg0);
3685
3686     wxPy_END_ALLOW_THREADS;
3687     if (PyErr_Occurred()) return NULL;
3688 }    _resultobj = Py_BuildValue("i",_result);
3689     return _resultobj;
3690 }
3691
3692 #define wxGridCellAttr_HasEditor(_swigobj)  (_swigobj->HasEditor())
3693 static PyObject *_wrap_wxGridCellAttr_HasEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
3694     PyObject * _resultobj;
3695     bool  _result;
3696     wxGridCellAttr * _arg0;
3697     PyObject * _argo0 = 0;
3698     char *_kwnames[] = { "self", NULL };
3699
3700     self = self;
3701     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasEditor",_kwnames,&_argo0))
3702         return NULL;
3703     if (_argo0) {
3704         if (_argo0 == Py_None) { _arg0 = NULL; }
3705         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3706             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasEditor. Expected _wxGridCellAttr_p.");
3707         return NULL;
3708         }
3709     }
3710 {
3711     wxPy_BEGIN_ALLOW_THREADS;
3712         _result = (bool )wxGridCellAttr_HasEditor(_arg0);
3713
3714     wxPy_END_ALLOW_THREADS;
3715     if (PyErr_Occurred()) return NULL;
3716 }    _resultobj = Py_BuildValue("i",_result);
3717     return _resultobj;
3718 }
3719
3720 #define wxGridCellAttr_HasReadWriteMode(_swigobj)  (_swigobj->HasReadWriteMode())
3721 static PyObject *_wrap_wxGridCellAttr_HasReadWriteMode(PyObject *self, PyObject *args, PyObject *kwargs) {
3722     PyObject * _resultobj;
3723     bool  _result;
3724     wxGridCellAttr * _arg0;
3725     PyObject * _argo0 = 0;
3726     char *_kwnames[] = { "self", NULL };
3727
3728     self = self;
3729     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_HasReadWriteMode",_kwnames,&_argo0))
3730         return NULL;
3731     if (_argo0) {
3732         if (_argo0 == Py_None) { _arg0 = NULL; }
3733         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3734             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_HasReadWriteMode. Expected _wxGridCellAttr_p.");
3735         return NULL;
3736         }
3737     }
3738 {
3739     wxPy_BEGIN_ALLOW_THREADS;
3740         _result = (bool )wxGridCellAttr_HasReadWriteMode(_arg0);
3741
3742     wxPy_END_ALLOW_THREADS;
3743     if (PyErr_Occurred()) return NULL;
3744 }    _resultobj = Py_BuildValue("i",_result);
3745     return _resultobj;
3746 }
3747
3748 #define wxGridCellAttr_GetTextColour(_swigobj)  (_swigobj->GetTextColour())
3749 static PyObject *_wrap_wxGridCellAttr_GetTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
3750     PyObject * _resultobj;
3751     wxColour * _result;
3752     wxGridCellAttr * _arg0;
3753     PyObject * _argo0 = 0;
3754     char *_kwnames[] = { "self", NULL };
3755     char _ptemp[128];
3756
3757     self = self;
3758     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridCellAttr_GetTextColour",_kwnames,&_argo0))
3759         return NULL;
3760     if (_argo0) {
3761         if (_argo0 == Py_None) { _arg0 = NULL; }
3762         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridCellAttr_p")) {
3763             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridCellAttr_GetTextColour. Expected _wxGridCellAttr_p.");
3764         return NULL;
3765         }
3766     }
3767 {
3768     wxPy_BEGIN_ALLOW_THREADS;
3769         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__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
4335 static PyObject *_wrap_wxPyGridCellAttrProvider__setCallbackInfo(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__setCallbackInfo",_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__setCallbackInfo. 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__setCallbackInfo(_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__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
5777 static PyObject *_wrap_wxPyGridTableBase__setCallbackInfo(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__setCallbackInfo",_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__setCallbackInfo. 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__setCallbackInfo(_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_GetTextBoxSize(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetTextBoxSize(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
7826 static PyObject *_wrap_wxGrid_GetTextBoxSize(PyObject *self, PyObject *args, PyObject *kwargs) {
7827     PyObject * _resultobj;
7828     wxGrid * _arg0;
7829     wxDC * _arg1;
7830     wxArrayString * _arg2;
7831     long * _arg3;
7832     long  temp;
7833     long * _arg4;
7834     long  temp0;
7835     PyObject * _argo0 = 0;
7836     PyObject * _argo1 = 0;
7837     PyObject * _obj2 = 0;
7838     char *_kwnames[] = { "self","dc","lines", NULL };
7839
7840     self = self;
7841 {
7842   _arg3 = &temp;
7843 }
7844 {
7845   _arg4 = &temp0;
7846 }
7847     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetTextBoxSize",_kwnames,&_argo0,&_argo1,&_obj2))
7848         return NULL;
7849     if (_argo0) {
7850         if (_argo0 == Py_None) { _arg0 = NULL; }
7851         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7852             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetTextBoxSize. Expected _wxGrid_p.");
7853         return NULL;
7854         }
7855     }
7856     if (_argo1) {
7857         if (_argo1 == Py_None) { _arg1 = NULL; }
7858         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxDC_p")) {
7859             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_GetTextBoxSize. Expected _wxDC_p.");
7860         return NULL;
7861         }
7862     }
7863 {
7864     if (! PySequence_Check(_obj2)) {
7865         PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
7866         return NULL;
7867     }
7868     _arg2 = new wxArrayString;
7869     int i, len=PySequence_Length(_obj2);
7870     for (i=0; i<len; i++) {
7871         PyObject* item = PySequence_GetItem(_obj2, i);
7872         PyObject* str  = PyObject_Str(item);
7873         _arg2->Add(PyString_AsString(item));
7874         Py_DECREF(item);
7875         Py_DECREF(str);
7876     }
7877 }
7878 {
7879     wxPy_BEGIN_ALLOW_THREADS;
7880         wxGrid_GetTextBoxSize(_arg0,*_arg1,*_arg2,_arg3,_arg4);
7881
7882     wxPy_END_ALLOW_THREADS;
7883     if (PyErr_Occurred()) return NULL;
7884 }    Py_INCREF(Py_None);
7885     _resultobj = Py_None;
7886 {
7887     PyObject *o;
7888     o = PyInt_FromLong((long) (*_arg3));
7889     _resultobj = t_output_helper(_resultobj, o);
7890 }
7891 {
7892     PyObject *o;
7893     o = PyInt_FromLong((long) (*_arg4));
7894     _resultobj = t_output_helper(_resultobj, o);
7895 }
7896 {
7897     if (_obj2)
7898         delete _arg2;
7899 }
7900     return _resultobj;
7901 }
7902
7903 #define wxGrid_BeginBatch(_swigobj)  (_swigobj->BeginBatch())
7904 static PyObject *_wrap_wxGrid_BeginBatch(PyObject *self, PyObject *args, PyObject *kwargs) {
7905     PyObject * _resultobj;
7906     wxGrid * _arg0;
7907     PyObject * _argo0 = 0;
7908     char *_kwnames[] = { "self", NULL };
7909
7910     self = self;
7911     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_BeginBatch",_kwnames,&_argo0))
7912         return NULL;
7913     if (_argo0) {
7914         if (_argo0 == Py_None) { _arg0 = NULL; }
7915         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7916             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_BeginBatch. Expected _wxGrid_p.");
7917         return NULL;
7918         }
7919     }
7920 {
7921     wxPy_BEGIN_ALLOW_THREADS;
7922         wxGrid_BeginBatch(_arg0);
7923
7924     wxPy_END_ALLOW_THREADS;
7925     if (PyErr_Occurred()) return NULL;
7926 }    Py_INCREF(Py_None);
7927     _resultobj = Py_None;
7928     return _resultobj;
7929 }
7930
7931 #define wxGrid_EndBatch(_swigobj)  (_swigobj->EndBatch())
7932 static PyObject *_wrap_wxGrid_EndBatch(PyObject *self, PyObject *args, PyObject *kwargs) {
7933     PyObject * _resultobj;
7934     wxGrid * _arg0;
7935     PyObject * _argo0 = 0;
7936     char *_kwnames[] = { "self", NULL };
7937
7938     self = self;
7939     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_EndBatch",_kwnames,&_argo0))
7940         return NULL;
7941     if (_argo0) {
7942         if (_argo0 == Py_None) { _arg0 = NULL; }
7943         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7944             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EndBatch. Expected _wxGrid_p.");
7945         return NULL;
7946         }
7947     }
7948 {
7949     wxPy_BEGIN_ALLOW_THREADS;
7950         wxGrid_EndBatch(_arg0);
7951
7952     wxPy_END_ALLOW_THREADS;
7953     if (PyErr_Occurred()) return NULL;
7954 }    Py_INCREF(Py_None);
7955     _resultobj = Py_None;
7956     return _resultobj;
7957 }
7958
7959 #define wxGrid_GetBatchCount(_swigobj)  (_swigobj->GetBatchCount())
7960 static PyObject *_wrap_wxGrid_GetBatchCount(PyObject *self, PyObject *args, PyObject *kwargs) {
7961     PyObject * _resultobj;
7962     int  _result;
7963     wxGrid * _arg0;
7964     PyObject * _argo0 = 0;
7965     char *_kwnames[] = { "self", NULL };
7966
7967     self = self;
7968     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetBatchCount",_kwnames,&_argo0))
7969         return NULL;
7970     if (_argo0) {
7971         if (_argo0 == Py_None) { _arg0 = NULL; }
7972         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
7973             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetBatchCount. Expected _wxGrid_p.");
7974         return NULL;
7975         }
7976     }
7977 {
7978     wxPy_BEGIN_ALLOW_THREADS;
7979         _result = (int )wxGrid_GetBatchCount(_arg0);
7980
7981     wxPy_END_ALLOW_THREADS;
7982     if (PyErr_Occurred()) return NULL;
7983 }    _resultobj = Py_BuildValue("i",_result);
7984     return _resultobj;
7985 }
7986
7987 #define wxGrid_ForceRefresh(_swigobj)  (_swigobj->ForceRefresh())
7988 static PyObject *_wrap_wxGrid_ForceRefresh(PyObject *self, PyObject *args, PyObject *kwargs) {
7989     PyObject * _resultobj;
7990     wxGrid * _arg0;
7991     PyObject * _argo0 = 0;
7992     char *_kwnames[] = { "self", NULL };
7993
7994     self = self;
7995     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ForceRefresh",_kwnames,&_argo0))
7996         return NULL;
7997     if (_argo0) {
7998         if (_argo0 == Py_None) { _arg0 = NULL; }
7999         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8000             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ForceRefresh. Expected _wxGrid_p.");
8001         return NULL;
8002         }
8003     }
8004 {
8005     wxPy_BEGIN_ALLOW_THREADS;
8006         wxGrid_ForceRefresh(_arg0);
8007
8008     wxPy_END_ALLOW_THREADS;
8009     if (PyErr_Occurred()) return NULL;
8010 }    Py_INCREF(Py_None);
8011     _resultobj = Py_None;
8012     return _resultobj;
8013 }
8014
8015 #define wxGrid_IsEditable(_swigobj)  (_swigobj->IsEditable())
8016 static PyObject *_wrap_wxGrid_IsEditable(PyObject *self, PyObject *args, PyObject *kwargs) {
8017     PyObject * _resultobj;
8018     bool  _result;
8019     wxGrid * _arg0;
8020     PyObject * _argo0 = 0;
8021     char *_kwnames[] = { "self", NULL };
8022
8023     self = self;
8024     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsEditable",_kwnames,&_argo0))
8025         return NULL;
8026     if (_argo0) {
8027         if (_argo0 == Py_None) { _arg0 = NULL; }
8028         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8029             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsEditable. Expected _wxGrid_p.");
8030         return NULL;
8031         }
8032     }
8033 {
8034     wxPy_BEGIN_ALLOW_THREADS;
8035         _result = (bool )wxGrid_IsEditable(_arg0);
8036
8037     wxPy_END_ALLOW_THREADS;
8038     if (PyErr_Occurred()) return NULL;
8039 }    _resultobj = Py_BuildValue("i",_result);
8040     return _resultobj;
8041 }
8042
8043 #define wxGrid_EnableEditing(_swigobj,_swigarg0)  (_swigobj->EnableEditing(_swigarg0))
8044 static PyObject *_wrap_wxGrid_EnableEditing(PyObject *self, PyObject *args, PyObject *kwargs) {
8045     PyObject * _resultobj;
8046     wxGrid * _arg0;
8047     bool  _arg1;
8048     PyObject * _argo0 = 0;
8049     int tempbool1;
8050     char *_kwnames[] = { "self","edit", NULL };
8051
8052     self = self;
8053     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_EnableEditing",_kwnames,&_argo0,&tempbool1))
8054         return NULL;
8055     if (_argo0) {
8056         if (_argo0 == Py_None) { _arg0 = NULL; }
8057         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8058             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableEditing. Expected _wxGrid_p.");
8059         return NULL;
8060         }
8061     }
8062     _arg1 = (bool ) tempbool1;
8063 {
8064     wxPy_BEGIN_ALLOW_THREADS;
8065         wxGrid_EnableEditing(_arg0,_arg1);
8066
8067     wxPy_END_ALLOW_THREADS;
8068     if (PyErr_Occurred()) return NULL;
8069 }    Py_INCREF(Py_None);
8070     _resultobj = Py_None;
8071     return _resultobj;
8072 }
8073
8074 #define wxGrid_EnableCellEditControl(_swigobj,_swigarg0)  (_swigobj->EnableCellEditControl(_swigarg0))
8075 static PyObject *_wrap_wxGrid_EnableCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8076     PyObject * _resultobj;
8077     wxGrid * _arg0;
8078     bool  _arg1 = (bool ) TRUE;
8079     PyObject * _argo0 = 0;
8080     int tempbool1 = (int) TRUE;
8081     char *_kwnames[] = { "self","enable", NULL };
8082
8083     self = self;
8084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableCellEditControl",_kwnames,&_argo0,&tempbool1))
8085         return NULL;
8086     if (_argo0) {
8087         if (_argo0 == Py_None) { _arg0 = NULL; }
8088         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8089             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableCellEditControl. Expected _wxGrid_p.");
8090         return NULL;
8091         }
8092     }
8093     _arg1 = (bool ) tempbool1;
8094 {
8095     wxPy_BEGIN_ALLOW_THREADS;
8096         wxGrid_EnableCellEditControl(_arg0,_arg1);
8097
8098     wxPy_END_ALLOW_THREADS;
8099     if (PyErr_Occurred()) return NULL;
8100 }    Py_INCREF(Py_None);
8101     _resultobj = Py_None;
8102     return _resultobj;
8103 }
8104
8105 #define wxGrid_DisableCellEditControl(_swigobj)  (_swigobj->DisableCellEditControl())
8106 static PyObject *_wrap_wxGrid_DisableCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8107     PyObject * _resultobj;
8108     wxGrid * _arg0;
8109     PyObject * _argo0 = 0;
8110     char *_kwnames[] = { "self", NULL };
8111
8112     self = self;
8113     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableCellEditControl",_kwnames,&_argo0))
8114         return NULL;
8115     if (_argo0) {
8116         if (_argo0 == Py_None) { _arg0 = NULL; }
8117         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8118             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableCellEditControl. Expected _wxGrid_p.");
8119         return NULL;
8120         }
8121     }
8122 {
8123     wxPy_BEGIN_ALLOW_THREADS;
8124         wxGrid_DisableCellEditControl(_arg0);
8125
8126     wxPy_END_ALLOW_THREADS;
8127     if (PyErr_Occurred()) return NULL;
8128 }    Py_INCREF(Py_None);
8129     _resultobj = Py_None;
8130     return _resultobj;
8131 }
8132
8133 #define wxGrid_CanEnableCellControl(_swigobj)  (_swigobj->CanEnableCellControl())
8134 static PyObject *_wrap_wxGrid_CanEnableCellControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8135     PyObject * _resultobj;
8136     bool  _result;
8137     wxGrid * _arg0;
8138     PyObject * _argo0 = 0;
8139     char *_kwnames[] = { "self", NULL };
8140
8141     self = self;
8142     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanEnableCellControl",_kwnames,&_argo0))
8143         return NULL;
8144     if (_argo0) {
8145         if (_argo0 == Py_None) { _arg0 = NULL; }
8146         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8147             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanEnableCellControl. Expected _wxGrid_p.");
8148         return NULL;
8149         }
8150     }
8151 {
8152     wxPy_BEGIN_ALLOW_THREADS;
8153         _result = (bool )wxGrid_CanEnableCellControl(_arg0);
8154
8155     wxPy_END_ALLOW_THREADS;
8156     if (PyErr_Occurred()) return NULL;
8157 }    _resultobj = Py_BuildValue("i",_result);
8158     return _resultobj;
8159 }
8160
8161 #define wxGrid_IsCellEditControlEnabled(_swigobj)  (_swigobj->IsCellEditControlEnabled())
8162 static PyObject *_wrap_wxGrid_IsCellEditControlEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
8163     PyObject * _resultobj;
8164     bool  _result;
8165     wxGrid * _arg0;
8166     PyObject * _argo0 = 0;
8167     char *_kwnames[] = { "self", NULL };
8168
8169     self = self;
8170     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCellEditControlEnabled",_kwnames,&_argo0))
8171         return NULL;
8172     if (_argo0) {
8173         if (_argo0 == Py_None) { _arg0 = NULL; }
8174         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8175             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCellEditControlEnabled. Expected _wxGrid_p.");
8176         return NULL;
8177         }
8178     }
8179 {
8180     wxPy_BEGIN_ALLOW_THREADS;
8181         _result = (bool )wxGrid_IsCellEditControlEnabled(_arg0);
8182
8183     wxPy_END_ALLOW_THREADS;
8184     if (PyErr_Occurred()) return NULL;
8185 }    _resultobj = Py_BuildValue("i",_result);
8186     return _resultobj;
8187 }
8188
8189 #define wxGrid_IsCellEditControlShown(_swigobj)  (_swigobj->IsCellEditControlShown())
8190 static PyObject *_wrap_wxGrid_IsCellEditControlShown(PyObject *self, PyObject *args, PyObject *kwargs) {
8191     PyObject * _resultobj;
8192     bool  _result;
8193     wxGrid * _arg0;
8194     PyObject * _argo0 = 0;
8195     char *_kwnames[] = { "self", NULL };
8196
8197     self = self;
8198     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCellEditControlShown",_kwnames,&_argo0))
8199         return NULL;
8200     if (_argo0) {
8201         if (_argo0 == Py_None) { _arg0 = NULL; }
8202         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8203             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCellEditControlShown. Expected _wxGrid_p.");
8204         return NULL;
8205         }
8206     }
8207 {
8208     wxPy_BEGIN_ALLOW_THREADS;
8209         _result = (bool )wxGrid_IsCellEditControlShown(_arg0);
8210
8211     wxPy_END_ALLOW_THREADS;
8212     if (PyErr_Occurred()) return NULL;
8213 }    _resultobj = Py_BuildValue("i",_result);
8214     return _resultobj;
8215 }
8216
8217 #define wxGrid_IsCurrentCellReadOnly(_swigobj)  (_swigobj->IsCurrentCellReadOnly())
8218 static PyObject *_wrap_wxGrid_IsCurrentCellReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
8219     PyObject * _resultobj;
8220     bool  _result;
8221     wxGrid * _arg0;
8222     PyObject * _argo0 = 0;
8223     char *_kwnames[] = { "self", NULL };
8224
8225     self = self;
8226     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsCurrentCellReadOnly",_kwnames,&_argo0))
8227         return NULL;
8228     if (_argo0) {
8229         if (_argo0 == Py_None) { _arg0 = NULL; }
8230         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8231             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsCurrentCellReadOnly. Expected _wxGrid_p.");
8232         return NULL;
8233         }
8234     }
8235 {
8236     wxPy_BEGIN_ALLOW_THREADS;
8237         _result = (bool )wxGrid_IsCurrentCellReadOnly(_arg0);
8238
8239     wxPy_END_ALLOW_THREADS;
8240     if (PyErr_Occurred()) return NULL;
8241 }    _resultobj = Py_BuildValue("i",_result);
8242     return _resultobj;
8243 }
8244
8245 #define wxGrid_ShowCellEditControl(_swigobj)  (_swigobj->ShowCellEditControl())
8246 static PyObject *_wrap_wxGrid_ShowCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8247     PyObject * _resultobj;
8248     wxGrid * _arg0;
8249     PyObject * _argo0 = 0;
8250     char *_kwnames[] = { "self", NULL };
8251
8252     self = self;
8253     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ShowCellEditControl",_kwnames,&_argo0))
8254         return NULL;
8255     if (_argo0) {
8256         if (_argo0 == Py_None) { _arg0 = NULL; }
8257         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8258             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ShowCellEditControl. Expected _wxGrid_p.");
8259         return NULL;
8260         }
8261     }
8262 {
8263     wxPy_BEGIN_ALLOW_THREADS;
8264         wxGrid_ShowCellEditControl(_arg0);
8265
8266     wxPy_END_ALLOW_THREADS;
8267     if (PyErr_Occurred()) return NULL;
8268 }    Py_INCREF(Py_None);
8269     _resultobj = Py_None;
8270     return _resultobj;
8271 }
8272
8273 #define wxGrid_HideCellEditControl(_swigobj)  (_swigobj->HideCellEditControl())
8274 static PyObject *_wrap_wxGrid_HideCellEditControl(PyObject *self, PyObject *args, PyObject *kwargs) {
8275     PyObject * _resultobj;
8276     wxGrid * _arg0;
8277     PyObject * _argo0 = 0;
8278     char *_kwnames[] = { "self", NULL };
8279
8280     self = self;
8281     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_HideCellEditControl",_kwnames,&_argo0))
8282         return NULL;
8283     if (_argo0) {
8284         if (_argo0 == Py_None) { _arg0 = NULL; }
8285         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8286             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_HideCellEditControl. Expected _wxGrid_p.");
8287         return NULL;
8288         }
8289     }
8290 {
8291     wxPy_BEGIN_ALLOW_THREADS;
8292         wxGrid_HideCellEditControl(_arg0);
8293
8294     wxPy_END_ALLOW_THREADS;
8295     if (PyErr_Occurred()) return NULL;
8296 }    Py_INCREF(Py_None);
8297     _resultobj = Py_None;
8298     return _resultobj;
8299 }
8300
8301 #define wxGrid_SaveEditControlValue(_swigobj)  (_swigobj->SaveEditControlValue())
8302 static PyObject *_wrap_wxGrid_SaveEditControlValue(PyObject *self, PyObject *args, PyObject *kwargs) {
8303     PyObject * _resultobj;
8304     wxGrid * _arg0;
8305     PyObject * _argo0 = 0;
8306     char *_kwnames[] = { "self", NULL };
8307
8308     self = self;
8309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_SaveEditControlValue",_kwnames,&_argo0))
8310         return NULL;
8311     if (_argo0) {
8312         if (_argo0 == Py_None) { _arg0 = NULL; }
8313         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8314             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SaveEditControlValue. Expected _wxGrid_p.");
8315         return NULL;
8316         }
8317     }
8318 {
8319     wxPy_BEGIN_ALLOW_THREADS;
8320         wxGrid_SaveEditControlValue(_arg0);
8321
8322     wxPy_END_ALLOW_THREADS;
8323     if (PyErr_Occurred()) return NULL;
8324 }    Py_INCREF(Py_None);
8325     _resultobj = Py_None;
8326     return _resultobj;
8327 }
8328
8329 static wxGridCellCoords * wxGrid_XYToCell(wxGrid *self,int  x,int  y) {
8330             wxGridCellCoords rv;
8331             self->XYToCell(x, y, rv);
8332             return new wxGridCellCoords(rv);
8333         }
8334 static PyObject *_wrap_wxGrid_XYToCell(PyObject *self, PyObject *args, PyObject *kwargs) {
8335     PyObject * _resultobj;
8336     wxGridCellCoords * _result;
8337     wxGrid * _arg0;
8338     int  _arg1;
8339     int  _arg2;
8340     PyObject * _argo0 = 0;
8341     char *_kwnames[] = { "self","x","y", NULL };
8342     char _ptemp[128];
8343
8344     self = self;
8345     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_XYToCell",_kwnames,&_argo0,&_arg1,&_arg2))
8346         return NULL;
8347     if (_argo0) {
8348         if (_argo0 == Py_None) { _arg0 = NULL; }
8349         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8350             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XYToCell. Expected _wxGrid_p.");
8351         return NULL;
8352         }
8353     }
8354 {
8355     wxPy_BEGIN_ALLOW_THREADS;
8356         _result = (wxGridCellCoords *)wxGrid_XYToCell(_arg0,_arg1,_arg2);
8357
8358     wxPy_END_ALLOW_THREADS;
8359     if (PyErr_Occurred()) return NULL;
8360 }    if (_result) {
8361         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellCoords_p");
8362         _resultobj = Py_BuildValue("s",_ptemp);
8363     } else {
8364         Py_INCREF(Py_None);
8365         _resultobj = Py_None;
8366     }
8367     return _resultobj;
8368 }
8369
8370 #define wxGrid_YToRow(_swigobj,_swigarg0)  (_swigobj->YToRow(_swigarg0))
8371 static PyObject *_wrap_wxGrid_YToRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8372     PyObject * _resultobj;
8373     int  _result;
8374     wxGrid * _arg0;
8375     int  _arg1;
8376     PyObject * _argo0 = 0;
8377     char *_kwnames[] = { "self","y", NULL };
8378
8379     self = self;
8380     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_YToRow",_kwnames,&_argo0,&_arg1))
8381         return NULL;
8382     if (_argo0) {
8383         if (_argo0 == Py_None) { _arg0 = NULL; }
8384         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8385             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_YToRow. Expected _wxGrid_p.");
8386         return NULL;
8387         }
8388     }
8389 {
8390     wxPy_BEGIN_ALLOW_THREADS;
8391         _result = (int )wxGrid_YToRow(_arg0,_arg1);
8392
8393     wxPy_END_ALLOW_THREADS;
8394     if (PyErr_Occurred()) return NULL;
8395 }    _resultobj = Py_BuildValue("i",_result);
8396     return _resultobj;
8397 }
8398
8399 #define wxGrid_XToCol(_swigobj,_swigarg0)  (_swigobj->XToCol(_swigarg0))
8400 static PyObject *_wrap_wxGrid_XToCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8401     PyObject * _resultobj;
8402     int  _result;
8403     wxGrid * _arg0;
8404     int  _arg1;
8405     PyObject * _argo0 = 0;
8406     char *_kwnames[] = { "self","x", NULL };
8407
8408     self = self;
8409     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_XToCol",_kwnames,&_argo0,&_arg1))
8410         return NULL;
8411     if (_argo0) {
8412         if (_argo0 == Py_None) { _arg0 = NULL; }
8413         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8414             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XToCol. Expected _wxGrid_p.");
8415         return NULL;
8416         }
8417     }
8418 {
8419     wxPy_BEGIN_ALLOW_THREADS;
8420         _result = (int )wxGrid_XToCol(_arg0,_arg1);
8421
8422     wxPy_END_ALLOW_THREADS;
8423     if (PyErr_Occurred()) return NULL;
8424 }    _resultobj = Py_BuildValue("i",_result);
8425     return _resultobj;
8426 }
8427
8428 #define wxGrid_YToEdgeOfRow(_swigobj,_swigarg0)  (_swigobj->YToEdgeOfRow(_swigarg0))
8429 static PyObject *_wrap_wxGrid_YToEdgeOfRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8430     PyObject * _resultobj;
8431     int  _result;
8432     wxGrid * _arg0;
8433     int  _arg1;
8434     PyObject * _argo0 = 0;
8435     char *_kwnames[] = { "self","y", NULL };
8436
8437     self = self;
8438     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_YToEdgeOfRow",_kwnames,&_argo0,&_arg1))
8439         return NULL;
8440     if (_argo0) {
8441         if (_argo0 == Py_None) { _arg0 = NULL; }
8442         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8443             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_YToEdgeOfRow. Expected _wxGrid_p.");
8444         return NULL;
8445         }
8446     }
8447 {
8448     wxPy_BEGIN_ALLOW_THREADS;
8449         _result = (int )wxGrid_YToEdgeOfRow(_arg0,_arg1);
8450
8451     wxPy_END_ALLOW_THREADS;
8452     if (PyErr_Occurred()) return NULL;
8453 }    _resultobj = Py_BuildValue("i",_result);
8454     return _resultobj;
8455 }
8456
8457 #define wxGrid_XToEdgeOfCol(_swigobj,_swigarg0)  (_swigobj->XToEdgeOfCol(_swigarg0))
8458 static PyObject *_wrap_wxGrid_XToEdgeOfCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8459     PyObject * _resultobj;
8460     int  _result;
8461     wxGrid * _arg0;
8462     int  _arg1;
8463     PyObject * _argo0 = 0;
8464     char *_kwnames[] = { "self","x", NULL };
8465
8466     self = self;
8467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_XToEdgeOfCol",_kwnames,&_argo0,&_arg1))
8468         return NULL;
8469     if (_argo0) {
8470         if (_argo0 == Py_None) { _arg0 = NULL; }
8471         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8472             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_XToEdgeOfCol. Expected _wxGrid_p.");
8473         return NULL;
8474         }
8475     }
8476 {
8477     wxPy_BEGIN_ALLOW_THREADS;
8478         _result = (int )wxGrid_XToEdgeOfCol(_arg0,_arg1);
8479
8480     wxPy_END_ALLOW_THREADS;
8481     if (PyErr_Occurred()) return NULL;
8482 }    _resultobj = Py_BuildValue("i",_result);
8483     return _resultobj;
8484 }
8485
8486 #define wxGrid_CellToRect(_swigobj,_swigarg0,_swigarg1)  (_swigobj->CellToRect(_swigarg0,_swigarg1))
8487 static PyObject *_wrap_wxGrid_CellToRect(PyObject *self, PyObject *args, PyObject *kwargs) {
8488     PyObject * _resultobj;
8489     wxRect * _result;
8490     wxGrid * _arg0;
8491     int  _arg1;
8492     int  _arg2;
8493     PyObject * _argo0 = 0;
8494     char *_kwnames[] = { "self","row","col", NULL };
8495     char _ptemp[128];
8496
8497     self = self;
8498     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_CellToRect",_kwnames,&_argo0,&_arg1,&_arg2))
8499         return NULL;
8500     if (_argo0) {
8501         if (_argo0 == Py_None) { _arg0 = NULL; }
8502         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8503             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CellToRect. Expected _wxGrid_p.");
8504         return NULL;
8505         }
8506     }
8507 {
8508     wxPy_BEGIN_ALLOW_THREADS;
8509         _result = new wxRect (wxGrid_CellToRect(_arg0,_arg1,_arg2));
8510
8511     wxPy_END_ALLOW_THREADS;
8512     if (PyErr_Occurred()) return NULL;
8513 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
8514     _resultobj = Py_BuildValue("s",_ptemp);
8515     return _resultobj;
8516 }
8517
8518 #define wxGrid_GetGridCursorRow(_swigobj)  (_swigobj->GetGridCursorRow())
8519 static PyObject *_wrap_wxGrid_GetGridCursorRow(PyObject *self, PyObject *args, PyObject *kwargs) {
8520     PyObject * _resultobj;
8521     int  _result;
8522     wxGrid * _arg0;
8523     PyObject * _argo0 = 0;
8524     char *_kwnames[] = { "self", NULL };
8525
8526     self = self;
8527     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCursorRow",_kwnames,&_argo0))
8528         return NULL;
8529     if (_argo0) {
8530         if (_argo0 == Py_None) { _arg0 = NULL; }
8531         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8532             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCursorRow. Expected _wxGrid_p.");
8533         return NULL;
8534         }
8535     }
8536 {
8537     wxPy_BEGIN_ALLOW_THREADS;
8538         _result = (int )wxGrid_GetGridCursorRow(_arg0);
8539
8540     wxPy_END_ALLOW_THREADS;
8541     if (PyErr_Occurred()) return NULL;
8542 }    _resultobj = Py_BuildValue("i",_result);
8543     return _resultobj;
8544 }
8545
8546 #define wxGrid_GetGridCursorCol(_swigobj)  (_swigobj->GetGridCursorCol())
8547 static PyObject *_wrap_wxGrid_GetGridCursorCol(PyObject *self, PyObject *args, PyObject *kwargs) {
8548     PyObject * _resultobj;
8549     int  _result;
8550     wxGrid * _arg0;
8551     PyObject * _argo0 = 0;
8552     char *_kwnames[] = { "self", NULL };
8553
8554     self = self;
8555     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCursorCol",_kwnames,&_argo0))
8556         return NULL;
8557     if (_argo0) {
8558         if (_argo0 == Py_None) { _arg0 = NULL; }
8559         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8560             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCursorCol. Expected _wxGrid_p.");
8561         return NULL;
8562         }
8563     }
8564 {
8565     wxPy_BEGIN_ALLOW_THREADS;
8566         _result = (int )wxGrid_GetGridCursorCol(_arg0);
8567
8568     wxPy_END_ALLOW_THREADS;
8569     if (PyErr_Occurred()) return NULL;
8570 }    _resultobj = Py_BuildValue("i",_result);
8571     return _resultobj;
8572 }
8573
8574 #define wxGrid_IsVisible(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->IsVisible(_swigarg0,_swigarg1,_swigarg2))
8575 static PyObject *_wrap_wxGrid_IsVisible(PyObject *self, PyObject *args, PyObject *kwargs) {
8576     PyObject * _resultobj;
8577     bool  _result;
8578     wxGrid * _arg0;
8579     int  _arg1;
8580     int  _arg2;
8581     bool  _arg3 = (bool ) TRUE;
8582     PyObject * _argo0 = 0;
8583     int tempbool3 = (int) TRUE;
8584     char *_kwnames[] = { "self","row","col","wholeCellVisible", NULL };
8585
8586     self = self;
8587     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_IsVisible",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
8588         return NULL;
8589     if (_argo0) {
8590         if (_argo0 == Py_None) { _arg0 = NULL; }
8591         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8592             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsVisible. Expected _wxGrid_p.");
8593         return NULL;
8594         }
8595     }
8596     _arg3 = (bool ) tempbool3;
8597 {
8598     wxPy_BEGIN_ALLOW_THREADS;
8599         _result = (bool )wxGrid_IsVisible(_arg0,_arg1,_arg2,_arg3);
8600
8601     wxPy_END_ALLOW_THREADS;
8602     if (PyErr_Occurred()) return NULL;
8603 }    _resultobj = Py_BuildValue("i",_result);
8604     return _resultobj;
8605 }
8606
8607 #define wxGrid_MakeCellVisible(_swigobj,_swigarg0,_swigarg1)  (_swigobj->MakeCellVisible(_swigarg0,_swigarg1))
8608 static PyObject *_wrap_wxGrid_MakeCellVisible(PyObject *self, PyObject *args, PyObject *kwargs) {
8609     PyObject * _resultobj;
8610     wxGrid * _arg0;
8611     int  _arg1;
8612     int  _arg2;
8613     PyObject * _argo0 = 0;
8614     char *_kwnames[] = { "self","row","col", NULL };
8615
8616     self = self;
8617     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_MakeCellVisible",_kwnames,&_argo0,&_arg1,&_arg2))
8618         return NULL;
8619     if (_argo0) {
8620         if (_argo0 == Py_None) { _arg0 = NULL; }
8621         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8622             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MakeCellVisible. Expected _wxGrid_p.");
8623         return NULL;
8624         }
8625     }
8626 {
8627     wxPy_BEGIN_ALLOW_THREADS;
8628         wxGrid_MakeCellVisible(_arg0,_arg1,_arg2);
8629
8630     wxPy_END_ALLOW_THREADS;
8631     if (PyErr_Occurred()) return NULL;
8632 }    Py_INCREF(Py_None);
8633     _resultobj = Py_None;
8634     return _resultobj;
8635 }
8636
8637 #define wxGrid_SetGridCursor(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetGridCursor(_swigarg0,_swigarg1))
8638 static PyObject *_wrap_wxGrid_SetGridCursor(PyObject *self, PyObject *args, PyObject *kwargs) {
8639     PyObject * _resultobj;
8640     wxGrid * _arg0;
8641     int  _arg1;
8642     int  _arg2;
8643     PyObject * _argo0 = 0;
8644     char *_kwnames[] = { "self","row","col", NULL };
8645
8646     self = self;
8647     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetGridCursor",_kwnames,&_argo0,&_arg1,&_arg2))
8648         return NULL;
8649     if (_argo0) {
8650         if (_argo0 == Py_None) { _arg0 = NULL; }
8651         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8652             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetGridCursor. Expected _wxGrid_p.");
8653         return NULL;
8654         }
8655     }
8656 {
8657     wxPy_BEGIN_ALLOW_THREADS;
8658         wxGrid_SetGridCursor(_arg0,_arg1,_arg2);
8659
8660     wxPy_END_ALLOW_THREADS;
8661     if (PyErr_Occurred()) return NULL;
8662 }    Py_INCREF(Py_None);
8663     _resultobj = Py_None;
8664     return _resultobj;
8665 }
8666
8667 #define wxGrid_MoveCursorUp(_swigobj,_swigarg0)  (_swigobj->MoveCursorUp(_swigarg0))
8668 static PyObject *_wrap_wxGrid_MoveCursorUp(PyObject *self, PyObject *args, PyObject *kwargs) {
8669     PyObject * _resultobj;
8670     bool  _result;
8671     wxGrid * _arg0;
8672     bool  _arg1;
8673     PyObject * _argo0 = 0;
8674     int tempbool1;
8675     char *_kwnames[] = { "self","expandSelection", NULL };
8676
8677     self = self;
8678     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorUp",_kwnames,&_argo0,&tempbool1))
8679         return NULL;
8680     if (_argo0) {
8681         if (_argo0 == Py_None) { _arg0 = NULL; }
8682         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8683             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorUp. Expected _wxGrid_p.");
8684         return NULL;
8685         }
8686     }
8687     _arg1 = (bool ) tempbool1;
8688 {
8689     wxPy_BEGIN_ALLOW_THREADS;
8690         _result = (bool )wxGrid_MoveCursorUp(_arg0,_arg1);
8691
8692     wxPy_END_ALLOW_THREADS;
8693     if (PyErr_Occurred()) return NULL;
8694 }    _resultobj = Py_BuildValue("i",_result);
8695     return _resultobj;
8696 }
8697
8698 #define wxGrid_MoveCursorDown(_swigobj,_swigarg0)  (_swigobj->MoveCursorDown(_swigarg0))
8699 static PyObject *_wrap_wxGrid_MoveCursorDown(PyObject *self, PyObject *args, PyObject *kwargs) {
8700     PyObject * _resultobj;
8701     bool  _result;
8702     wxGrid * _arg0;
8703     bool  _arg1;
8704     PyObject * _argo0 = 0;
8705     int tempbool1;
8706     char *_kwnames[] = { "self","expandSelection", NULL };
8707
8708     self = self;
8709     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorDown",_kwnames,&_argo0,&tempbool1))
8710         return NULL;
8711     if (_argo0) {
8712         if (_argo0 == Py_None) { _arg0 = NULL; }
8713         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8714             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorDown. Expected _wxGrid_p.");
8715         return NULL;
8716         }
8717     }
8718     _arg1 = (bool ) tempbool1;
8719 {
8720     wxPy_BEGIN_ALLOW_THREADS;
8721         _result = (bool )wxGrid_MoveCursorDown(_arg0,_arg1);
8722
8723     wxPy_END_ALLOW_THREADS;
8724     if (PyErr_Occurred()) return NULL;
8725 }    _resultobj = Py_BuildValue("i",_result);
8726     return _resultobj;
8727 }
8728
8729 #define wxGrid_MoveCursorLeft(_swigobj,_swigarg0)  (_swigobj->MoveCursorLeft(_swigarg0))
8730 static PyObject *_wrap_wxGrid_MoveCursorLeft(PyObject *self, PyObject *args, PyObject *kwargs) {
8731     PyObject * _resultobj;
8732     bool  _result;
8733     wxGrid * _arg0;
8734     bool  _arg1;
8735     PyObject * _argo0 = 0;
8736     int tempbool1;
8737     char *_kwnames[] = { "self","expandSelection", NULL };
8738
8739     self = self;
8740     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorLeft",_kwnames,&_argo0,&tempbool1))
8741         return NULL;
8742     if (_argo0) {
8743         if (_argo0 == Py_None) { _arg0 = NULL; }
8744         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8745             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorLeft. Expected _wxGrid_p.");
8746         return NULL;
8747         }
8748     }
8749     _arg1 = (bool ) tempbool1;
8750 {
8751     wxPy_BEGIN_ALLOW_THREADS;
8752         _result = (bool )wxGrid_MoveCursorLeft(_arg0,_arg1);
8753
8754     wxPy_END_ALLOW_THREADS;
8755     if (PyErr_Occurred()) return NULL;
8756 }    _resultobj = Py_BuildValue("i",_result);
8757     return _resultobj;
8758 }
8759
8760 #define wxGrid_MoveCursorRight(_swigobj,_swigarg0)  (_swigobj->MoveCursorRight(_swigarg0))
8761 static PyObject *_wrap_wxGrid_MoveCursorRight(PyObject *self, PyObject *args, PyObject *kwargs) {
8762     PyObject * _resultobj;
8763     bool  _result;
8764     wxGrid * _arg0;
8765     bool  _arg1;
8766     PyObject * _argo0 = 0;
8767     int tempbool1;
8768     char *_kwnames[] = { "self","expandSelection", NULL };
8769
8770     self = self;
8771     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorRight",_kwnames,&_argo0,&tempbool1))
8772         return NULL;
8773     if (_argo0) {
8774         if (_argo0 == Py_None) { _arg0 = NULL; }
8775         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8776             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorRight. Expected _wxGrid_p.");
8777         return NULL;
8778         }
8779     }
8780     _arg1 = (bool ) tempbool1;
8781 {
8782     wxPy_BEGIN_ALLOW_THREADS;
8783         _result = (bool )wxGrid_MoveCursorRight(_arg0,_arg1);
8784
8785     wxPy_END_ALLOW_THREADS;
8786     if (PyErr_Occurred()) return NULL;
8787 }    _resultobj = Py_BuildValue("i",_result);
8788     return _resultobj;
8789 }
8790
8791 #define wxGrid_MovePageDown(_swigobj)  (_swigobj->MovePageDown())
8792 static PyObject *_wrap_wxGrid_MovePageDown(PyObject *self, PyObject *args, PyObject *kwargs) {
8793     PyObject * _resultobj;
8794     bool  _result;
8795     wxGrid * _arg0;
8796     PyObject * _argo0 = 0;
8797     char *_kwnames[] = { "self", NULL };
8798
8799     self = self;
8800     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_MovePageDown",_kwnames,&_argo0))
8801         return NULL;
8802     if (_argo0) {
8803         if (_argo0 == Py_None) { _arg0 = NULL; }
8804         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8805             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MovePageDown. Expected _wxGrid_p.");
8806         return NULL;
8807         }
8808     }
8809 {
8810     wxPy_BEGIN_ALLOW_THREADS;
8811         _result = (bool )wxGrid_MovePageDown(_arg0);
8812
8813     wxPy_END_ALLOW_THREADS;
8814     if (PyErr_Occurred()) return NULL;
8815 }    _resultobj = Py_BuildValue("i",_result);
8816     return _resultobj;
8817 }
8818
8819 #define wxGrid_MovePageUp(_swigobj)  (_swigobj->MovePageUp())
8820 static PyObject *_wrap_wxGrid_MovePageUp(PyObject *self, PyObject *args, PyObject *kwargs) {
8821     PyObject * _resultobj;
8822     bool  _result;
8823     wxGrid * _arg0;
8824     PyObject * _argo0 = 0;
8825     char *_kwnames[] = { "self", NULL };
8826
8827     self = self;
8828     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_MovePageUp",_kwnames,&_argo0))
8829         return NULL;
8830     if (_argo0) {
8831         if (_argo0 == Py_None) { _arg0 = NULL; }
8832         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8833             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MovePageUp. Expected _wxGrid_p.");
8834         return NULL;
8835         }
8836     }
8837 {
8838     wxPy_BEGIN_ALLOW_THREADS;
8839         _result = (bool )wxGrid_MovePageUp(_arg0);
8840
8841     wxPy_END_ALLOW_THREADS;
8842     if (PyErr_Occurred()) return NULL;
8843 }    _resultobj = Py_BuildValue("i",_result);
8844     return _resultobj;
8845 }
8846
8847 #define wxGrid_MoveCursorUpBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorUpBlock(_swigarg0))
8848 static PyObject *_wrap_wxGrid_MoveCursorUpBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8849     PyObject * _resultobj;
8850     bool  _result;
8851     wxGrid * _arg0;
8852     bool  _arg1;
8853     PyObject * _argo0 = 0;
8854     int tempbool1;
8855     char *_kwnames[] = { "self","expandSelection", NULL };
8856
8857     self = self;
8858     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorUpBlock",_kwnames,&_argo0,&tempbool1))
8859         return NULL;
8860     if (_argo0) {
8861         if (_argo0 == Py_None) { _arg0 = NULL; }
8862         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8863             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorUpBlock. Expected _wxGrid_p.");
8864         return NULL;
8865         }
8866     }
8867     _arg1 = (bool ) tempbool1;
8868 {
8869     wxPy_BEGIN_ALLOW_THREADS;
8870         _result = (bool )wxGrid_MoveCursorUpBlock(_arg0,_arg1);
8871
8872     wxPy_END_ALLOW_THREADS;
8873     if (PyErr_Occurred()) return NULL;
8874 }    _resultobj = Py_BuildValue("i",_result);
8875     return _resultobj;
8876 }
8877
8878 #define wxGrid_MoveCursorDownBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorDownBlock(_swigarg0))
8879 static PyObject *_wrap_wxGrid_MoveCursorDownBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8880     PyObject * _resultobj;
8881     bool  _result;
8882     wxGrid * _arg0;
8883     bool  _arg1;
8884     PyObject * _argo0 = 0;
8885     int tempbool1;
8886     char *_kwnames[] = { "self","expandSelection", NULL };
8887
8888     self = self;
8889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorDownBlock",_kwnames,&_argo0,&tempbool1))
8890         return NULL;
8891     if (_argo0) {
8892         if (_argo0 == Py_None) { _arg0 = NULL; }
8893         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8894             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorDownBlock. Expected _wxGrid_p.");
8895         return NULL;
8896         }
8897     }
8898     _arg1 = (bool ) tempbool1;
8899 {
8900     wxPy_BEGIN_ALLOW_THREADS;
8901         _result = (bool )wxGrid_MoveCursorDownBlock(_arg0,_arg1);
8902
8903     wxPy_END_ALLOW_THREADS;
8904     if (PyErr_Occurred()) return NULL;
8905 }    _resultobj = Py_BuildValue("i",_result);
8906     return _resultobj;
8907 }
8908
8909 #define wxGrid_MoveCursorLeftBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorLeftBlock(_swigarg0))
8910 static PyObject *_wrap_wxGrid_MoveCursorLeftBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8911     PyObject * _resultobj;
8912     bool  _result;
8913     wxGrid * _arg0;
8914     bool  _arg1;
8915     PyObject * _argo0 = 0;
8916     int tempbool1;
8917     char *_kwnames[] = { "self","expandSelection", NULL };
8918
8919     self = self;
8920     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorLeftBlock",_kwnames,&_argo0,&tempbool1))
8921         return NULL;
8922     if (_argo0) {
8923         if (_argo0 == Py_None) { _arg0 = NULL; }
8924         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8925             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorLeftBlock. Expected _wxGrid_p.");
8926         return NULL;
8927         }
8928     }
8929     _arg1 = (bool ) tempbool1;
8930 {
8931     wxPy_BEGIN_ALLOW_THREADS;
8932         _result = (bool )wxGrid_MoveCursorLeftBlock(_arg0,_arg1);
8933
8934     wxPy_END_ALLOW_THREADS;
8935     if (PyErr_Occurred()) return NULL;
8936 }    _resultobj = Py_BuildValue("i",_result);
8937     return _resultobj;
8938 }
8939
8940 #define wxGrid_MoveCursorRightBlock(_swigobj,_swigarg0)  (_swigobj->MoveCursorRightBlock(_swigarg0))
8941 static PyObject *_wrap_wxGrid_MoveCursorRightBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
8942     PyObject * _resultobj;
8943     bool  _result;
8944     wxGrid * _arg0;
8945     bool  _arg1;
8946     PyObject * _argo0 = 0;
8947     int tempbool1;
8948     char *_kwnames[] = { "self","expandSelection", NULL };
8949
8950     self = self;
8951     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_MoveCursorRightBlock",_kwnames,&_argo0,&tempbool1))
8952         return NULL;
8953     if (_argo0) {
8954         if (_argo0 == Py_None) { _arg0 = NULL; }
8955         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8956             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_MoveCursorRightBlock. Expected _wxGrid_p.");
8957         return NULL;
8958         }
8959     }
8960     _arg1 = (bool ) tempbool1;
8961 {
8962     wxPy_BEGIN_ALLOW_THREADS;
8963         _result = (bool )wxGrid_MoveCursorRightBlock(_arg0,_arg1);
8964
8965     wxPy_END_ALLOW_THREADS;
8966     if (PyErr_Occurred()) return NULL;
8967 }    _resultobj = Py_BuildValue("i",_result);
8968     return _resultobj;
8969 }
8970
8971 #define wxGrid_GetDefaultRowLabelSize(_swigobj)  (_swigobj->GetDefaultRowLabelSize())
8972 static PyObject *_wrap_wxGrid_GetDefaultRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
8973     PyObject * _resultobj;
8974     int  _result;
8975     wxGrid * _arg0;
8976     PyObject * _argo0 = 0;
8977     char *_kwnames[] = { "self", NULL };
8978
8979     self = self;
8980     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRowLabelSize",_kwnames,&_argo0))
8981         return NULL;
8982     if (_argo0) {
8983         if (_argo0 == Py_None) { _arg0 = NULL; }
8984         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
8985             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRowLabelSize. Expected _wxGrid_p.");
8986         return NULL;
8987         }
8988     }
8989 {
8990     wxPy_BEGIN_ALLOW_THREADS;
8991         _result = (int )wxGrid_GetDefaultRowLabelSize(_arg0);
8992
8993     wxPy_END_ALLOW_THREADS;
8994     if (PyErr_Occurred()) return NULL;
8995 }    _resultobj = Py_BuildValue("i",_result);
8996     return _resultobj;
8997 }
8998
8999 #define wxGrid_GetRowLabelSize(_swigobj)  (_swigobj->GetRowLabelSize())
9000 static PyObject *_wrap_wxGrid_GetRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9001     PyObject * _resultobj;
9002     int  _result;
9003     wxGrid * _arg0;
9004     PyObject * _argo0 = 0;
9005     char *_kwnames[] = { "self", NULL };
9006
9007     self = self;
9008     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetRowLabelSize",_kwnames,&_argo0))
9009         return NULL;
9010     if (_argo0) {
9011         if (_argo0 == Py_None) { _arg0 = NULL; }
9012         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9013             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelSize. Expected _wxGrid_p.");
9014         return NULL;
9015         }
9016     }
9017 {
9018     wxPy_BEGIN_ALLOW_THREADS;
9019         _result = (int )wxGrid_GetRowLabelSize(_arg0);
9020
9021     wxPy_END_ALLOW_THREADS;
9022     if (PyErr_Occurred()) return NULL;
9023 }    _resultobj = Py_BuildValue("i",_result);
9024     return _resultobj;
9025 }
9026
9027 #define wxGrid_GetDefaultColLabelSize(_swigobj)  (_swigobj->GetDefaultColLabelSize())
9028 static PyObject *_wrap_wxGrid_GetDefaultColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9029     PyObject * _resultobj;
9030     int  _result;
9031     wxGrid * _arg0;
9032     PyObject * _argo0 = 0;
9033     char *_kwnames[] = { "self", NULL };
9034
9035     self = self;
9036     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultColLabelSize",_kwnames,&_argo0))
9037         return NULL;
9038     if (_argo0) {
9039         if (_argo0 == Py_None) { _arg0 = NULL; }
9040         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9041             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultColLabelSize. Expected _wxGrid_p.");
9042         return NULL;
9043         }
9044     }
9045 {
9046     wxPy_BEGIN_ALLOW_THREADS;
9047         _result = (int )wxGrid_GetDefaultColLabelSize(_arg0);
9048
9049     wxPy_END_ALLOW_THREADS;
9050     if (PyErr_Occurred()) return NULL;
9051 }    _resultobj = Py_BuildValue("i",_result);
9052     return _resultobj;
9053 }
9054
9055 #define wxGrid_GetColLabelSize(_swigobj)  (_swigobj->GetColLabelSize())
9056 static PyObject *_wrap_wxGrid_GetColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9057     PyObject * _resultobj;
9058     int  _result;
9059     wxGrid * _arg0;
9060     PyObject * _argo0 = 0;
9061     char *_kwnames[] = { "self", NULL };
9062
9063     self = self;
9064     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetColLabelSize",_kwnames,&_argo0))
9065         return NULL;
9066     if (_argo0) {
9067         if (_argo0 == Py_None) { _arg0 = NULL; }
9068         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9069             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelSize. Expected _wxGrid_p.");
9070         return NULL;
9071         }
9072     }
9073 {
9074     wxPy_BEGIN_ALLOW_THREADS;
9075         _result = (int )wxGrid_GetColLabelSize(_arg0);
9076
9077     wxPy_END_ALLOW_THREADS;
9078     if (PyErr_Occurred()) return NULL;
9079 }    _resultobj = Py_BuildValue("i",_result);
9080     return _resultobj;
9081 }
9082
9083 #define wxGrid_GetLabelBackgroundColour(_swigobj)  (_swigobj->GetLabelBackgroundColour())
9084 static PyObject *_wrap_wxGrid_GetLabelBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9085     PyObject * _resultobj;
9086     wxColour * _result;
9087     wxGrid * _arg0;
9088     PyObject * _argo0 = 0;
9089     char *_kwnames[] = { "self", NULL };
9090     char _ptemp[128];
9091
9092     self = self;
9093     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelBackgroundColour",_kwnames,&_argo0))
9094         return NULL;
9095     if (_argo0) {
9096         if (_argo0 == Py_None) { _arg0 = NULL; }
9097         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9098             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelBackgroundColour. Expected _wxGrid_p.");
9099         return NULL;
9100         }
9101     }
9102 {
9103     wxPy_BEGIN_ALLOW_THREADS;
9104         _result = new wxColour (wxGrid_GetLabelBackgroundColour(_arg0));
9105
9106     wxPy_END_ALLOW_THREADS;
9107     if (PyErr_Occurred()) return NULL;
9108 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9109     _resultobj = Py_BuildValue("s",_ptemp);
9110     return _resultobj;
9111 }
9112
9113 #define wxGrid_GetLabelTextColour(_swigobj)  (_swigobj->GetLabelTextColour())
9114 static PyObject *_wrap_wxGrid_GetLabelTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9115     PyObject * _resultobj;
9116     wxColour * _result;
9117     wxGrid * _arg0;
9118     PyObject * _argo0 = 0;
9119     char *_kwnames[] = { "self", NULL };
9120     char _ptemp[128];
9121
9122     self = self;
9123     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelTextColour",_kwnames,&_argo0))
9124         return NULL;
9125     if (_argo0) {
9126         if (_argo0 == Py_None) { _arg0 = NULL; }
9127         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9128             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelTextColour. Expected _wxGrid_p.");
9129         return NULL;
9130         }
9131     }
9132 {
9133     wxPy_BEGIN_ALLOW_THREADS;
9134         _result = new wxColour (wxGrid_GetLabelTextColour(_arg0));
9135
9136     wxPy_END_ALLOW_THREADS;
9137     if (PyErr_Occurred()) return NULL;
9138 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9139     _resultobj = Py_BuildValue("s",_ptemp);
9140     return _resultobj;
9141 }
9142
9143 #define wxGrid_GetLabelFont(_swigobj)  (_swigobj->GetLabelFont())
9144 static PyObject *_wrap_wxGrid_GetLabelFont(PyObject *self, PyObject *args, PyObject *kwargs) {
9145     PyObject * _resultobj;
9146     wxFont * _result;
9147     wxGrid * _arg0;
9148     PyObject * _argo0 = 0;
9149     char *_kwnames[] = { "self", NULL };
9150     char _ptemp[128];
9151
9152     self = self;
9153     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetLabelFont",_kwnames,&_argo0))
9154         return NULL;
9155     if (_argo0) {
9156         if (_argo0 == Py_None) { _arg0 = NULL; }
9157         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9158             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetLabelFont. Expected _wxGrid_p.");
9159         return NULL;
9160         }
9161     }
9162 {
9163     wxPy_BEGIN_ALLOW_THREADS;
9164         _result = new wxFont (wxGrid_GetLabelFont(_arg0));
9165
9166     wxPy_END_ALLOW_THREADS;
9167     if (PyErr_Occurred()) return NULL;
9168 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
9169     _resultobj = Py_BuildValue("s",_ptemp);
9170     return _resultobj;
9171 }
9172
9173 #define wxGrid_GetRowLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetRowLabelAlignment(_swigarg0,_swigarg1))
9174 static PyObject *_wrap_wxGrid_GetRowLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9175     PyObject * _resultobj;
9176     wxGrid * _arg0;
9177     int * _arg1;
9178     int  temp;
9179     int * _arg2;
9180     int  temp0;
9181     PyObject * _argo0 = 0;
9182     char *_kwnames[] = { "self", NULL };
9183
9184     self = self;
9185 {
9186   _arg1 = &temp;
9187 }
9188 {
9189   _arg2 = &temp0;
9190 }
9191     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetRowLabelAlignment",_kwnames,&_argo0))
9192         return NULL;
9193     if (_argo0) {
9194         if (_argo0 == Py_None) { _arg0 = NULL; }
9195         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9196             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelAlignment. Expected _wxGrid_p.");
9197         return NULL;
9198         }
9199     }
9200 {
9201     wxPy_BEGIN_ALLOW_THREADS;
9202         wxGrid_GetRowLabelAlignment(_arg0,_arg1,_arg2);
9203
9204     wxPy_END_ALLOW_THREADS;
9205     if (PyErr_Occurred()) return NULL;
9206 }    Py_INCREF(Py_None);
9207     _resultobj = Py_None;
9208 {
9209     PyObject *o;
9210     o = PyInt_FromLong((long) (*_arg1));
9211     _resultobj = t_output_helper(_resultobj, o);
9212 }
9213 {
9214     PyObject *o;
9215     o = PyInt_FromLong((long) (*_arg2));
9216     _resultobj = t_output_helper(_resultobj, o);
9217 }
9218     return _resultobj;
9219 }
9220
9221 #define wxGrid_GetColLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetColLabelAlignment(_swigarg0,_swigarg1))
9222 static PyObject *_wrap_wxGrid_GetColLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9223     PyObject * _resultobj;
9224     wxGrid * _arg0;
9225     int * _arg1;
9226     int  temp;
9227     int * _arg2;
9228     int  temp0;
9229     PyObject * _argo0 = 0;
9230     char *_kwnames[] = { "self", NULL };
9231
9232     self = self;
9233 {
9234   _arg1 = &temp;
9235 }
9236 {
9237   _arg2 = &temp0;
9238 }
9239     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetColLabelAlignment",_kwnames,&_argo0))
9240         return NULL;
9241     if (_argo0) {
9242         if (_argo0 == Py_None) { _arg0 = NULL; }
9243         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9244             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelAlignment. Expected _wxGrid_p.");
9245         return NULL;
9246         }
9247     }
9248 {
9249     wxPy_BEGIN_ALLOW_THREADS;
9250         wxGrid_GetColLabelAlignment(_arg0,_arg1,_arg2);
9251
9252     wxPy_END_ALLOW_THREADS;
9253     if (PyErr_Occurred()) return NULL;
9254 }    Py_INCREF(Py_None);
9255     _resultobj = Py_None;
9256 {
9257     PyObject *o;
9258     o = PyInt_FromLong((long) (*_arg1));
9259     _resultobj = t_output_helper(_resultobj, o);
9260 }
9261 {
9262     PyObject *o;
9263     o = PyInt_FromLong((long) (*_arg2));
9264     _resultobj = t_output_helper(_resultobj, o);
9265 }
9266     return _resultobj;
9267 }
9268
9269 #define wxGrid_GetRowLabelValue(_swigobj,_swigarg0)  (_swigobj->GetRowLabelValue(_swigarg0))
9270 static PyObject *_wrap_wxGrid_GetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9271     PyObject * _resultobj;
9272     wxString * _result;
9273     wxGrid * _arg0;
9274     int  _arg1;
9275     PyObject * _argo0 = 0;
9276     char *_kwnames[] = { "self","row", NULL };
9277
9278     self = self;
9279     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetRowLabelValue",_kwnames,&_argo0,&_arg1))
9280         return NULL;
9281     if (_argo0) {
9282         if (_argo0 == Py_None) { _arg0 = NULL; }
9283         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9284             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowLabelValue. Expected _wxGrid_p.");
9285         return NULL;
9286         }
9287     }
9288 {
9289     wxPy_BEGIN_ALLOW_THREADS;
9290         _result = new wxString (wxGrid_GetRowLabelValue(_arg0,_arg1));
9291
9292     wxPy_END_ALLOW_THREADS;
9293     if (PyErr_Occurred()) return NULL;
9294 }{
9295     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
9296 }
9297 {
9298     delete _result;
9299 }
9300     return _resultobj;
9301 }
9302
9303 #define wxGrid_GetColLabelValue(_swigobj,_swigarg0)  (_swigobj->GetColLabelValue(_swigarg0))
9304 static PyObject *_wrap_wxGrid_GetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9305     PyObject * _resultobj;
9306     wxString * _result;
9307     wxGrid * _arg0;
9308     int  _arg1;
9309     PyObject * _argo0 = 0;
9310     char *_kwnames[] = { "self","col", NULL };
9311
9312     self = self;
9313     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetColLabelValue",_kwnames,&_argo0,&_arg1))
9314         return NULL;
9315     if (_argo0) {
9316         if (_argo0 == Py_None) { _arg0 = NULL; }
9317         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9318             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColLabelValue. Expected _wxGrid_p.");
9319         return NULL;
9320         }
9321     }
9322 {
9323     wxPy_BEGIN_ALLOW_THREADS;
9324         _result = new wxString (wxGrid_GetColLabelValue(_arg0,_arg1));
9325
9326     wxPy_END_ALLOW_THREADS;
9327     if (PyErr_Occurred()) return NULL;
9328 }{
9329     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
9330 }
9331 {
9332     delete _result;
9333 }
9334     return _resultobj;
9335 }
9336
9337 #define wxGrid_GetGridLineColour(_swigobj)  (_swigobj->GetGridLineColour())
9338 static PyObject *_wrap_wxGrid_GetGridLineColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9339     PyObject * _resultobj;
9340     wxColour * _result;
9341     wxGrid * _arg0;
9342     PyObject * _argo0 = 0;
9343     char *_kwnames[] = { "self", NULL };
9344     char _ptemp[128];
9345
9346     self = self;
9347     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridLineColour",_kwnames,&_argo0))
9348         return NULL;
9349     if (_argo0) {
9350         if (_argo0 == Py_None) { _arg0 = NULL; }
9351         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9352             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridLineColour. Expected _wxGrid_p.");
9353         return NULL;
9354         }
9355     }
9356 {
9357     wxPy_BEGIN_ALLOW_THREADS;
9358         _result = new wxColour (wxGrid_GetGridLineColour(_arg0));
9359
9360     wxPy_END_ALLOW_THREADS;
9361     if (PyErr_Occurred()) return NULL;
9362 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9363     _resultobj = Py_BuildValue("s",_ptemp);
9364     return _resultobj;
9365 }
9366
9367 #define wxGrid_GetCellHighlightColour(_swigobj)  (_swigobj->GetCellHighlightColour())
9368 static PyObject *_wrap_wxGrid_GetCellHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9369     PyObject * _resultobj;
9370     wxColour * _result;
9371     wxGrid * _arg0;
9372     PyObject * _argo0 = 0;
9373     char *_kwnames[] = { "self", NULL };
9374     char _ptemp[128];
9375
9376     self = self;
9377     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightColour",_kwnames,&_argo0))
9378         return NULL;
9379     if (_argo0) {
9380         if (_argo0 == Py_None) { _arg0 = NULL; }
9381         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9382             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightColour. Expected _wxGrid_p.");
9383         return NULL;
9384         }
9385     }
9386 {
9387     wxPy_BEGIN_ALLOW_THREADS;
9388         _result = new wxColour (wxGrid_GetCellHighlightColour(_arg0));
9389
9390     wxPy_END_ALLOW_THREADS;
9391     if (PyErr_Occurred()) return NULL;
9392 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
9393     _resultobj = Py_BuildValue("s",_ptemp);
9394     return _resultobj;
9395 }
9396
9397 #define wxGrid_GetCellHighlightPenWidth(_swigobj)  (_swigobj->GetCellHighlightPenWidth())
9398 static PyObject *_wrap_wxGrid_GetCellHighlightPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9399     PyObject * _resultobj;
9400     int  _result;
9401     wxGrid * _arg0;
9402     PyObject * _argo0 = 0;
9403     char *_kwnames[] = { "self", NULL };
9404
9405     self = self;
9406     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightPenWidth",_kwnames,&_argo0))
9407         return NULL;
9408     if (_argo0) {
9409         if (_argo0 == Py_None) { _arg0 = NULL; }
9410         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9411             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightPenWidth. Expected _wxGrid_p.");
9412         return NULL;
9413         }
9414     }
9415 {
9416     wxPy_BEGIN_ALLOW_THREADS;
9417         _result = (int )wxGrid_GetCellHighlightPenWidth(_arg0);
9418
9419     wxPy_END_ALLOW_THREADS;
9420     if (PyErr_Occurred()) return NULL;
9421 }    _resultobj = Py_BuildValue("i",_result);
9422     return _resultobj;
9423 }
9424
9425 #define wxGrid_GetCellHighlightROPenWidth(_swigobj)  (_swigobj->GetCellHighlightROPenWidth())
9426 static PyObject *_wrap_wxGrid_GetCellHighlightROPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9427     PyObject * _resultobj;
9428     int  _result;
9429     wxGrid * _arg0;
9430     PyObject * _argo0 = 0;
9431     char *_kwnames[] = { "self", NULL };
9432
9433     self = self;
9434     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetCellHighlightROPenWidth",_kwnames,&_argo0))
9435         return NULL;
9436     if (_argo0) {
9437         if (_argo0 == Py_None) { _arg0 = NULL; }
9438         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9439             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellHighlightROPenWidth. Expected _wxGrid_p.");
9440         return NULL;
9441         }
9442     }
9443 {
9444     wxPy_BEGIN_ALLOW_THREADS;
9445         _result = (int )wxGrid_GetCellHighlightROPenWidth(_arg0);
9446
9447     wxPy_END_ALLOW_THREADS;
9448     if (PyErr_Occurred()) return NULL;
9449 }    _resultobj = Py_BuildValue("i",_result);
9450     return _resultobj;
9451 }
9452
9453 #define wxGrid_SetRowLabelSize(_swigobj,_swigarg0)  (_swigobj->SetRowLabelSize(_swigarg0))
9454 static PyObject *_wrap_wxGrid_SetRowLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9455     PyObject * _resultobj;
9456     wxGrid * _arg0;
9457     int  _arg1;
9458     PyObject * _argo0 = 0;
9459     char *_kwnames[] = { "self","width", NULL };
9460
9461     self = self;
9462     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetRowLabelSize",_kwnames,&_argo0,&_arg1))
9463         return NULL;
9464     if (_argo0) {
9465         if (_argo0 == Py_None) { _arg0 = NULL; }
9466         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9467             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelSize. Expected _wxGrid_p.");
9468         return NULL;
9469         }
9470     }
9471 {
9472     wxPy_BEGIN_ALLOW_THREADS;
9473         wxGrid_SetRowLabelSize(_arg0,_arg1);
9474
9475     wxPy_END_ALLOW_THREADS;
9476     if (PyErr_Occurred()) return NULL;
9477 }    Py_INCREF(Py_None);
9478     _resultobj = Py_None;
9479     return _resultobj;
9480 }
9481
9482 #define wxGrid_SetColLabelSize(_swigobj,_swigarg0)  (_swigobj->SetColLabelSize(_swigarg0))
9483 static PyObject *_wrap_wxGrid_SetColLabelSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9484     PyObject * _resultobj;
9485     wxGrid * _arg0;
9486     int  _arg1;
9487     PyObject * _argo0 = 0;
9488     char *_kwnames[] = { "self","height", NULL };
9489
9490     self = self;
9491     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColLabelSize",_kwnames,&_argo0,&_arg1))
9492         return NULL;
9493     if (_argo0) {
9494         if (_argo0 == Py_None) { _arg0 = NULL; }
9495         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9496             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelSize. Expected _wxGrid_p.");
9497         return NULL;
9498         }
9499     }
9500 {
9501     wxPy_BEGIN_ALLOW_THREADS;
9502         wxGrid_SetColLabelSize(_arg0,_arg1);
9503
9504     wxPy_END_ALLOW_THREADS;
9505     if (PyErr_Occurred()) return NULL;
9506 }    Py_INCREF(Py_None);
9507     _resultobj = Py_None;
9508     return _resultobj;
9509 }
9510
9511 #define wxGrid_SetLabelBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetLabelBackgroundColour(_swigarg0))
9512 static PyObject *_wrap_wxGrid_SetLabelBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9513     PyObject * _resultobj;
9514     wxGrid * _arg0;
9515     wxColour * _arg1;
9516     PyObject * _argo0 = 0;
9517     wxColour  temp;
9518     PyObject * _obj1 = 0;
9519     char *_kwnames[] = { "self","arg2", NULL };
9520
9521     self = self;
9522     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelBackgroundColour",_kwnames,&_argo0,&_obj1))
9523         return NULL;
9524     if (_argo0) {
9525         if (_argo0 == Py_None) { _arg0 = NULL; }
9526         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9527             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelBackgroundColour. Expected _wxGrid_p.");
9528         return NULL;
9529         }
9530     }
9531 {
9532     _arg1 = &temp;
9533     if (! wxColour_helper(_obj1, &_arg1))
9534         return NULL;
9535 }
9536 {
9537     wxPy_BEGIN_ALLOW_THREADS;
9538         wxGrid_SetLabelBackgroundColour(_arg0,*_arg1);
9539
9540     wxPy_END_ALLOW_THREADS;
9541     if (PyErr_Occurred()) return NULL;
9542 }    Py_INCREF(Py_None);
9543     _resultobj = Py_None;
9544     return _resultobj;
9545 }
9546
9547 #define wxGrid_SetLabelTextColour(_swigobj,_swigarg0)  (_swigobj->SetLabelTextColour(_swigarg0))
9548 static PyObject *_wrap_wxGrid_SetLabelTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9549     PyObject * _resultobj;
9550     wxGrid * _arg0;
9551     wxColour * _arg1;
9552     PyObject * _argo0 = 0;
9553     wxColour  temp;
9554     PyObject * _obj1 = 0;
9555     char *_kwnames[] = { "self","arg2", NULL };
9556
9557     self = self;
9558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelTextColour",_kwnames,&_argo0,&_obj1))
9559         return NULL;
9560     if (_argo0) {
9561         if (_argo0 == Py_None) { _arg0 = NULL; }
9562         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9563             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelTextColour. Expected _wxGrid_p.");
9564         return NULL;
9565         }
9566     }
9567 {
9568     _arg1 = &temp;
9569     if (! wxColour_helper(_obj1, &_arg1))
9570         return NULL;
9571 }
9572 {
9573     wxPy_BEGIN_ALLOW_THREADS;
9574         wxGrid_SetLabelTextColour(_arg0,*_arg1);
9575
9576     wxPy_END_ALLOW_THREADS;
9577     if (PyErr_Occurred()) return NULL;
9578 }    Py_INCREF(Py_None);
9579     _resultobj = Py_None;
9580     return _resultobj;
9581 }
9582
9583 #define wxGrid_SetLabelFont(_swigobj,_swigarg0)  (_swigobj->SetLabelFont(_swigarg0))
9584 static PyObject *_wrap_wxGrid_SetLabelFont(PyObject *self, PyObject *args, PyObject *kwargs) {
9585     PyObject * _resultobj;
9586     wxGrid * _arg0;
9587     wxFont * _arg1;
9588     PyObject * _argo0 = 0;
9589     PyObject * _argo1 = 0;
9590     char *_kwnames[] = { "self","arg2", NULL };
9591
9592     self = self;
9593     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetLabelFont",_kwnames,&_argo0,&_argo1))
9594         return NULL;
9595     if (_argo0) {
9596         if (_argo0 == Py_None) { _arg0 = NULL; }
9597         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9598             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetLabelFont. Expected _wxGrid_p.");
9599         return NULL;
9600         }
9601     }
9602     if (_argo1) {
9603         if (_argo1 == Py_None) { _arg1 = NULL; }
9604         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
9605             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetLabelFont. Expected _wxFont_p.");
9606         return NULL;
9607         }
9608     }
9609 {
9610     wxPy_BEGIN_ALLOW_THREADS;
9611         wxGrid_SetLabelFont(_arg0,*_arg1);
9612
9613     wxPy_END_ALLOW_THREADS;
9614     if (PyErr_Occurred()) return NULL;
9615 }    Py_INCREF(Py_None);
9616     _resultobj = Py_None;
9617     return _resultobj;
9618 }
9619
9620 #define wxGrid_SetRowLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelAlignment(_swigarg0,_swigarg1))
9621 static PyObject *_wrap_wxGrid_SetRowLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9622     PyObject * _resultobj;
9623     wxGrid * _arg0;
9624     int  _arg1;
9625     int  _arg2;
9626     PyObject * _argo0 = 0;
9627     char *_kwnames[] = { "self","horiz","vert", NULL };
9628
9629     self = self;
9630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowLabelAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
9631         return NULL;
9632     if (_argo0) {
9633         if (_argo0 == Py_None) { _arg0 = NULL; }
9634         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9635             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelAlignment. Expected _wxGrid_p.");
9636         return NULL;
9637         }
9638     }
9639 {
9640     wxPy_BEGIN_ALLOW_THREADS;
9641         wxGrid_SetRowLabelAlignment(_arg0,_arg1,_arg2);
9642
9643     wxPy_END_ALLOW_THREADS;
9644     if (PyErr_Occurred()) return NULL;
9645 }    Py_INCREF(Py_None);
9646     _resultobj = Py_None;
9647     return _resultobj;
9648 }
9649
9650 #define wxGrid_SetColLabelAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelAlignment(_swigarg0,_swigarg1))
9651 static PyObject *_wrap_wxGrid_SetColLabelAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
9652     PyObject * _resultobj;
9653     wxGrid * _arg0;
9654     int  _arg1;
9655     int  _arg2;
9656     PyObject * _argo0 = 0;
9657     char *_kwnames[] = { "self","horiz","vert", NULL };
9658
9659     self = self;
9660     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColLabelAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
9661         return NULL;
9662     if (_argo0) {
9663         if (_argo0 == Py_None) { _arg0 = NULL; }
9664         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9665             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelAlignment. Expected _wxGrid_p.");
9666         return NULL;
9667         }
9668     }
9669 {
9670     wxPy_BEGIN_ALLOW_THREADS;
9671         wxGrid_SetColLabelAlignment(_arg0,_arg1,_arg2);
9672
9673     wxPy_END_ALLOW_THREADS;
9674     if (PyErr_Occurred()) return NULL;
9675 }    Py_INCREF(Py_None);
9676     _resultobj = Py_None;
9677     return _resultobj;
9678 }
9679
9680 #define wxGrid_SetRowLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowLabelValue(_swigarg0,_swigarg1))
9681 static PyObject *_wrap_wxGrid_SetRowLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9682     PyObject * _resultobj;
9683     wxGrid * _arg0;
9684     int  _arg1;
9685     wxString * _arg2;
9686     PyObject * _argo0 = 0;
9687     PyObject * _obj2 = 0;
9688     char *_kwnames[] = { "self","row","arg3", NULL };
9689
9690     self = self;
9691     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetRowLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
9692         return NULL;
9693     if (_argo0) {
9694         if (_argo0 == Py_None) { _arg0 = NULL; }
9695         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9696             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowLabelValue. Expected _wxGrid_p.");
9697         return NULL;
9698         }
9699     }
9700 {
9701 #if PYTHON_API_VERSION >= 1009
9702     char* tmpPtr; int tmpSize;
9703     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
9704         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9705         return NULL;
9706     }
9707     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
9708         return NULL;
9709     _arg2 = new wxString(tmpPtr, tmpSize);
9710 #else
9711     if (!PyString_Check(_obj2)) {
9712         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9713         return NULL;
9714     }
9715     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
9716 #endif
9717 }
9718 {
9719     wxPy_BEGIN_ALLOW_THREADS;
9720         wxGrid_SetRowLabelValue(_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 {
9727     if (_obj2)
9728         delete _arg2;
9729 }
9730     return _resultobj;
9731 }
9732
9733 #define wxGrid_SetColLabelValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColLabelValue(_swigarg0,_swigarg1))
9734 static PyObject *_wrap_wxGrid_SetColLabelValue(PyObject *self, PyObject *args, PyObject *kwargs) {
9735     PyObject * _resultobj;
9736     wxGrid * _arg0;
9737     int  _arg1;
9738     wxString * _arg2;
9739     PyObject * _argo0 = 0;
9740     PyObject * _obj2 = 0;
9741     char *_kwnames[] = { "self","col","arg3", NULL };
9742
9743     self = self;
9744     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColLabelValue",_kwnames,&_argo0,&_arg1,&_obj2))
9745         return NULL;
9746     if (_argo0) {
9747         if (_argo0 == Py_None) { _arg0 = NULL; }
9748         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9749             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColLabelValue. Expected _wxGrid_p.");
9750         return NULL;
9751         }
9752     }
9753 {
9754 #if PYTHON_API_VERSION >= 1009
9755     char* tmpPtr; int tmpSize;
9756     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
9757         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9758         return NULL;
9759     }
9760     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
9761         return NULL;
9762     _arg2 = new wxString(tmpPtr, tmpSize);
9763 #else
9764     if (!PyString_Check(_obj2)) {
9765         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
9766         return NULL;
9767     }
9768     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
9769 #endif
9770 }
9771 {
9772     wxPy_BEGIN_ALLOW_THREADS;
9773         wxGrid_SetColLabelValue(_arg0,_arg1,*_arg2);
9774
9775     wxPy_END_ALLOW_THREADS;
9776     if (PyErr_Occurred()) return NULL;
9777 }    Py_INCREF(Py_None);
9778     _resultobj = Py_None;
9779 {
9780     if (_obj2)
9781         delete _arg2;
9782 }
9783     return _resultobj;
9784 }
9785
9786 #define wxGrid_SetGridLineColour(_swigobj,_swigarg0)  (_swigobj->SetGridLineColour(_swigarg0))
9787 static PyObject *_wrap_wxGrid_SetGridLineColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9788     PyObject * _resultobj;
9789     wxGrid * _arg0;
9790     wxColour * _arg1;
9791     PyObject * _argo0 = 0;
9792     wxColour  temp;
9793     PyObject * _obj1 = 0;
9794     char *_kwnames[] = { "self","arg2", NULL };
9795
9796     self = self;
9797     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetGridLineColour",_kwnames,&_argo0,&_obj1))
9798         return NULL;
9799     if (_argo0) {
9800         if (_argo0 == Py_None) { _arg0 = NULL; }
9801         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9802             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetGridLineColour. Expected _wxGrid_p.");
9803         return NULL;
9804         }
9805     }
9806 {
9807     _arg1 = &temp;
9808     if (! wxColour_helper(_obj1, &_arg1))
9809         return NULL;
9810 }
9811 {
9812     wxPy_BEGIN_ALLOW_THREADS;
9813         wxGrid_SetGridLineColour(_arg0,*_arg1);
9814
9815     wxPy_END_ALLOW_THREADS;
9816     if (PyErr_Occurred()) return NULL;
9817 }    Py_INCREF(Py_None);
9818     _resultobj = Py_None;
9819     return _resultobj;
9820 }
9821
9822 #define wxGrid_SetCellHighlightColour(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightColour(_swigarg0))
9823 static PyObject *_wrap_wxGrid_SetCellHighlightColour(PyObject *self, PyObject *args, PyObject *kwargs) {
9824     PyObject * _resultobj;
9825     wxGrid * _arg0;
9826     wxColour * _arg1;
9827     PyObject * _argo0 = 0;
9828     wxColour  temp;
9829     PyObject * _obj1 = 0;
9830     char *_kwnames[] = { "self","arg2", NULL };
9831
9832     self = self;
9833     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetCellHighlightColour",_kwnames,&_argo0,&_obj1))
9834         return NULL;
9835     if (_argo0) {
9836         if (_argo0 == Py_None) { _arg0 = NULL; }
9837         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9838             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightColour. Expected _wxGrid_p.");
9839         return NULL;
9840         }
9841     }
9842 {
9843     _arg1 = &temp;
9844     if (! wxColour_helper(_obj1, &_arg1))
9845         return NULL;
9846 }
9847 {
9848     wxPy_BEGIN_ALLOW_THREADS;
9849         wxGrid_SetCellHighlightColour(_arg0,*_arg1);
9850
9851     wxPy_END_ALLOW_THREADS;
9852     if (PyErr_Occurred()) return NULL;
9853 }    Py_INCREF(Py_None);
9854     _resultobj = Py_None;
9855     return _resultobj;
9856 }
9857
9858 #define wxGrid_SetCellHighlightPenWidth(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightPenWidth(_swigarg0))
9859 static PyObject *_wrap_wxGrid_SetCellHighlightPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9860     PyObject * _resultobj;
9861     wxGrid * _arg0;
9862     int  _arg1;
9863     PyObject * _argo0 = 0;
9864     char *_kwnames[] = { "self","width", NULL };
9865
9866     self = self;
9867     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetCellHighlightPenWidth",_kwnames,&_argo0,&_arg1))
9868         return NULL;
9869     if (_argo0) {
9870         if (_argo0 == Py_None) { _arg0 = NULL; }
9871         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9872             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightPenWidth. Expected _wxGrid_p.");
9873         return NULL;
9874         }
9875     }
9876 {
9877     wxPy_BEGIN_ALLOW_THREADS;
9878         wxGrid_SetCellHighlightPenWidth(_arg0,_arg1);
9879
9880     wxPy_END_ALLOW_THREADS;
9881     if (PyErr_Occurred()) return NULL;
9882 }    Py_INCREF(Py_None);
9883     _resultobj = Py_None;
9884     return _resultobj;
9885 }
9886
9887 #define wxGrid_SetCellHighlightROPenWidth(_swigobj,_swigarg0)  (_swigobj->SetCellHighlightROPenWidth(_swigarg0))
9888 static PyObject *_wrap_wxGrid_SetCellHighlightROPenWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
9889     PyObject * _resultobj;
9890     wxGrid * _arg0;
9891     int  _arg1;
9892     PyObject * _argo0 = 0;
9893     char *_kwnames[] = { "self","width", NULL };
9894
9895     self = self;
9896     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetCellHighlightROPenWidth",_kwnames,&_argo0,&_arg1))
9897         return NULL;
9898     if (_argo0) {
9899         if (_argo0 == Py_None) { _arg0 = NULL; }
9900         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9901             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellHighlightROPenWidth. Expected _wxGrid_p.");
9902         return NULL;
9903         }
9904     }
9905 {
9906     wxPy_BEGIN_ALLOW_THREADS;
9907         wxGrid_SetCellHighlightROPenWidth(_arg0,_arg1);
9908
9909     wxPy_END_ALLOW_THREADS;
9910     if (PyErr_Occurred()) return NULL;
9911 }    Py_INCREF(Py_None);
9912     _resultobj = Py_None;
9913     return _resultobj;
9914 }
9915
9916 #define wxGrid_EnableDragRowSize(_swigobj,_swigarg0)  (_swigobj->EnableDragRowSize(_swigarg0))
9917 static PyObject *_wrap_wxGrid_EnableDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9918     PyObject * _resultobj;
9919     wxGrid * _arg0;
9920     bool  _arg1 = (bool ) TRUE;
9921     PyObject * _argo0 = 0;
9922     int tempbool1 = (int) TRUE;
9923     char *_kwnames[] = { "self","enable", NULL };
9924
9925     self = self;
9926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragRowSize",_kwnames,&_argo0,&tempbool1))
9927         return NULL;
9928     if (_argo0) {
9929         if (_argo0 == Py_None) { _arg0 = NULL; }
9930         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9931             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragRowSize. Expected _wxGrid_p.");
9932         return NULL;
9933         }
9934     }
9935     _arg1 = (bool ) tempbool1;
9936 {
9937     wxPy_BEGIN_ALLOW_THREADS;
9938         wxGrid_EnableDragRowSize(_arg0,_arg1);
9939
9940     wxPy_END_ALLOW_THREADS;
9941     if (PyErr_Occurred()) return NULL;
9942 }    Py_INCREF(Py_None);
9943     _resultobj = Py_None;
9944     return _resultobj;
9945 }
9946
9947 #define wxGrid_DisableDragRowSize(_swigobj)  (_swigobj->DisableDragRowSize())
9948 static PyObject *_wrap_wxGrid_DisableDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9949     PyObject * _resultobj;
9950     wxGrid * _arg0;
9951     PyObject * _argo0 = 0;
9952     char *_kwnames[] = { "self", NULL };
9953
9954     self = self;
9955     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragRowSize",_kwnames,&_argo0))
9956         return NULL;
9957     if (_argo0) {
9958         if (_argo0 == Py_None) { _arg0 = NULL; }
9959         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9960             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragRowSize. Expected _wxGrid_p.");
9961         return NULL;
9962         }
9963     }
9964 {
9965     wxPy_BEGIN_ALLOW_THREADS;
9966         wxGrid_DisableDragRowSize(_arg0);
9967
9968     wxPy_END_ALLOW_THREADS;
9969     if (PyErr_Occurred()) return NULL;
9970 }    Py_INCREF(Py_None);
9971     _resultobj = Py_None;
9972     return _resultobj;
9973 }
9974
9975 #define wxGrid_CanDragRowSize(_swigobj)  (_swigobj->CanDragRowSize())
9976 static PyObject *_wrap_wxGrid_CanDragRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
9977     PyObject * _resultobj;
9978     bool  _result;
9979     wxGrid * _arg0;
9980     PyObject * _argo0 = 0;
9981     char *_kwnames[] = { "self", NULL };
9982
9983     self = self;
9984     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragRowSize",_kwnames,&_argo0))
9985         return NULL;
9986     if (_argo0) {
9987         if (_argo0 == Py_None) { _arg0 = NULL; }
9988         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
9989             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragRowSize. Expected _wxGrid_p.");
9990         return NULL;
9991         }
9992     }
9993 {
9994     wxPy_BEGIN_ALLOW_THREADS;
9995         _result = (bool )wxGrid_CanDragRowSize(_arg0);
9996
9997     wxPy_END_ALLOW_THREADS;
9998     if (PyErr_Occurred()) return NULL;
9999 }    _resultobj = Py_BuildValue("i",_result);
10000     return _resultobj;
10001 }
10002
10003 #define wxGrid_EnableDragColSize(_swigobj,_swigarg0)  (_swigobj->EnableDragColSize(_swigarg0))
10004 static PyObject *_wrap_wxGrid_EnableDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10005     PyObject * _resultobj;
10006     wxGrid * _arg0;
10007     bool  _arg1 = (bool ) TRUE;
10008     PyObject * _argo0 = 0;
10009     int tempbool1 = (int) TRUE;
10010     char *_kwnames[] = { "self","enable", NULL };
10011
10012     self = self;
10013     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragColSize",_kwnames,&_argo0,&tempbool1))
10014         return NULL;
10015     if (_argo0) {
10016         if (_argo0 == Py_None) { _arg0 = NULL; }
10017         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10018             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragColSize. Expected _wxGrid_p.");
10019         return NULL;
10020         }
10021     }
10022     _arg1 = (bool ) tempbool1;
10023 {
10024     wxPy_BEGIN_ALLOW_THREADS;
10025         wxGrid_EnableDragColSize(_arg0,_arg1);
10026
10027     wxPy_END_ALLOW_THREADS;
10028     if (PyErr_Occurred()) return NULL;
10029 }    Py_INCREF(Py_None);
10030     _resultobj = Py_None;
10031     return _resultobj;
10032 }
10033
10034 #define wxGrid_DisableDragColSize(_swigobj)  (_swigobj->DisableDragColSize())
10035 static PyObject *_wrap_wxGrid_DisableDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10036     PyObject * _resultobj;
10037     wxGrid * _arg0;
10038     PyObject * _argo0 = 0;
10039     char *_kwnames[] = { "self", NULL };
10040
10041     self = self;
10042     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragColSize",_kwnames,&_argo0))
10043         return NULL;
10044     if (_argo0) {
10045         if (_argo0 == Py_None) { _arg0 = NULL; }
10046         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10047             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragColSize. Expected _wxGrid_p.");
10048         return NULL;
10049         }
10050     }
10051 {
10052     wxPy_BEGIN_ALLOW_THREADS;
10053         wxGrid_DisableDragColSize(_arg0);
10054
10055     wxPy_END_ALLOW_THREADS;
10056     if (PyErr_Occurred()) return NULL;
10057 }    Py_INCREF(Py_None);
10058     _resultobj = Py_None;
10059     return _resultobj;
10060 }
10061
10062 #define wxGrid_CanDragColSize(_swigobj)  (_swigobj->CanDragColSize())
10063 static PyObject *_wrap_wxGrid_CanDragColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10064     PyObject * _resultobj;
10065     bool  _result;
10066     wxGrid * _arg0;
10067     PyObject * _argo0 = 0;
10068     char *_kwnames[] = { "self", NULL };
10069
10070     self = self;
10071     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragColSize",_kwnames,&_argo0))
10072         return NULL;
10073     if (_argo0) {
10074         if (_argo0 == Py_None) { _arg0 = NULL; }
10075         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10076             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragColSize. Expected _wxGrid_p.");
10077         return NULL;
10078         }
10079     }
10080 {
10081     wxPy_BEGIN_ALLOW_THREADS;
10082         _result = (bool )wxGrid_CanDragColSize(_arg0);
10083
10084     wxPy_END_ALLOW_THREADS;
10085     if (PyErr_Occurred()) return NULL;
10086 }    _resultobj = Py_BuildValue("i",_result);
10087     return _resultobj;
10088 }
10089
10090 #define wxGrid_EnableDragGridSize(_swigobj,_swigarg0)  (_swigobj->EnableDragGridSize(_swigarg0))
10091 static PyObject *_wrap_wxGrid_EnableDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10092     PyObject * _resultobj;
10093     wxGrid * _arg0;
10094     bool  _arg1 = (bool ) TRUE;
10095     PyObject * _argo0 = 0;
10096     int tempbool1 = (int) TRUE;
10097     char *_kwnames[] = { "self","enable", NULL };
10098
10099     self = self;
10100     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableDragGridSize",_kwnames,&_argo0,&tempbool1))
10101         return NULL;
10102     if (_argo0) {
10103         if (_argo0 == Py_None) { _arg0 = NULL; }
10104         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10105             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableDragGridSize. Expected _wxGrid_p.");
10106         return NULL;
10107         }
10108     }
10109     _arg1 = (bool ) tempbool1;
10110 {
10111     wxPy_BEGIN_ALLOW_THREADS;
10112         wxGrid_EnableDragGridSize(_arg0,_arg1);
10113
10114     wxPy_END_ALLOW_THREADS;
10115     if (PyErr_Occurred()) return NULL;
10116 }    Py_INCREF(Py_None);
10117     _resultobj = Py_None;
10118     return _resultobj;
10119 }
10120
10121 #define wxGrid_DisableDragGridSize(_swigobj)  (_swigobj->DisableDragGridSize())
10122 static PyObject *_wrap_wxGrid_DisableDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10123     PyObject * _resultobj;
10124     wxGrid * _arg0;
10125     PyObject * _argo0 = 0;
10126     char *_kwnames[] = { "self", NULL };
10127
10128     self = self;
10129     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_DisableDragGridSize",_kwnames,&_argo0))
10130         return NULL;
10131     if (_argo0) {
10132         if (_argo0 == Py_None) { _arg0 = NULL; }
10133         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10134             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_DisableDragGridSize. Expected _wxGrid_p.");
10135         return NULL;
10136         }
10137     }
10138 {
10139     wxPy_BEGIN_ALLOW_THREADS;
10140         wxGrid_DisableDragGridSize(_arg0);
10141
10142     wxPy_END_ALLOW_THREADS;
10143     if (PyErr_Occurred()) return NULL;
10144 }    Py_INCREF(Py_None);
10145     _resultobj = Py_None;
10146     return _resultobj;
10147 }
10148
10149 #define wxGrid_CanDragGridSize(_swigobj)  (_swigobj->CanDragGridSize())
10150 static PyObject *_wrap_wxGrid_CanDragGridSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10151     PyObject * _resultobj;
10152     bool  _result;
10153     wxGrid * _arg0;
10154     PyObject * _argo0 = 0;
10155     char *_kwnames[] = { "self", NULL };
10156
10157     self = self;
10158     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_CanDragGridSize",_kwnames,&_argo0))
10159         return NULL;
10160     if (_argo0) {
10161         if (_argo0 == Py_None) { _arg0 = NULL; }
10162         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10163             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_CanDragGridSize. Expected _wxGrid_p.");
10164         return NULL;
10165         }
10166     }
10167 {
10168     wxPy_BEGIN_ALLOW_THREADS;
10169         _result = (bool )wxGrid_CanDragGridSize(_arg0);
10170
10171     wxPy_END_ALLOW_THREADS;
10172     if (PyErr_Occurred()) return NULL;
10173 }    _resultobj = Py_BuildValue("i",_result);
10174     return _resultobj;
10175 }
10176
10177 #define wxGrid_SetRowAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowAttr(_swigarg0,_swigarg1))
10178 static PyObject *_wrap_wxGrid_SetRowAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
10179     PyObject * _resultobj;
10180     wxGrid * _arg0;
10181     int  _arg1;
10182     wxGridCellAttr * _arg2;
10183     PyObject * _argo0 = 0;
10184     PyObject * _argo2 = 0;
10185     char *_kwnames[] = { "self","row","attr", NULL };
10186
10187     self = self;
10188     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetRowAttr",_kwnames,&_argo0,&_arg1,&_argo2))
10189         return NULL;
10190     if (_argo0) {
10191         if (_argo0 == Py_None) { _arg0 = NULL; }
10192         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10193             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowAttr. Expected _wxGrid_p.");
10194         return NULL;
10195         }
10196     }
10197     if (_argo2) {
10198         if (_argo2 == Py_None) { _arg2 = NULL; }
10199         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
10200             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_SetRowAttr. Expected _wxGridCellAttr_p.");
10201         return NULL;
10202         }
10203     }
10204 {
10205     wxPy_BEGIN_ALLOW_THREADS;
10206         wxGrid_SetRowAttr(_arg0,_arg1,_arg2);
10207
10208     wxPy_END_ALLOW_THREADS;
10209     if (PyErr_Occurred()) return NULL;
10210 }    Py_INCREF(Py_None);
10211     _resultobj = Py_None;
10212     return _resultobj;
10213 }
10214
10215 #define wxGrid_SetColAttr(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColAttr(_swigarg0,_swigarg1))
10216 static PyObject *_wrap_wxGrid_SetColAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
10217     PyObject * _resultobj;
10218     wxGrid * _arg0;
10219     int  _arg1;
10220     wxGridCellAttr * _arg2;
10221     PyObject * _argo0 = 0;
10222     PyObject * _argo2 = 0;
10223     char *_kwnames[] = { "self","col","attr", NULL };
10224
10225     self = self;
10226     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColAttr",_kwnames,&_argo0,&_arg1,&_argo2))
10227         return NULL;
10228     if (_argo0) {
10229         if (_argo0 == Py_None) { _arg0 = NULL; }
10230         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10231             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColAttr. Expected _wxGrid_p.");
10232         return NULL;
10233         }
10234     }
10235     if (_argo2) {
10236         if (_argo2 == Py_None) { _arg2 = NULL; }
10237         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellAttr_p")) {
10238             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_SetColAttr. Expected _wxGridCellAttr_p.");
10239         return NULL;
10240         }
10241     }
10242 {
10243     wxPy_BEGIN_ALLOW_THREADS;
10244         wxGrid_SetColAttr(_arg0,_arg1,_arg2);
10245
10246     wxPy_END_ALLOW_THREADS;
10247     if (PyErr_Occurred()) return NULL;
10248 }    Py_INCREF(Py_None);
10249     _resultobj = Py_None;
10250     return _resultobj;
10251 }
10252
10253 #define wxGrid_SetColFormatBool(_swigobj,_swigarg0)  (_swigobj->SetColFormatBool(_swigarg0))
10254 static PyObject *_wrap_wxGrid_SetColFormatBool(PyObject *self, PyObject *args, PyObject *kwargs) {
10255     PyObject * _resultobj;
10256     wxGrid * _arg0;
10257     int  _arg1;
10258     PyObject * _argo0 = 0;
10259     char *_kwnames[] = { "self","col", NULL };
10260
10261     self = self;
10262     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColFormatBool",_kwnames,&_argo0,&_arg1))
10263         return NULL;
10264     if (_argo0) {
10265         if (_argo0 == Py_None) { _arg0 = NULL; }
10266         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10267             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatBool. Expected _wxGrid_p.");
10268         return NULL;
10269         }
10270     }
10271 {
10272     wxPy_BEGIN_ALLOW_THREADS;
10273         wxGrid_SetColFormatBool(_arg0,_arg1);
10274
10275     wxPy_END_ALLOW_THREADS;
10276     if (PyErr_Occurred()) return NULL;
10277 }    Py_INCREF(Py_None);
10278     _resultobj = Py_None;
10279     return _resultobj;
10280 }
10281
10282 #define wxGrid_SetColFormatNumber(_swigobj,_swigarg0)  (_swigobj->SetColFormatNumber(_swigarg0))
10283 static PyObject *_wrap_wxGrid_SetColFormatNumber(PyObject *self, PyObject *args, PyObject *kwargs) {
10284     PyObject * _resultobj;
10285     wxGrid * _arg0;
10286     int  _arg1;
10287     PyObject * _argo0 = 0;
10288     char *_kwnames[] = { "self","col", NULL };
10289
10290     self = self;
10291     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_SetColFormatNumber",_kwnames,&_argo0,&_arg1))
10292         return NULL;
10293     if (_argo0) {
10294         if (_argo0 == Py_None) { _arg0 = NULL; }
10295         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10296             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatNumber. Expected _wxGrid_p.");
10297         return NULL;
10298         }
10299     }
10300 {
10301     wxPy_BEGIN_ALLOW_THREADS;
10302         wxGrid_SetColFormatNumber(_arg0,_arg1);
10303
10304     wxPy_END_ALLOW_THREADS;
10305     if (PyErr_Occurred()) return NULL;
10306 }    Py_INCREF(Py_None);
10307     _resultobj = Py_None;
10308     return _resultobj;
10309 }
10310
10311 #define wxGrid_SetColFormatFloat(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetColFormatFloat(_swigarg0,_swigarg1,_swigarg2))
10312 static PyObject *_wrap_wxGrid_SetColFormatFloat(PyObject *self, PyObject *args, PyObject *kwargs) {
10313     PyObject * _resultobj;
10314     wxGrid * _arg0;
10315     int  _arg1;
10316     int  _arg2 = (int ) -1;
10317     int  _arg3 = (int ) -1;
10318     PyObject * _argo0 = 0;
10319     char *_kwnames[] = { "self","col","width","precision", NULL };
10320
10321     self = self;
10322     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|ii:wxGrid_SetColFormatFloat",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3))
10323         return NULL;
10324     if (_argo0) {
10325         if (_argo0 == Py_None) { _arg0 = NULL; }
10326         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10327             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatFloat. Expected _wxGrid_p.");
10328         return NULL;
10329         }
10330     }
10331 {
10332     wxPy_BEGIN_ALLOW_THREADS;
10333         wxGrid_SetColFormatFloat(_arg0,_arg1,_arg2,_arg3);
10334
10335     wxPy_END_ALLOW_THREADS;
10336     if (PyErr_Occurred()) return NULL;
10337 }    Py_INCREF(Py_None);
10338     _resultobj = Py_None;
10339     return _resultobj;
10340 }
10341
10342 #define wxGrid_SetColFormatCustom(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColFormatCustom(_swigarg0,_swigarg1))
10343 static PyObject *_wrap_wxGrid_SetColFormatCustom(PyObject *self, PyObject *args, PyObject *kwargs) {
10344     PyObject * _resultobj;
10345     wxGrid * _arg0;
10346     int  _arg1;
10347     wxString * _arg2;
10348     PyObject * _argo0 = 0;
10349     PyObject * _obj2 = 0;
10350     char *_kwnames[] = { "self","col","typeName", NULL };
10351
10352     self = self;
10353     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiO:wxGrid_SetColFormatCustom",_kwnames,&_argo0,&_arg1,&_obj2))
10354         return NULL;
10355     if (_argo0) {
10356         if (_argo0 == Py_None) { _arg0 = NULL; }
10357         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10358             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColFormatCustom. Expected _wxGrid_p.");
10359         return NULL;
10360         }
10361     }
10362 {
10363 #if PYTHON_API_VERSION >= 1009
10364     char* tmpPtr; int tmpSize;
10365     if (!PyString_Check(_obj2) && !PyUnicode_Check(_obj2)) {
10366         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
10367         return NULL;
10368     }
10369     if (PyString_AsStringAndSize(_obj2, &tmpPtr, &tmpSize) == -1)
10370         return NULL;
10371     _arg2 = new wxString(tmpPtr, tmpSize);
10372 #else
10373     if (!PyString_Check(_obj2)) {
10374         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
10375         return NULL;
10376     }
10377     _arg2 = new wxString(PyString_AS_STRING(_obj2), PyString_GET_SIZE(_obj2));
10378 #endif
10379 }
10380 {
10381     wxPy_BEGIN_ALLOW_THREADS;
10382         wxGrid_SetColFormatCustom(_arg0,_arg1,*_arg2);
10383
10384     wxPy_END_ALLOW_THREADS;
10385     if (PyErr_Occurred()) return NULL;
10386 }    Py_INCREF(Py_None);
10387     _resultobj = Py_None;
10388 {
10389     if (_obj2)
10390         delete _arg2;
10391 }
10392     return _resultobj;
10393 }
10394
10395 #define wxGrid_EnableGridLines(_swigobj,_swigarg0)  (_swigobj->EnableGridLines(_swigarg0))
10396 static PyObject *_wrap_wxGrid_EnableGridLines(PyObject *self, PyObject *args, PyObject *kwargs) {
10397     PyObject * _resultobj;
10398     wxGrid * _arg0;
10399     bool  _arg1 = (bool ) TRUE;
10400     PyObject * _argo0 = 0;
10401     int tempbool1 = (int) TRUE;
10402     char *_kwnames[] = { "self","enable", NULL };
10403
10404     self = self;
10405     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_EnableGridLines",_kwnames,&_argo0,&tempbool1))
10406         return NULL;
10407     if (_argo0) {
10408         if (_argo0 == Py_None) { _arg0 = NULL; }
10409         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10410             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_EnableGridLines. Expected _wxGrid_p.");
10411         return NULL;
10412         }
10413     }
10414     _arg1 = (bool ) tempbool1;
10415 {
10416     wxPy_BEGIN_ALLOW_THREADS;
10417         wxGrid_EnableGridLines(_arg0,_arg1);
10418
10419     wxPy_END_ALLOW_THREADS;
10420     if (PyErr_Occurred()) return NULL;
10421 }    Py_INCREF(Py_None);
10422     _resultobj = Py_None;
10423     return _resultobj;
10424 }
10425
10426 #define wxGrid_GridLinesEnabled(_swigobj)  (_swigobj->GridLinesEnabled())
10427 static PyObject *_wrap_wxGrid_GridLinesEnabled(PyObject *self, PyObject *args, PyObject *kwargs) {
10428     PyObject * _resultobj;
10429     bool  _result;
10430     wxGrid * _arg0;
10431     PyObject * _argo0 = 0;
10432     char *_kwnames[] = { "self", NULL };
10433
10434     self = self;
10435     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GridLinesEnabled",_kwnames,&_argo0))
10436         return NULL;
10437     if (_argo0) {
10438         if (_argo0 == Py_None) { _arg0 = NULL; }
10439         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10440             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GridLinesEnabled. Expected _wxGrid_p.");
10441         return NULL;
10442         }
10443     }
10444 {
10445     wxPy_BEGIN_ALLOW_THREADS;
10446         _result = (bool )wxGrid_GridLinesEnabled(_arg0);
10447
10448     wxPy_END_ALLOW_THREADS;
10449     if (PyErr_Occurred()) return NULL;
10450 }    _resultobj = Py_BuildValue("i",_result);
10451     return _resultobj;
10452 }
10453
10454 #define wxGrid_GetDefaultRowSize(_swigobj)  (_swigobj->GetDefaultRowSize())
10455 static PyObject *_wrap_wxGrid_GetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10456     PyObject * _resultobj;
10457     int  _result;
10458     wxGrid * _arg0;
10459     PyObject * _argo0 = 0;
10460     char *_kwnames[] = { "self", NULL };
10461
10462     self = self;
10463     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRowSize",_kwnames,&_argo0))
10464         return NULL;
10465     if (_argo0) {
10466         if (_argo0 == Py_None) { _arg0 = NULL; }
10467         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10468             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRowSize. Expected _wxGrid_p.");
10469         return NULL;
10470         }
10471     }
10472 {
10473     wxPy_BEGIN_ALLOW_THREADS;
10474         _result = (int )wxGrid_GetDefaultRowSize(_arg0);
10475
10476     wxPy_END_ALLOW_THREADS;
10477     if (PyErr_Occurred()) return NULL;
10478 }    _resultobj = Py_BuildValue("i",_result);
10479     return _resultobj;
10480 }
10481
10482 #define wxGrid_GetRowSize(_swigobj,_swigarg0)  (_swigobj->GetRowSize(_swigarg0))
10483 static PyObject *_wrap_wxGrid_GetRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10484     PyObject * _resultobj;
10485     int  _result;
10486     wxGrid * _arg0;
10487     int  _arg1;
10488     PyObject * _argo0 = 0;
10489     char *_kwnames[] = { "self","row", NULL };
10490
10491     self = self;
10492     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetRowSize",_kwnames,&_argo0,&_arg1))
10493         return NULL;
10494     if (_argo0) {
10495         if (_argo0 == Py_None) { _arg0 = NULL; }
10496         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10497             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetRowSize. Expected _wxGrid_p.");
10498         return NULL;
10499         }
10500     }
10501 {
10502     wxPy_BEGIN_ALLOW_THREADS;
10503         _result = (int )wxGrid_GetRowSize(_arg0,_arg1);
10504
10505     wxPy_END_ALLOW_THREADS;
10506     if (PyErr_Occurred()) return NULL;
10507 }    _resultobj = Py_BuildValue("i",_result);
10508     return _resultobj;
10509 }
10510
10511 #define wxGrid_GetDefaultColSize(_swigobj)  (_swigobj->GetDefaultColSize())
10512 static PyObject *_wrap_wxGrid_GetDefaultColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10513     PyObject * _resultobj;
10514     int  _result;
10515     wxGrid * _arg0;
10516     PyObject * _argo0 = 0;
10517     char *_kwnames[] = { "self", NULL };
10518
10519     self = self;
10520     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultColSize",_kwnames,&_argo0))
10521         return NULL;
10522     if (_argo0) {
10523         if (_argo0 == Py_None) { _arg0 = NULL; }
10524         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10525             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultColSize. Expected _wxGrid_p.");
10526         return NULL;
10527         }
10528     }
10529 {
10530     wxPy_BEGIN_ALLOW_THREADS;
10531         _result = (int )wxGrid_GetDefaultColSize(_arg0);
10532
10533     wxPy_END_ALLOW_THREADS;
10534     if (PyErr_Occurred()) return NULL;
10535 }    _resultobj = Py_BuildValue("i",_result);
10536     return _resultobj;
10537 }
10538
10539 #define wxGrid_GetColSize(_swigobj,_swigarg0)  (_swigobj->GetColSize(_swigarg0))
10540 static PyObject *_wrap_wxGrid_GetColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10541     PyObject * _resultobj;
10542     int  _result;
10543     wxGrid * _arg0;
10544     int  _arg1;
10545     PyObject * _argo0 = 0;
10546     char *_kwnames[] = { "self","col", NULL };
10547
10548     self = self;
10549     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGrid_GetColSize",_kwnames,&_argo0,&_arg1))
10550         return NULL;
10551     if (_argo0) {
10552         if (_argo0 == Py_None) { _arg0 = NULL; }
10553         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10554             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetColSize. Expected _wxGrid_p.");
10555         return NULL;
10556         }
10557     }
10558 {
10559     wxPy_BEGIN_ALLOW_THREADS;
10560         _result = (int )wxGrid_GetColSize(_arg0,_arg1);
10561
10562     wxPy_END_ALLOW_THREADS;
10563     if (PyErr_Occurred()) return NULL;
10564 }    _resultobj = Py_BuildValue("i",_result);
10565     return _resultobj;
10566 }
10567
10568 #define wxGrid_GetDefaultCellBackgroundColour(_swigobj)  (_swigobj->GetDefaultCellBackgroundColour())
10569 static PyObject *_wrap_wxGrid_GetDefaultCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10570     PyObject * _resultobj;
10571     wxColour * _result;
10572     wxGrid * _arg0;
10573     PyObject * _argo0 = 0;
10574     char *_kwnames[] = { "self", NULL };
10575     char _ptemp[128];
10576
10577     self = self;
10578     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellBackgroundColour",_kwnames,&_argo0))
10579         return NULL;
10580     if (_argo0) {
10581         if (_argo0 == Py_None) { _arg0 = NULL; }
10582         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10583             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellBackgroundColour. Expected _wxGrid_p.");
10584         return NULL;
10585         }
10586     }
10587 {
10588     wxPy_BEGIN_ALLOW_THREADS;
10589         _result = new wxColour (wxGrid_GetDefaultCellBackgroundColour(_arg0));
10590
10591     wxPy_END_ALLOW_THREADS;
10592     if (PyErr_Occurred()) return NULL;
10593 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10594     _resultobj = Py_BuildValue("s",_ptemp);
10595     return _resultobj;
10596 }
10597
10598 #define wxGrid_GetCellBackgroundColour(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellBackgroundColour(_swigarg0,_swigarg1))
10599 static PyObject *_wrap_wxGrid_GetCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10600     PyObject * _resultobj;
10601     wxColour * _result;
10602     wxGrid * _arg0;
10603     int  _arg1;
10604     int  _arg2;
10605     PyObject * _argo0 = 0;
10606     char *_kwnames[] = { "self","row","col", NULL };
10607     char _ptemp[128];
10608
10609     self = self;
10610     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellBackgroundColour",_kwnames,&_argo0,&_arg1,&_arg2))
10611         return NULL;
10612     if (_argo0) {
10613         if (_argo0 == Py_None) { _arg0 = NULL; }
10614         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10615             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellBackgroundColour. Expected _wxGrid_p.");
10616         return NULL;
10617         }
10618     }
10619 {
10620     wxPy_BEGIN_ALLOW_THREADS;
10621         _result = new wxColour (wxGrid_GetCellBackgroundColour(_arg0,_arg1,_arg2));
10622
10623     wxPy_END_ALLOW_THREADS;
10624     if (PyErr_Occurred()) return NULL;
10625 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10626     _resultobj = Py_BuildValue("s",_ptemp);
10627     return _resultobj;
10628 }
10629
10630 #define wxGrid_GetDefaultCellTextColour(_swigobj)  (_swigobj->GetDefaultCellTextColour())
10631 static PyObject *_wrap_wxGrid_GetDefaultCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10632     PyObject * _resultobj;
10633     wxColour * _result;
10634     wxGrid * _arg0;
10635     PyObject * _argo0 = 0;
10636     char *_kwnames[] = { "self", NULL };
10637     char _ptemp[128];
10638
10639     self = self;
10640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellTextColour",_kwnames,&_argo0))
10641         return NULL;
10642     if (_argo0) {
10643         if (_argo0 == Py_None) { _arg0 = NULL; }
10644         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10645             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellTextColour. Expected _wxGrid_p.");
10646         return NULL;
10647         }
10648     }
10649 {
10650     wxPy_BEGIN_ALLOW_THREADS;
10651         _result = new wxColour (wxGrid_GetDefaultCellTextColour(_arg0));
10652
10653     wxPy_END_ALLOW_THREADS;
10654     if (PyErr_Occurred()) return NULL;
10655 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10656     _resultobj = Py_BuildValue("s",_ptemp);
10657     return _resultobj;
10658 }
10659
10660 #define wxGrid_GetCellTextColour(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellTextColour(_swigarg0,_swigarg1))
10661 static PyObject *_wrap_wxGrid_GetCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
10662     PyObject * _resultobj;
10663     wxColour * _result;
10664     wxGrid * _arg0;
10665     int  _arg1;
10666     int  _arg2;
10667     PyObject * _argo0 = 0;
10668     char *_kwnames[] = { "self","row","col", NULL };
10669     char _ptemp[128];
10670
10671     self = self;
10672     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellTextColour",_kwnames,&_argo0,&_arg1,&_arg2))
10673         return NULL;
10674     if (_argo0) {
10675         if (_argo0 == Py_None) { _arg0 = NULL; }
10676         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10677             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellTextColour. Expected _wxGrid_p.");
10678         return NULL;
10679         }
10680     }
10681 {
10682     wxPy_BEGIN_ALLOW_THREADS;
10683         _result = new wxColour (wxGrid_GetCellTextColour(_arg0,_arg1,_arg2));
10684
10685     wxPy_END_ALLOW_THREADS;
10686     if (PyErr_Occurred()) return NULL;
10687 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
10688     _resultobj = Py_BuildValue("s",_ptemp);
10689     return _resultobj;
10690 }
10691
10692 #define wxGrid_GetDefaultCellFont(_swigobj)  (_swigobj->GetDefaultCellFont())
10693 static PyObject *_wrap_wxGrid_GetDefaultCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
10694     PyObject * _resultobj;
10695     wxFont * _result;
10696     wxGrid * _arg0;
10697     PyObject * _argo0 = 0;
10698     char *_kwnames[] = { "self", NULL };
10699     char _ptemp[128];
10700
10701     self = self;
10702     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultCellFont",_kwnames,&_argo0))
10703         return NULL;
10704     if (_argo0) {
10705         if (_argo0 == Py_None) { _arg0 = NULL; }
10706         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10707             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellFont. Expected _wxGrid_p.");
10708         return NULL;
10709         }
10710     }
10711 {
10712     wxPy_BEGIN_ALLOW_THREADS;
10713         _result = new wxFont (wxGrid_GetDefaultCellFont(_arg0));
10714
10715     wxPy_END_ALLOW_THREADS;
10716     if (PyErr_Occurred()) return NULL;
10717 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
10718     _resultobj = Py_BuildValue("s",_ptemp);
10719     return _resultobj;
10720 }
10721
10722 #define wxGrid_GetCellFont(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellFont(_swigarg0,_swigarg1))
10723 static PyObject *_wrap_wxGrid_GetCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
10724     PyObject * _resultobj;
10725     wxFont * _result;
10726     wxGrid * _arg0;
10727     int  _arg1;
10728     int  _arg2;
10729     PyObject * _argo0 = 0;
10730     char *_kwnames[] = { "self","row","col", NULL };
10731     char _ptemp[128];
10732
10733     self = self;
10734     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellFont",_kwnames,&_argo0,&_arg1,&_arg2))
10735         return NULL;
10736     if (_argo0) {
10737         if (_argo0 == Py_None) { _arg0 = NULL; }
10738         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10739             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellFont. Expected _wxGrid_p.");
10740         return NULL;
10741         }
10742     }
10743 {
10744     wxPy_BEGIN_ALLOW_THREADS;
10745         _result = new wxFont (wxGrid_GetCellFont(_arg0,_arg1,_arg2));
10746
10747     wxPy_END_ALLOW_THREADS;
10748     if (PyErr_Occurred()) return NULL;
10749 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxFont_p");
10750     _resultobj = Py_BuildValue("s",_ptemp);
10751     return _resultobj;
10752 }
10753
10754 #define wxGrid_GetDefaultCellAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultCellAlignment(_swigarg0,_swigarg1))
10755 static PyObject *_wrap_wxGrid_GetDefaultCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
10756     PyObject * _resultobj;
10757     wxGrid * _arg0;
10758     int * _arg1;
10759     int * _arg2;
10760     PyObject * _argo0 = 0;
10761     PyObject * _argo1 = 0;
10762     PyObject * _argo2 = 0;
10763     char *_kwnames[] = { "self","horiz","vert", NULL };
10764
10765     self = self;
10766     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_GetDefaultCellAlignment",_kwnames,&_argo0,&_argo1,&_argo2))
10767         return NULL;
10768     if (_argo0) {
10769         if (_argo0 == Py_None) { _arg0 = NULL; }
10770         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10771             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultCellAlignment. Expected _wxGrid_p.");
10772         return NULL;
10773         }
10774     }
10775     if (_argo1) {
10776         if (_argo1 == Py_None) { _arg1 = NULL; }
10777         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_int_p")) {
10778             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_GetDefaultCellAlignment. Expected _int_p.");
10779         return NULL;
10780         }
10781     }
10782     if (_argo2) {
10783         if (_argo2 == Py_None) { _arg2 = NULL; }
10784         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_int_p")) {
10785             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_GetDefaultCellAlignment. Expected _int_p.");
10786         return NULL;
10787         }
10788     }
10789 {
10790     wxPy_BEGIN_ALLOW_THREADS;
10791         wxGrid_GetDefaultCellAlignment(_arg0,_arg1,_arg2);
10792
10793     wxPy_END_ALLOW_THREADS;
10794     if (PyErr_Occurred()) return NULL;
10795 }    Py_INCREF(Py_None);
10796     _resultobj = Py_None;
10797     return _resultobj;
10798 }
10799
10800 #define wxGrid_GetCellAlignment(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->GetCellAlignment(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
10801 static PyObject *_wrap_wxGrid_GetCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
10802     PyObject * _resultobj;
10803     wxGrid * _arg0;
10804     int  _arg1;
10805     int  _arg2;
10806     int * _arg3;
10807     int * _arg4;
10808     PyObject * _argo0 = 0;
10809     PyObject * _argo3 = 0;
10810     PyObject * _argo4 = 0;
10811     char *_kwnames[] = { "self","row","col","horiz","vert", NULL };
10812
10813     self = self;
10814     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiOO:wxGrid_GetCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3,&_argo4))
10815         return NULL;
10816     if (_argo0) {
10817         if (_argo0 == Py_None) { _arg0 = NULL; }
10818         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10819             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellAlignment. Expected _wxGrid_p.");
10820         return NULL;
10821         }
10822     }
10823     if (_argo3) {
10824         if (_argo3 == Py_None) { _arg3 = NULL; }
10825         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_int_p")) {
10826             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_GetCellAlignment. Expected _int_p.");
10827         return NULL;
10828         }
10829     }
10830     if (_argo4) {
10831         if (_argo4 == Py_None) { _arg4 = NULL; }
10832         else if (SWIG_GetPtrObj(_argo4,(void **) &_arg4,"_int_p")) {
10833             PyErr_SetString(PyExc_TypeError,"Type error in argument 5 of wxGrid_GetCellAlignment. Expected _int_p.");
10834         return NULL;
10835         }
10836     }
10837 {
10838     wxPy_BEGIN_ALLOW_THREADS;
10839         wxGrid_GetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
10840
10841     wxPy_END_ALLOW_THREADS;
10842     if (PyErr_Occurred()) return NULL;
10843 }    Py_INCREF(Py_None);
10844     _resultobj = Py_None;
10845     return _resultobj;
10846 }
10847
10848 #define wxGrid_SetDefaultRowSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultRowSize(_swigarg0,_swigarg1))
10849 static PyObject *_wrap_wxGrid_SetDefaultRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10850     PyObject * _resultobj;
10851     wxGrid * _arg0;
10852     int  _arg1;
10853     bool  _arg2 = (bool ) FALSE;
10854     PyObject * _argo0 = 0;
10855     int tempbool2 = (int) FALSE;
10856     char *_kwnames[] = { "self","height","resizeExistingRows", NULL };
10857
10858     self = self;
10859     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SetDefaultRowSize",_kwnames,&_argo0,&_arg1,&tempbool2))
10860         return NULL;
10861     if (_argo0) {
10862         if (_argo0 == Py_None) { _arg0 = NULL; }
10863         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10864             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultRowSize. Expected _wxGrid_p.");
10865         return NULL;
10866         }
10867     }
10868     _arg2 = (bool ) tempbool2;
10869 {
10870     wxPy_BEGIN_ALLOW_THREADS;
10871         wxGrid_SetDefaultRowSize(_arg0,_arg1,_arg2);
10872
10873     wxPy_END_ALLOW_THREADS;
10874     if (PyErr_Occurred()) return NULL;
10875 }    Py_INCREF(Py_None);
10876     _resultobj = Py_None;
10877     return _resultobj;
10878 }
10879
10880 #define wxGrid_SetRowSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowSize(_swigarg0,_swigarg1))
10881 static PyObject *_wrap_wxGrid_SetRowSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10882     PyObject * _resultobj;
10883     wxGrid * _arg0;
10884     int  _arg1;
10885     int  _arg2;
10886     PyObject * _argo0 = 0;
10887     char *_kwnames[] = { "self","row","height", NULL };
10888
10889     self = self;
10890     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowSize",_kwnames,&_argo0,&_arg1,&_arg2))
10891         return NULL;
10892     if (_argo0) {
10893         if (_argo0 == Py_None) { _arg0 = NULL; }
10894         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10895             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowSize. Expected _wxGrid_p.");
10896         return NULL;
10897         }
10898     }
10899 {
10900     wxPy_BEGIN_ALLOW_THREADS;
10901         wxGrid_SetRowSize(_arg0,_arg1,_arg2);
10902
10903     wxPy_END_ALLOW_THREADS;
10904     if (PyErr_Occurred()) return NULL;
10905 }    Py_INCREF(Py_None);
10906     _resultobj = Py_None;
10907     return _resultobj;
10908 }
10909
10910 #define wxGrid_SetDefaultColSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultColSize(_swigarg0,_swigarg1))
10911 static PyObject *_wrap_wxGrid_SetDefaultColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10912     PyObject * _resultobj;
10913     wxGrid * _arg0;
10914     int  _arg1;
10915     bool  _arg2 = (bool ) FALSE;
10916     PyObject * _argo0 = 0;
10917     int tempbool2 = (int) FALSE;
10918     char *_kwnames[] = { "self","width","resizeExistingCols", NULL };
10919
10920     self = self;
10921     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SetDefaultColSize",_kwnames,&_argo0,&_arg1,&tempbool2))
10922         return NULL;
10923     if (_argo0) {
10924         if (_argo0 == Py_None) { _arg0 = NULL; }
10925         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10926             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultColSize. Expected _wxGrid_p.");
10927         return NULL;
10928         }
10929     }
10930     _arg2 = (bool ) tempbool2;
10931 {
10932     wxPy_BEGIN_ALLOW_THREADS;
10933         wxGrid_SetDefaultColSize(_arg0,_arg1,_arg2);
10934
10935     wxPy_END_ALLOW_THREADS;
10936     if (PyErr_Occurred()) return NULL;
10937 }    Py_INCREF(Py_None);
10938     _resultobj = Py_None;
10939     return _resultobj;
10940 }
10941
10942 #define wxGrid_SetColSize(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColSize(_swigarg0,_swigarg1))
10943 static PyObject *_wrap_wxGrid_SetColSize(PyObject *self, PyObject *args, PyObject *kwargs) {
10944     PyObject * _resultobj;
10945     wxGrid * _arg0;
10946     int  _arg1;
10947     int  _arg2;
10948     PyObject * _argo0 = 0;
10949     char *_kwnames[] = { "self","col","width", NULL };
10950
10951     self = self;
10952     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColSize",_kwnames,&_argo0,&_arg1,&_arg2))
10953         return NULL;
10954     if (_argo0) {
10955         if (_argo0 == Py_None) { _arg0 = NULL; }
10956         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10957             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColSize. Expected _wxGrid_p.");
10958         return NULL;
10959         }
10960     }
10961 {
10962     wxPy_BEGIN_ALLOW_THREADS;
10963         wxGrid_SetColSize(_arg0,_arg1,_arg2);
10964
10965     wxPy_END_ALLOW_THREADS;
10966     if (PyErr_Occurred()) return NULL;
10967 }    Py_INCREF(Py_None);
10968     _resultobj = Py_None;
10969     return _resultobj;
10970 }
10971
10972 #define wxGrid_AutoSizeColumn(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AutoSizeColumn(_swigarg0,_swigarg1))
10973 static PyObject *_wrap_wxGrid_AutoSizeColumn(PyObject *self, PyObject *args, PyObject *kwargs) {
10974     PyObject * _resultobj;
10975     wxGrid * _arg0;
10976     int  _arg1;
10977     bool  _arg2 = (bool ) TRUE;
10978     PyObject * _argo0 = 0;
10979     int tempbool2 = (int) TRUE;
10980     char *_kwnames[] = { "self","col","setAsMin", NULL };
10981
10982     self = self;
10983     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_AutoSizeColumn",_kwnames,&_argo0,&_arg1,&tempbool2))
10984         return NULL;
10985     if (_argo0) {
10986         if (_argo0 == Py_None) { _arg0 = NULL; }
10987         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
10988             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeColumn. Expected _wxGrid_p.");
10989         return NULL;
10990         }
10991     }
10992     _arg2 = (bool ) tempbool2;
10993 {
10994     wxPy_BEGIN_ALLOW_THREADS;
10995         wxGrid_AutoSizeColumn(_arg0,_arg1,_arg2);
10996
10997     wxPy_END_ALLOW_THREADS;
10998     if (PyErr_Occurred()) return NULL;
10999 }    Py_INCREF(Py_None);
11000     _resultobj = Py_None;
11001     return _resultobj;
11002 }
11003
11004 #define wxGrid_AutoSizeRow(_swigobj,_swigarg0,_swigarg1)  (_swigobj->AutoSizeRow(_swigarg0,_swigarg1))
11005 static PyObject *_wrap_wxGrid_AutoSizeRow(PyObject *self, PyObject *args, PyObject *kwargs) {
11006     PyObject * _resultobj;
11007     wxGrid * _arg0;
11008     int  _arg1;
11009     bool  _arg2 = (bool ) TRUE;
11010     PyObject * _argo0 = 0;
11011     int tempbool2 = (int) TRUE;
11012     char *_kwnames[] = { "self","row","setAsMin", NULL };
11013
11014     self = self;
11015     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_AutoSizeRow",_kwnames,&_argo0,&_arg1,&tempbool2))
11016         return NULL;
11017     if (_argo0) {
11018         if (_argo0 == Py_None) { _arg0 = NULL; }
11019         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11020             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeRow. Expected _wxGrid_p.");
11021         return NULL;
11022         }
11023     }
11024     _arg2 = (bool ) tempbool2;
11025 {
11026     wxPy_BEGIN_ALLOW_THREADS;
11027         wxGrid_AutoSizeRow(_arg0,_arg1,_arg2);
11028
11029     wxPy_END_ALLOW_THREADS;
11030     if (PyErr_Occurred()) return NULL;
11031 }    Py_INCREF(Py_None);
11032     _resultobj = Py_None;
11033     return _resultobj;
11034 }
11035
11036 #define wxGrid_AutoSizeColumns(_swigobj,_swigarg0)  (_swigobj->AutoSizeColumns(_swigarg0))
11037 static PyObject *_wrap_wxGrid_AutoSizeColumns(PyObject *self, PyObject *args, PyObject *kwargs) {
11038     PyObject * _resultobj;
11039     wxGrid * _arg0;
11040     bool  _arg1 = (bool ) TRUE;
11041     PyObject * _argo0 = 0;
11042     int tempbool1 = (int) TRUE;
11043     char *_kwnames[] = { "self","setAsMin", NULL };
11044
11045     self = self;
11046     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_AutoSizeColumns",_kwnames,&_argo0,&tempbool1))
11047         return NULL;
11048     if (_argo0) {
11049         if (_argo0 == Py_None) { _arg0 = NULL; }
11050         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11051             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeColumns. Expected _wxGrid_p.");
11052         return NULL;
11053         }
11054     }
11055     _arg1 = (bool ) tempbool1;
11056 {
11057     wxPy_BEGIN_ALLOW_THREADS;
11058         wxGrid_AutoSizeColumns(_arg0,_arg1);
11059
11060     wxPy_END_ALLOW_THREADS;
11061     if (PyErr_Occurred()) return NULL;
11062 }    Py_INCREF(Py_None);
11063     _resultobj = Py_None;
11064     return _resultobj;
11065 }
11066
11067 #define wxGrid_AutoSizeRows(_swigobj,_swigarg0)  (_swigobj->AutoSizeRows(_swigarg0))
11068 static PyObject *_wrap_wxGrid_AutoSizeRows(PyObject *self, PyObject *args, PyObject *kwargs) {
11069     PyObject * _resultobj;
11070     wxGrid * _arg0;
11071     bool  _arg1 = (bool ) TRUE;
11072     PyObject * _argo0 = 0;
11073     int tempbool1 = (int) TRUE;
11074     char *_kwnames[] = { "self","setAsMin", NULL };
11075
11076     self = self;
11077     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|i:wxGrid_AutoSizeRows",_kwnames,&_argo0,&tempbool1))
11078         return NULL;
11079     if (_argo0) {
11080         if (_argo0 == Py_None) { _arg0 = NULL; }
11081         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11082             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSizeRows. Expected _wxGrid_p.");
11083         return NULL;
11084         }
11085     }
11086     _arg1 = (bool ) tempbool1;
11087 {
11088     wxPy_BEGIN_ALLOW_THREADS;
11089         wxGrid_AutoSizeRows(_arg0,_arg1);
11090
11091     wxPy_END_ALLOW_THREADS;
11092     if (PyErr_Occurred()) return NULL;
11093 }    Py_INCREF(Py_None);
11094     _resultobj = Py_None;
11095     return _resultobj;
11096 }
11097
11098 #define wxGrid_AutoSize(_swigobj)  (_swigobj->AutoSize())
11099 static PyObject *_wrap_wxGrid_AutoSize(PyObject *self, PyObject *args, PyObject *kwargs) {
11100     PyObject * _resultobj;
11101     wxGrid * _arg0;
11102     PyObject * _argo0 = 0;
11103     char *_kwnames[] = { "self", NULL };
11104
11105     self = self;
11106     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_AutoSize",_kwnames,&_argo0))
11107         return NULL;
11108     if (_argo0) {
11109         if (_argo0 == Py_None) { _arg0 = NULL; }
11110         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11111             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_AutoSize. Expected _wxGrid_p.");
11112         return NULL;
11113         }
11114     }
11115 {
11116     wxPy_BEGIN_ALLOW_THREADS;
11117         wxGrid_AutoSize(_arg0);
11118
11119     wxPy_END_ALLOW_THREADS;
11120     if (PyErr_Occurred()) return NULL;
11121 }    Py_INCREF(Py_None);
11122     _resultobj = Py_None;
11123     return _resultobj;
11124 }
11125
11126 #define wxGrid_SetColMinimalWidth(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetColMinimalWidth(_swigarg0,_swigarg1))
11127 static PyObject *_wrap_wxGrid_SetColMinimalWidth(PyObject *self, PyObject *args, PyObject *kwargs) {
11128     PyObject * _resultobj;
11129     wxGrid * _arg0;
11130     int  _arg1;
11131     int  _arg2;
11132     PyObject * _argo0 = 0;
11133     char *_kwnames[] = { "self","col","width", NULL };
11134
11135     self = self;
11136     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetColMinimalWidth",_kwnames,&_argo0,&_arg1,&_arg2))
11137         return NULL;
11138     if (_argo0) {
11139         if (_argo0 == Py_None) { _arg0 = NULL; }
11140         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11141             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetColMinimalWidth. Expected _wxGrid_p.");
11142         return NULL;
11143         }
11144     }
11145 {
11146     wxPy_BEGIN_ALLOW_THREADS;
11147         wxGrid_SetColMinimalWidth(_arg0,_arg1,_arg2);
11148
11149     wxPy_END_ALLOW_THREADS;
11150     if (PyErr_Occurred()) return NULL;
11151 }    Py_INCREF(Py_None);
11152     _resultobj = Py_None;
11153     return _resultobj;
11154 }
11155
11156 #define wxGrid_SetRowMinimalHeight(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetRowMinimalHeight(_swigarg0,_swigarg1))
11157 static PyObject *_wrap_wxGrid_SetRowMinimalHeight(PyObject *self, PyObject *args, PyObject *kwargs) {
11158     PyObject * _resultobj;
11159     wxGrid * _arg0;
11160     int  _arg1;
11161     int  _arg2;
11162     PyObject * _argo0 = 0;
11163     char *_kwnames[] = { "self","row","width", NULL };
11164
11165     self = self;
11166     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetRowMinimalHeight",_kwnames,&_argo0,&_arg1,&_arg2))
11167         return NULL;
11168     if (_argo0) {
11169         if (_argo0 == Py_None) { _arg0 = NULL; }
11170         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11171             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetRowMinimalHeight. Expected _wxGrid_p.");
11172         return NULL;
11173         }
11174     }
11175 {
11176     wxPy_BEGIN_ALLOW_THREADS;
11177         wxGrid_SetRowMinimalHeight(_arg0,_arg1,_arg2);
11178
11179     wxPy_END_ALLOW_THREADS;
11180     if (PyErr_Occurred()) return NULL;
11181 }    Py_INCREF(Py_None);
11182     _resultobj = Py_None;
11183     return _resultobj;
11184 }
11185
11186 #define wxGrid_SetDefaultCellBackgroundColour(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellBackgroundColour(_swigarg0))
11187 static PyObject *_wrap_wxGrid_SetDefaultCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11188     PyObject * _resultobj;
11189     wxGrid * _arg0;
11190     wxColour * _arg1;
11191     PyObject * _argo0 = 0;
11192     wxColour  temp;
11193     PyObject * _obj1 = 0;
11194     char *_kwnames[] = { "self","arg2", NULL };
11195
11196     self = self;
11197     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellBackgroundColour",_kwnames,&_argo0,&_obj1))
11198         return NULL;
11199     if (_argo0) {
11200         if (_argo0 == Py_None) { _arg0 = NULL; }
11201         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11202             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellBackgroundColour. Expected _wxGrid_p.");
11203         return NULL;
11204         }
11205     }
11206 {
11207     _arg1 = &temp;
11208     if (! wxColour_helper(_obj1, &_arg1))
11209         return NULL;
11210 }
11211 {
11212     wxPy_BEGIN_ALLOW_THREADS;
11213         wxGrid_SetDefaultCellBackgroundColour(_arg0,*_arg1);
11214
11215     wxPy_END_ALLOW_THREADS;
11216     if (PyErr_Occurred()) return NULL;
11217 }    Py_INCREF(Py_None);
11218     _resultobj = Py_None;
11219     return _resultobj;
11220 }
11221
11222 #define wxGrid_SetCellBackgroundColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellBackgroundColour(_swigarg0,_swigarg1,_swigarg2))
11223 static PyObject *_wrap_wxGrid_SetCellBackgroundColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11224     PyObject * _resultobj;
11225     wxGrid * _arg0;
11226     int  _arg1;
11227     int  _arg2;
11228     wxColour * _arg3;
11229     PyObject * _argo0 = 0;
11230     wxColour  temp;
11231     PyObject * _obj3 = 0;
11232     char *_kwnames[] = { "self","row","col","arg4", NULL };
11233
11234     self = self;
11235     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellBackgroundColour",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11236         return NULL;
11237     if (_argo0) {
11238         if (_argo0 == Py_None) { _arg0 = NULL; }
11239         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11240             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellBackgroundColour. Expected _wxGrid_p.");
11241         return NULL;
11242         }
11243     }
11244 {
11245     _arg3 = &temp;
11246     if (! wxColour_helper(_obj3, &_arg3))
11247         return NULL;
11248 }
11249 {
11250     wxPy_BEGIN_ALLOW_THREADS;
11251         wxGrid_SetCellBackgroundColour(_arg0,_arg1,_arg2,*_arg3);
11252
11253     wxPy_END_ALLOW_THREADS;
11254     if (PyErr_Occurred()) return NULL;
11255 }    Py_INCREF(Py_None);
11256     _resultobj = Py_None;
11257     return _resultobj;
11258 }
11259
11260 #define wxGrid_SetDefaultCellTextColour(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellTextColour(_swigarg0))
11261 static PyObject *_wrap_wxGrid_SetDefaultCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11262     PyObject * _resultobj;
11263     wxGrid * _arg0;
11264     wxColour * _arg1;
11265     PyObject * _argo0 = 0;
11266     wxColour  temp;
11267     PyObject * _obj1 = 0;
11268     char *_kwnames[] = { "self","arg2", NULL };
11269
11270     self = self;
11271     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellTextColour",_kwnames,&_argo0,&_obj1))
11272         return NULL;
11273     if (_argo0) {
11274         if (_argo0 == Py_None) { _arg0 = NULL; }
11275         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11276             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellTextColour. Expected _wxGrid_p.");
11277         return NULL;
11278         }
11279     }
11280 {
11281     _arg1 = &temp;
11282     if (! wxColour_helper(_obj1, &_arg1))
11283         return NULL;
11284 }
11285 {
11286     wxPy_BEGIN_ALLOW_THREADS;
11287         wxGrid_SetDefaultCellTextColour(_arg0,*_arg1);
11288
11289     wxPy_END_ALLOW_THREADS;
11290     if (PyErr_Occurred()) return NULL;
11291 }    Py_INCREF(Py_None);
11292     _resultobj = Py_None;
11293     return _resultobj;
11294 }
11295
11296 #define wxGrid_SetCellTextColour(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellTextColour(_swigarg0,_swigarg1,_swigarg2))
11297 static PyObject *_wrap_wxGrid_SetCellTextColour(PyObject *self, PyObject *args, PyObject *kwargs) {
11298     PyObject * _resultobj;
11299     wxGrid * _arg0;
11300     int  _arg1;
11301     int  _arg2;
11302     wxColour * _arg3;
11303     PyObject * _argo0 = 0;
11304     wxColour  temp;
11305     PyObject * _obj3 = 0;
11306     char *_kwnames[] = { "self","row","col","arg4", NULL };
11307
11308     self = self;
11309     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellTextColour",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11310         return NULL;
11311     if (_argo0) {
11312         if (_argo0 == Py_None) { _arg0 = NULL; }
11313         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11314             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellTextColour. Expected _wxGrid_p.");
11315         return NULL;
11316         }
11317     }
11318 {
11319     _arg3 = &temp;
11320     if (! wxColour_helper(_obj3, &_arg3))
11321         return NULL;
11322 }
11323 {
11324     wxPy_BEGIN_ALLOW_THREADS;
11325         wxGrid_SetCellTextColour(_arg0,_arg1,_arg2,*_arg3);
11326
11327     wxPy_END_ALLOW_THREADS;
11328     if (PyErr_Occurred()) return NULL;
11329 }    Py_INCREF(Py_None);
11330     _resultobj = Py_None;
11331     return _resultobj;
11332 }
11333
11334 #define wxGrid_SetDefaultCellFont(_swigobj,_swigarg0)  (_swigobj->SetDefaultCellFont(_swigarg0))
11335 static PyObject *_wrap_wxGrid_SetDefaultCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
11336     PyObject * _resultobj;
11337     wxGrid * _arg0;
11338     wxFont * _arg1;
11339     PyObject * _argo0 = 0;
11340     PyObject * _argo1 = 0;
11341     char *_kwnames[] = { "self","arg2", NULL };
11342
11343     self = self;
11344     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultCellFont",_kwnames,&_argo0,&_argo1))
11345         return NULL;
11346     if (_argo0) {
11347         if (_argo0 == Py_None) { _arg0 = NULL; }
11348         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11349             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellFont. Expected _wxGrid_p.");
11350         return NULL;
11351         }
11352     }
11353     if (_argo1) {
11354         if (_argo1 == Py_None) { _arg1 = NULL; }
11355         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxFont_p")) {
11356             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultCellFont. Expected _wxFont_p.");
11357         return NULL;
11358         }
11359     }
11360 {
11361     wxPy_BEGIN_ALLOW_THREADS;
11362         wxGrid_SetDefaultCellFont(_arg0,*_arg1);
11363
11364     wxPy_END_ALLOW_THREADS;
11365     if (PyErr_Occurred()) return NULL;
11366 }    Py_INCREF(Py_None);
11367     _resultobj = Py_None;
11368     return _resultobj;
11369 }
11370
11371 #define wxGrid_SetCellFont(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellFont(_swigarg0,_swigarg1,_swigarg2))
11372 static PyObject *_wrap_wxGrid_SetCellFont(PyObject *self, PyObject *args, PyObject *kwargs) {
11373     PyObject * _resultobj;
11374     wxGrid * _arg0;
11375     int  _arg1;
11376     int  _arg2;
11377     wxFont * _arg3;
11378     PyObject * _argo0 = 0;
11379     PyObject * _argo3 = 0;
11380     char *_kwnames[] = { "self","row","col","arg4", NULL };
11381
11382     self = self;
11383     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellFont",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11384         return NULL;
11385     if (_argo0) {
11386         if (_argo0 == Py_None) { _arg0 = NULL; }
11387         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11388             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellFont. Expected _wxGrid_p.");
11389         return NULL;
11390         }
11391     }
11392     if (_argo3) {
11393         if (_argo3 == Py_None) { _arg3 = NULL; }
11394         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxFont_p")) {
11395             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellFont. Expected _wxFont_p.");
11396         return NULL;
11397         }
11398     }
11399 {
11400     wxPy_BEGIN_ALLOW_THREADS;
11401         wxGrid_SetCellFont(_arg0,_arg1,_arg2,*_arg3);
11402
11403     wxPy_END_ALLOW_THREADS;
11404     if (PyErr_Occurred()) return NULL;
11405 }    Py_INCREF(Py_None);
11406     _resultobj = Py_None;
11407     return _resultobj;
11408 }
11409
11410 #define wxGrid_SetDefaultCellAlignment(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetDefaultCellAlignment(_swigarg0,_swigarg1))
11411 static PyObject *_wrap_wxGrid_SetDefaultCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
11412     PyObject * _resultobj;
11413     wxGrid * _arg0;
11414     int  _arg1;
11415     int  _arg2;
11416     PyObject * _argo0 = 0;
11417     char *_kwnames[] = { "self","horiz","vert", NULL };
11418
11419     self = self;
11420     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetDefaultCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2))
11421         return NULL;
11422     if (_argo0) {
11423         if (_argo0 == Py_None) { _arg0 = NULL; }
11424         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11425             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultCellAlignment. Expected _wxGrid_p.");
11426         return NULL;
11427         }
11428     }
11429 {
11430     wxPy_BEGIN_ALLOW_THREADS;
11431         wxGrid_SetDefaultCellAlignment(_arg0,_arg1,_arg2);
11432
11433     wxPy_END_ALLOW_THREADS;
11434     if (PyErr_Occurred()) return NULL;
11435 }    Py_INCREF(Py_None);
11436     _resultobj = Py_None;
11437     return _resultobj;
11438 }
11439
11440 #define wxGrid_SetCellAlignment(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3)  (_swigobj->SetCellAlignment(_swigarg0,_swigarg1,_swigarg2,_swigarg3))
11441 static PyObject *_wrap_wxGrid_SetCellAlignment(PyObject *self, PyObject *args, PyObject *kwargs) {
11442     PyObject * _resultobj;
11443     wxGrid * _arg0;
11444     int  _arg1;
11445     int  _arg2;
11446     int  _arg3;
11447     int  _arg4;
11448     PyObject * _argo0 = 0;
11449     char *_kwnames[] = { "self","row","col","horiz","vert", NULL };
11450
11451     self = self;
11452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii:wxGrid_SetCellAlignment",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4))
11453         return NULL;
11454     if (_argo0) {
11455         if (_argo0 == Py_None) { _arg0 = NULL; }
11456         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11457             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellAlignment. Expected _wxGrid_p.");
11458         return NULL;
11459         }
11460     }
11461 {
11462     wxPy_BEGIN_ALLOW_THREADS;
11463         wxGrid_SetCellAlignment(_arg0,_arg1,_arg2,_arg3,_arg4);
11464
11465     wxPy_END_ALLOW_THREADS;
11466     if (PyErr_Occurred()) return NULL;
11467 }    Py_INCREF(Py_None);
11468     _resultobj = Py_None;
11469     return _resultobj;
11470 }
11471
11472 #define wxGrid_SetDefaultRenderer(_swigobj,_swigarg0)  (_swigobj->SetDefaultRenderer(_swigarg0))
11473 static PyObject *_wrap_wxGrid_SetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11474     PyObject * _resultobj;
11475     wxGrid * _arg0;
11476     wxGridCellRenderer * _arg1;
11477     PyObject * _argo0 = 0;
11478     PyObject * _argo1 = 0;
11479     char *_kwnames[] = { "self","renderer", NULL };
11480
11481     self = self;
11482     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultRenderer",_kwnames,&_argo0,&_argo1))
11483         return NULL;
11484     if (_argo0) {
11485         if (_argo0 == Py_None) { _arg0 = NULL; }
11486         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11487             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultRenderer. Expected _wxGrid_p.");
11488         return NULL;
11489         }
11490     }
11491     if (_argo1) {
11492         if (_argo1 == Py_None) { _arg1 = NULL; }
11493         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellRenderer_p")) {
11494             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultRenderer. Expected _wxGridCellRenderer_p.");
11495         return NULL;
11496         }
11497     }
11498 {
11499     wxPy_BEGIN_ALLOW_THREADS;
11500         wxGrid_SetDefaultRenderer(_arg0,_arg1);
11501
11502     wxPy_END_ALLOW_THREADS;
11503     if (PyErr_Occurred()) return NULL;
11504 }    Py_INCREF(Py_None);
11505     _resultobj = Py_None;
11506     return _resultobj;
11507 }
11508
11509 #define wxGrid_SetCellRenderer(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellRenderer(_swigarg0,_swigarg1,_swigarg2))
11510 static PyObject *_wrap_wxGrid_SetCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11511     PyObject * _resultobj;
11512     wxGrid * _arg0;
11513     int  _arg1;
11514     int  _arg2;
11515     wxGridCellRenderer * _arg3;
11516     PyObject * _argo0 = 0;
11517     PyObject * _argo3 = 0;
11518     char *_kwnames[] = { "self","row","col","renderer", NULL };
11519
11520     self = self;
11521     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11522         return NULL;
11523     if (_argo0) {
11524         if (_argo0 == Py_None) { _arg0 = NULL; }
11525         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11526             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellRenderer. Expected _wxGrid_p.");
11527         return NULL;
11528         }
11529     }
11530     if (_argo3) {
11531         if (_argo3 == Py_None) { _arg3 = NULL; }
11532         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellRenderer_p")) {
11533             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellRenderer. Expected _wxGridCellRenderer_p.");
11534         return NULL;
11535         }
11536     }
11537 {
11538     wxPy_BEGIN_ALLOW_THREADS;
11539         wxGrid_SetCellRenderer(_arg0,_arg1,_arg2,_arg3);
11540
11541     wxPy_END_ALLOW_THREADS;
11542     if (PyErr_Occurred()) return NULL;
11543 }    Py_INCREF(Py_None);
11544     _resultobj = Py_None;
11545     return _resultobj;
11546 }
11547
11548 #define wxGrid_GetDefaultRenderer(_swigobj)  (_swigobj->GetDefaultRenderer())
11549 static PyObject *_wrap_wxGrid_GetDefaultRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11550     PyObject * _resultobj;
11551     wxGridCellRenderer * _result;
11552     wxGrid * _arg0;
11553     PyObject * _argo0 = 0;
11554     char *_kwnames[] = { "self", NULL };
11555     char _ptemp[128];
11556
11557     self = self;
11558     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultRenderer",_kwnames,&_argo0))
11559         return NULL;
11560     if (_argo0) {
11561         if (_argo0 == Py_None) { _arg0 = NULL; }
11562         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11563             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRenderer. Expected _wxGrid_p.");
11564         return NULL;
11565         }
11566     }
11567 {
11568     wxPy_BEGIN_ALLOW_THREADS;
11569         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRenderer(_arg0);
11570
11571     wxPy_END_ALLOW_THREADS;
11572     if (PyErr_Occurred()) return NULL;
11573 }    if (_result) {
11574         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
11575         _resultobj = Py_BuildValue("s",_ptemp);
11576     } else {
11577         Py_INCREF(Py_None);
11578         _resultobj = Py_None;
11579     }
11580     return _resultobj;
11581 }
11582
11583 #define wxGrid_GetCellRenderer(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellRenderer(_swigarg0,_swigarg1))
11584 static PyObject *_wrap_wxGrid_GetCellRenderer(PyObject *self, PyObject *args, PyObject *kwargs) {
11585     PyObject * _resultobj;
11586     wxGridCellRenderer * _result;
11587     wxGrid * _arg0;
11588     int  _arg1;
11589     int  _arg2;
11590     PyObject * _argo0 = 0;
11591     char *_kwnames[] = { "self","row","col", NULL };
11592     char _ptemp[128];
11593
11594     self = self;
11595     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellRenderer",_kwnames,&_argo0,&_arg1,&_arg2))
11596         return NULL;
11597     if (_argo0) {
11598         if (_argo0 == Py_None) { _arg0 = NULL; }
11599         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11600             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellRenderer. Expected _wxGrid_p.");
11601         return NULL;
11602         }
11603     }
11604 {
11605     wxPy_BEGIN_ALLOW_THREADS;
11606         _result = (wxGridCellRenderer *)wxGrid_GetCellRenderer(_arg0,_arg1,_arg2);
11607
11608     wxPy_END_ALLOW_THREADS;
11609     if (PyErr_Occurred()) return NULL;
11610 }    if (_result) {
11611         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
11612         _resultobj = Py_BuildValue("s",_ptemp);
11613     } else {
11614         Py_INCREF(Py_None);
11615         _resultobj = Py_None;
11616     }
11617     return _resultobj;
11618 }
11619
11620 #define wxGrid_SetDefaultEditor(_swigobj,_swigarg0)  (_swigobj->SetDefaultEditor(_swigarg0))
11621 static PyObject *_wrap_wxGrid_SetDefaultEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11622     PyObject * _resultobj;
11623     wxGrid * _arg0;
11624     wxGridCellEditor * _arg1;
11625     PyObject * _argo0 = 0;
11626     PyObject * _argo1 = 0;
11627     char *_kwnames[] = { "self","editor", NULL };
11628
11629     self = self;
11630     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetDefaultEditor",_kwnames,&_argo0,&_argo1))
11631         return NULL;
11632     if (_argo0) {
11633         if (_argo0 == Py_None) { _arg0 = NULL; }
11634         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11635             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetDefaultEditor. Expected _wxGrid_p.");
11636         return NULL;
11637         }
11638     }
11639     if (_argo1) {
11640         if (_argo1 == Py_None) { _arg1 = NULL; }
11641         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxGridCellEditor_p")) {
11642             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGrid_SetDefaultEditor. Expected _wxGridCellEditor_p.");
11643         return NULL;
11644         }
11645     }
11646 {
11647     wxPy_BEGIN_ALLOW_THREADS;
11648         wxGrid_SetDefaultEditor(_arg0,_arg1);
11649
11650     wxPy_END_ALLOW_THREADS;
11651     if (PyErr_Occurred()) return NULL;
11652 }    Py_INCREF(Py_None);
11653     _resultobj = Py_None;
11654     return _resultobj;
11655 }
11656
11657 #define wxGrid_SetCellEditor(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellEditor(_swigarg0,_swigarg1,_swigarg2))
11658 static PyObject *_wrap_wxGrid_SetCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11659     PyObject * _resultobj;
11660     wxGrid * _arg0;
11661     int  _arg1;
11662     int  _arg2;
11663     wxGridCellEditor * _arg3;
11664     PyObject * _argo0 = 0;
11665     PyObject * _argo3 = 0;
11666     char *_kwnames[] = { "self","row","col","editor", NULL };
11667
11668     self = self;
11669     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2,&_argo3))
11670         return NULL;
11671     if (_argo0) {
11672         if (_argo0 == Py_None) { _arg0 = NULL; }
11673         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11674             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellEditor. Expected _wxGrid_p.");
11675         return NULL;
11676         }
11677     }
11678     if (_argo3) {
11679         if (_argo3 == Py_None) { _arg3 = NULL; }
11680         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellEditor_p")) {
11681             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_SetCellEditor. Expected _wxGridCellEditor_p.");
11682         return NULL;
11683         }
11684     }
11685 {
11686     wxPy_BEGIN_ALLOW_THREADS;
11687         wxGrid_SetCellEditor(_arg0,_arg1,_arg2,_arg3);
11688
11689     wxPy_END_ALLOW_THREADS;
11690     if (PyErr_Occurred()) return NULL;
11691 }    Py_INCREF(Py_None);
11692     _resultobj = Py_None;
11693     return _resultobj;
11694 }
11695
11696 #define wxGrid_GetDefaultEditor(_swigobj)  (_swigobj->GetDefaultEditor())
11697 static PyObject *_wrap_wxGrid_GetDefaultEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11698     PyObject * _resultobj;
11699     wxGridCellEditor * _result;
11700     wxGrid * _arg0;
11701     PyObject * _argo0 = 0;
11702     char *_kwnames[] = { "self", NULL };
11703     char _ptemp[128];
11704
11705     self = self;
11706     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetDefaultEditor",_kwnames,&_argo0))
11707         return NULL;
11708     if (_argo0) {
11709         if (_argo0 == Py_None) { _arg0 = NULL; }
11710         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11711             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditor. Expected _wxGrid_p.");
11712         return NULL;
11713         }
11714     }
11715 {
11716     wxPy_BEGIN_ALLOW_THREADS;
11717         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditor(_arg0);
11718
11719     wxPy_END_ALLOW_THREADS;
11720     if (PyErr_Occurred()) return NULL;
11721 }    if (_result) {
11722         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
11723         _resultobj = Py_BuildValue("s",_ptemp);
11724     } else {
11725         Py_INCREF(Py_None);
11726         _resultobj = Py_None;
11727     }
11728     return _resultobj;
11729 }
11730
11731 #define wxGrid_GetCellEditor(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellEditor(_swigarg0,_swigarg1))
11732 static PyObject *_wrap_wxGrid_GetCellEditor(PyObject *self, PyObject *args, PyObject *kwargs) {
11733     PyObject * _resultobj;
11734     wxGridCellEditor * _result;
11735     wxGrid * _arg0;
11736     int  _arg1;
11737     int  _arg2;
11738     PyObject * _argo0 = 0;
11739     char *_kwnames[] = { "self","row","col", NULL };
11740     char _ptemp[128];
11741
11742     self = self;
11743     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellEditor",_kwnames,&_argo0,&_arg1,&_arg2))
11744         return NULL;
11745     if (_argo0) {
11746         if (_argo0 == Py_None) { _arg0 = NULL; }
11747         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11748             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellEditor. Expected _wxGrid_p.");
11749         return NULL;
11750         }
11751     }
11752 {
11753     wxPy_BEGIN_ALLOW_THREADS;
11754         _result = (wxGridCellEditor *)wxGrid_GetCellEditor(_arg0,_arg1,_arg2);
11755
11756     wxPy_END_ALLOW_THREADS;
11757     if (PyErr_Occurred()) return NULL;
11758 }    if (_result) {
11759         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
11760         _resultobj = Py_BuildValue("s",_ptemp);
11761     } else {
11762         Py_INCREF(Py_None);
11763         _resultobj = Py_None;
11764     }
11765     return _resultobj;
11766 }
11767
11768 #define wxGrid_GetCellValue(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetCellValue(_swigarg0,_swigarg1))
11769 static PyObject *_wrap_wxGrid_GetCellValue(PyObject *self, PyObject *args, PyObject *kwargs) {
11770     PyObject * _resultobj;
11771     wxString * _result;
11772     wxGrid * _arg0;
11773     int  _arg1;
11774     int  _arg2;
11775     PyObject * _argo0 = 0;
11776     char *_kwnames[] = { "self","row","col", NULL };
11777
11778     self = self;
11779     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetCellValue",_kwnames,&_argo0,&_arg1,&_arg2))
11780         return NULL;
11781     if (_argo0) {
11782         if (_argo0 == Py_None) { _arg0 = NULL; }
11783         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11784             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetCellValue. Expected _wxGrid_p.");
11785         return NULL;
11786         }
11787     }
11788 {
11789     wxPy_BEGIN_ALLOW_THREADS;
11790         _result = new wxString (wxGrid_GetCellValue(_arg0,_arg1,_arg2));
11791
11792     wxPy_END_ALLOW_THREADS;
11793     if (PyErr_Occurred()) return NULL;
11794 }{
11795     _resultobj = PyString_FromStringAndSize(_result->c_str(), _result->Len());
11796 }
11797 {
11798     delete _result;
11799 }
11800     return _resultobj;
11801 }
11802
11803 #define wxGrid_SetCellValue(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetCellValue(_swigarg0,_swigarg1,_swigarg2))
11804 static PyObject *_wrap_wxGrid_SetCellValue(PyObject *self, PyObject *args, PyObject *kwargs) {
11805     PyObject * _resultobj;
11806     wxGrid * _arg0;
11807     int  _arg1;
11808     int  _arg2;
11809     wxString * _arg3;
11810     PyObject * _argo0 = 0;
11811     PyObject * _obj3 = 0;
11812     char *_kwnames[] = { "self","row","col","s", NULL };
11813
11814     self = self;
11815     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OiiO:wxGrid_SetCellValue",_kwnames,&_argo0,&_arg1,&_arg2,&_obj3))
11816         return NULL;
11817     if (_argo0) {
11818         if (_argo0 == Py_None) { _arg0 = NULL; }
11819         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11820             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetCellValue. Expected _wxGrid_p.");
11821         return NULL;
11822         }
11823     }
11824 {
11825 #if PYTHON_API_VERSION >= 1009
11826     char* tmpPtr; int tmpSize;
11827     if (!PyString_Check(_obj3) && !PyUnicode_Check(_obj3)) {
11828         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
11829         return NULL;
11830     }
11831     if (PyString_AsStringAndSize(_obj3, &tmpPtr, &tmpSize) == -1)
11832         return NULL;
11833     _arg3 = new wxString(tmpPtr, tmpSize);
11834 #else
11835     if (!PyString_Check(_obj3)) {
11836         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
11837         return NULL;
11838     }
11839     _arg3 = new wxString(PyString_AS_STRING(_obj3), PyString_GET_SIZE(_obj3));
11840 #endif
11841 }
11842 {
11843     wxPy_BEGIN_ALLOW_THREADS;
11844         wxGrid_SetCellValue(_arg0,_arg1,_arg2,*_arg3);
11845
11846     wxPy_END_ALLOW_THREADS;
11847     if (PyErr_Occurred()) return NULL;
11848 }    Py_INCREF(Py_None);
11849     _resultobj = Py_None;
11850 {
11851     if (_obj3)
11852         delete _arg3;
11853 }
11854     return _resultobj;
11855 }
11856
11857 #define wxGrid_IsReadOnly(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsReadOnly(_swigarg0,_swigarg1))
11858 static PyObject *_wrap_wxGrid_IsReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
11859     PyObject * _resultobj;
11860     bool  _result;
11861     wxGrid * _arg0;
11862     int  _arg1;
11863     int  _arg2;
11864     PyObject * _argo0 = 0;
11865     char *_kwnames[] = { "self","row","col", NULL };
11866
11867     self = self;
11868     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_IsReadOnly",_kwnames,&_argo0,&_arg1,&_arg2))
11869         return NULL;
11870     if (_argo0) {
11871         if (_argo0 == Py_None) { _arg0 = NULL; }
11872         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11873             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsReadOnly. Expected _wxGrid_p.");
11874         return NULL;
11875         }
11876     }
11877 {
11878     wxPy_BEGIN_ALLOW_THREADS;
11879         _result = (bool )wxGrid_IsReadOnly(_arg0,_arg1,_arg2);
11880
11881     wxPy_END_ALLOW_THREADS;
11882     if (PyErr_Occurred()) return NULL;
11883 }    _resultobj = Py_BuildValue("i",_result);
11884     return _resultobj;
11885 }
11886
11887 #define wxGrid_SetReadOnly(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->SetReadOnly(_swigarg0,_swigarg1,_swigarg2))
11888 static PyObject *_wrap_wxGrid_SetReadOnly(PyObject *self, PyObject *args, PyObject *kwargs) {
11889     PyObject * _resultobj;
11890     wxGrid * _arg0;
11891     int  _arg1;
11892     int  _arg2;
11893     bool  _arg3 = (bool ) TRUE;
11894     PyObject * _argo0 = 0;
11895     int tempbool3 = (int) TRUE;
11896     char *_kwnames[] = { "self","row","col","isReadOnly", NULL };
11897
11898     self = self;
11899     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii|i:wxGrid_SetReadOnly",_kwnames,&_argo0,&_arg1,&_arg2,&tempbool3))
11900         return NULL;
11901     if (_argo0) {
11902         if (_argo0 == Py_None) { _arg0 = NULL; }
11903         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11904             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetReadOnly. Expected _wxGrid_p.");
11905         return NULL;
11906         }
11907     }
11908     _arg3 = (bool ) tempbool3;
11909 {
11910     wxPy_BEGIN_ALLOW_THREADS;
11911         wxGrid_SetReadOnly(_arg0,_arg1,_arg2,_arg3);
11912
11913     wxPy_END_ALLOW_THREADS;
11914     if (PyErr_Occurred()) return NULL;
11915 }    Py_INCREF(Py_None);
11916     _resultobj = Py_None;
11917     return _resultobj;
11918 }
11919
11920 #define wxGrid_SelectRow(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SelectRow(_swigarg0,_swigarg1))
11921 static PyObject *_wrap_wxGrid_SelectRow(PyObject *self, PyObject *args, PyObject *kwargs) {
11922     PyObject * _resultobj;
11923     wxGrid * _arg0;
11924     int  _arg1;
11925     bool  _arg2 = (bool ) FALSE;
11926     PyObject * _argo0 = 0;
11927     int tempbool2 = (int) FALSE;
11928     char *_kwnames[] = { "self","row","addToSelected", NULL };
11929
11930     self = self;
11931     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SelectRow",_kwnames,&_argo0,&_arg1,&tempbool2))
11932         return NULL;
11933     if (_argo0) {
11934         if (_argo0 == Py_None) { _arg0 = NULL; }
11935         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11936             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectRow. Expected _wxGrid_p.");
11937         return NULL;
11938         }
11939     }
11940     _arg2 = (bool ) tempbool2;
11941 {
11942     wxPy_BEGIN_ALLOW_THREADS;
11943         wxGrid_SelectRow(_arg0,_arg1,_arg2);
11944
11945     wxPy_END_ALLOW_THREADS;
11946     if (PyErr_Occurred()) return NULL;
11947 }    Py_INCREF(Py_None);
11948     _resultobj = Py_None;
11949     return _resultobj;
11950 }
11951
11952 #define wxGrid_SelectCol(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SelectCol(_swigarg0,_swigarg1))
11953 static PyObject *_wrap_wxGrid_SelectCol(PyObject *self, PyObject *args, PyObject *kwargs) {
11954     PyObject * _resultobj;
11955     wxGrid * _arg0;
11956     int  _arg1;
11957     bool  _arg2 = (bool ) FALSE;
11958     PyObject * _argo0 = 0;
11959     int tempbool2 = (int) FALSE;
11960     char *_kwnames[] = { "self","col","addToSelected", NULL };
11961
11962     self = self;
11963     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|i:wxGrid_SelectCol",_kwnames,&_argo0,&_arg1,&tempbool2))
11964         return NULL;
11965     if (_argo0) {
11966         if (_argo0 == Py_None) { _arg0 = NULL; }
11967         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
11968             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectCol. Expected _wxGrid_p.");
11969         return NULL;
11970         }
11971     }
11972     _arg2 = (bool ) tempbool2;
11973 {
11974     wxPy_BEGIN_ALLOW_THREADS;
11975         wxGrid_SelectCol(_arg0,_arg1,_arg2);
11976
11977     wxPy_END_ALLOW_THREADS;
11978     if (PyErr_Occurred()) return NULL;
11979 }    Py_INCREF(Py_None);
11980     _resultobj = Py_None;
11981     return _resultobj;
11982 }
11983
11984 #define wxGrid_SelectBlock(_swigobj,_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4)  (_swigobj->SelectBlock(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
11985 static PyObject *_wrap_wxGrid_SelectBlock(PyObject *self, PyObject *args, PyObject *kwargs) {
11986     PyObject * _resultobj;
11987     wxGrid * _arg0;
11988     int  _arg1;
11989     int  _arg2;
11990     int  _arg3;
11991     int  _arg4;
11992     bool  _arg5 = (bool ) FALSE;
11993     PyObject * _argo0 = 0;
11994     int tempbool5 = (int) FALSE;
11995     char *_kwnames[] = { "self","topRow","leftCol","bottomRow","rightCol","addToSelected", NULL };
11996
11997     self = self;
11998     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oiiii|i:wxGrid_SelectBlock",_kwnames,&_argo0,&_arg1,&_arg2,&_arg3,&_arg4,&tempbool5))
11999         return NULL;
12000     if (_argo0) {
12001         if (_argo0 == Py_None) { _arg0 = NULL; }
12002         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12003             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectBlock. Expected _wxGrid_p.");
12004         return NULL;
12005         }
12006     }
12007     _arg5 = (bool ) tempbool5;
12008 {
12009     wxPy_BEGIN_ALLOW_THREADS;
12010         wxGrid_SelectBlock(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
12011
12012     wxPy_END_ALLOW_THREADS;
12013     if (PyErr_Occurred()) return NULL;
12014 }    Py_INCREF(Py_None);
12015     _resultobj = Py_None;
12016     return _resultobj;
12017 }
12018
12019 #define wxGrid_SelectAll(_swigobj)  (_swigobj->SelectAll())
12020 static PyObject *_wrap_wxGrid_SelectAll(PyObject *self, PyObject *args, PyObject *kwargs) {
12021     PyObject * _resultobj;
12022     wxGrid * _arg0;
12023     PyObject * _argo0 = 0;
12024     char *_kwnames[] = { "self", NULL };
12025
12026     self = self;
12027     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_SelectAll",_kwnames,&_argo0))
12028         return NULL;
12029     if (_argo0) {
12030         if (_argo0 == Py_None) { _arg0 = NULL; }
12031         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12032             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SelectAll. Expected _wxGrid_p.");
12033         return NULL;
12034         }
12035     }
12036 {
12037     wxPy_BEGIN_ALLOW_THREADS;
12038         wxGrid_SelectAll(_arg0);
12039
12040     wxPy_END_ALLOW_THREADS;
12041     if (PyErr_Occurred()) return NULL;
12042 }    Py_INCREF(Py_None);
12043     _resultobj = Py_None;
12044     return _resultobj;
12045 }
12046
12047 #define wxGrid_IsSelection(_swigobj)  (_swigobj->IsSelection())
12048 static PyObject *_wrap_wxGrid_IsSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12049     PyObject * _resultobj;
12050     bool  _result;
12051     wxGrid * _arg0;
12052     PyObject * _argo0 = 0;
12053     char *_kwnames[] = { "self", NULL };
12054
12055     self = self;
12056     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_IsSelection",_kwnames,&_argo0))
12057         return NULL;
12058     if (_argo0) {
12059         if (_argo0 == Py_None) { _arg0 = NULL; }
12060         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12061             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsSelection. Expected _wxGrid_p.");
12062         return NULL;
12063         }
12064     }
12065 {
12066     wxPy_BEGIN_ALLOW_THREADS;
12067         _result = (bool )wxGrid_IsSelection(_arg0);
12068
12069     wxPy_END_ALLOW_THREADS;
12070     if (PyErr_Occurred()) return NULL;
12071 }    _resultobj = Py_BuildValue("i",_result);
12072     return _resultobj;
12073 }
12074
12075 #define wxGrid_ClearSelection(_swigobj)  (_swigobj->ClearSelection())
12076 static PyObject *_wrap_wxGrid_ClearSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12077     PyObject * _resultobj;
12078     wxGrid * _arg0;
12079     PyObject * _argo0 = 0;
12080     char *_kwnames[] = { "self", NULL };
12081
12082     self = self;
12083     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_ClearSelection",_kwnames,&_argo0))
12084         return NULL;
12085     if (_argo0) {
12086         if (_argo0 == Py_None) { _arg0 = NULL; }
12087         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12088             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_ClearSelection. Expected _wxGrid_p.");
12089         return NULL;
12090         }
12091     }
12092 {
12093     wxPy_BEGIN_ALLOW_THREADS;
12094         wxGrid_ClearSelection(_arg0);
12095
12096     wxPy_END_ALLOW_THREADS;
12097     if (PyErr_Occurred()) return NULL;
12098 }    Py_INCREF(Py_None);
12099     _resultobj = Py_None;
12100     return _resultobj;
12101 }
12102
12103 #define wxGrid_IsInSelection(_swigobj,_swigarg0,_swigarg1)  (_swigobj->IsInSelection(_swigarg0,_swigarg1))
12104 static PyObject *_wrap_wxGrid_IsInSelection(PyObject *self, PyObject *args, PyObject *kwargs) {
12105     PyObject * _resultobj;
12106     bool  _result;
12107     wxGrid * _arg0;
12108     int  _arg1;
12109     int  _arg2;
12110     PyObject * _argo0 = 0;
12111     char *_kwnames[] = { "self","row","col", NULL };
12112
12113     self = self;
12114     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_IsInSelection",_kwnames,&_argo0,&_arg1,&_arg2))
12115         return NULL;
12116     if (_argo0) {
12117         if (_argo0 == Py_None) { _arg0 = NULL; }
12118         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12119             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_IsInSelection. Expected _wxGrid_p.");
12120         return NULL;
12121         }
12122     }
12123 {
12124     wxPy_BEGIN_ALLOW_THREADS;
12125         _result = (bool )wxGrid_IsInSelection(_arg0,_arg1,_arg2);
12126
12127     wxPy_END_ALLOW_THREADS;
12128     if (PyErr_Occurred()) return NULL;
12129 }    _resultobj = Py_BuildValue("i",_result);
12130     return _resultobj;
12131 }
12132
12133 #define wxGrid_BlockToDeviceRect(_swigobj,_swigarg0,_swigarg1)  (_swigobj->BlockToDeviceRect(_swigarg0,_swigarg1))
12134 static PyObject *_wrap_wxGrid_BlockToDeviceRect(PyObject *self, PyObject *args, PyObject *kwargs) {
12135     PyObject * _resultobj;
12136     wxRect * _result;
12137     wxGrid * _arg0;
12138     wxGridCellCoords * _arg1;
12139     wxGridCellCoords * _arg2;
12140     PyObject * _argo0 = 0;
12141     wxGridCellCoords  temp;
12142     PyObject * _obj1 = 0;
12143     wxGridCellCoords  temp0;
12144     PyObject * _obj2 = 0;
12145     char *_kwnames[] = { "self","topLeft","bottomRight", NULL };
12146     char _ptemp[128];
12147
12148     self = self;
12149     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxGrid_BlockToDeviceRect",_kwnames,&_argo0,&_obj1,&_obj2))
12150         return NULL;
12151     if (_argo0) {
12152         if (_argo0 == Py_None) { _arg0 = NULL; }
12153         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12154             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_BlockToDeviceRect. Expected _wxGrid_p.");
12155         return NULL;
12156         }
12157     }
12158 {
12159     _arg1 = &temp;
12160     if (! wxGridCellCoords_helper(_obj1, &_arg1))
12161         return NULL;
12162 }
12163 {
12164     _arg2 = &temp0;
12165     if (! wxGridCellCoords_helper(_obj2, &_arg2))
12166         return NULL;
12167 }
12168 {
12169     wxPy_BEGIN_ALLOW_THREADS;
12170         _result = new wxRect (wxGrid_BlockToDeviceRect(_arg0,*_arg1,*_arg2));
12171
12172     wxPy_END_ALLOW_THREADS;
12173     if (PyErr_Occurred()) return NULL;
12174 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxRect_p");
12175     _resultobj = Py_BuildValue("s",_ptemp);
12176     return _resultobj;
12177 }
12178
12179 #define wxGrid_GetSelectionBackground(_swigobj)  (_swigobj->GetSelectionBackground())
12180 static PyObject *_wrap_wxGrid_GetSelectionBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
12181     PyObject * _resultobj;
12182     wxColour * _result;
12183     wxGrid * _arg0;
12184     PyObject * _argo0 = 0;
12185     char *_kwnames[] = { "self", NULL };
12186     char _ptemp[128];
12187
12188     self = self;
12189     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetSelectionBackground",_kwnames,&_argo0))
12190         return NULL;
12191     if (_argo0) {
12192         if (_argo0 == Py_None) { _arg0 = NULL; }
12193         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12194             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetSelectionBackground. Expected _wxGrid_p.");
12195         return NULL;
12196         }
12197     }
12198 {
12199     wxPy_BEGIN_ALLOW_THREADS;
12200         _result = new wxColour (wxGrid_GetSelectionBackground(_arg0));
12201
12202     wxPy_END_ALLOW_THREADS;
12203     if (PyErr_Occurred()) return NULL;
12204 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
12205     _resultobj = Py_BuildValue("s",_ptemp);
12206     return _resultobj;
12207 }
12208
12209 #define wxGrid_GetSelectionForeground(_swigobj)  (_swigobj->GetSelectionForeground())
12210 static PyObject *_wrap_wxGrid_GetSelectionForeground(PyObject *self, PyObject *args, PyObject *kwargs) {
12211     PyObject * _resultobj;
12212     wxColour * _result;
12213     wxGrid * _arg0;
12214     PyObject * _argo0 = 0;
12215     char *_kwnames[] = { "self", NULL };
12216     char _ptemp[128];
12217
12218     self = self;
12219     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetSelectionForeground",_kwnames,&_argo0))
12220         return NULL;
12221     if (_argo0) {
12222         if (_argo0 == Py_None) { _arg0 = NULL; }
12223         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12224             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetSelectionForeground. Expected _wxGrid_p.");
12225         return NULL;
12226         }
12227     }
12228 {
12229     wxPy_BEGIN_ALLOW_THREADS;
12230         _result = new wxColour (wxGrid_GetSelectionForeground(_arg0));
12231
12232     wxPy_END_ALLOW_THREADS;
12233     if (PyErr_Occurred()) return NULL;
12234 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxColour_p");
12235     _resultobj = Py_BuildValue("s",_ptemp);
12236     return _resultobj;
12237 }
12238
12239 #define wxGrid_SetSelectionBackground(_swigobj,_swigarg0)  (_swigobj->SetSelectionBackground(_swigarg0))
12240 static PyObject *_wrap_wxGrid_SetSelectionBackground(PyObject *self, PyObject *args, PyObject *kwargs) {
12241     PyObject * _resultobj;
12242     wxGrid * _arg0;
12243     wxColour * _arg1;
12244     PyObject * _argo0 = 0;
12245     wxColour  temp;
12246     PyObject * _obj1 = 0;
12247     char *_kwnames[] = { "self","c", NULL };
12248
12249     self = self;
12250     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetSelectionBackground",_kwnames,&_argo0,&_obj1))
12251         return NULL;
12252     if (_argo0) {
12253         if (_argo0 == Py_None) { _arg0 = NULL; }
12254         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12255             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionBackground. Expected _wxGrid_p.");
12256         return NULL;
12257         }
12258     }
12259 {
12260     _arg1 = &temp;
12261     if (! wxColour_helper(_obj1, &_arg1))
12262         return NULL;
12263 }
12264 {
12265     wxPy_BEGIN_ALLOW_THREADS;
12266         wxGrid_SetSelectionBackground(_arg0,*_arg1);
12267
12268     wxPy_END_ALLOW_THREADS;
12269     if (PyErr_Occurred()) return NULL;
12270 }    Py_INCREF(Py_None);
12271     _resultobj = Py_None;
12272     return _resultobj;
12273 }
12274
12275 #define wxGrid_SetSelectionForeground(_swigobj,_swigarg0)  (_swigobj->SetSelectionForeground(_swigarg0))
12276 static PyObject *_wrap_wxGrid_SetSelectionForeground(PyObject *self, PyObject *args, PyObject *kwargs) {
12277     PyObject * _resultobj;
12278     wxGrid * _arg0;
12279     wxColour * _arg1;
12280     PyObject * _argo0 = 0;
12281     wxColour  temp;
12282     PyObject * _obj1 = 0;
12283     char *_kwnames[] = { "self","c", NULL };
12284
12285     self = self;
12286     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_SetSelectionForeground",_kwnames,&_argo0,&_obj1))
12287         return NULL;
12288     if (_argo0) {
12289         if (_argo0 == Py_None) { _arg0 = NULL; }
12290         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12291             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetSelectionForeground. Expected _wxGrid_p.");
12292         return NULL;
12293         }
12294     }
12295 {
12296     _arg1 = &temp;
12297     if (! wxColour_helper(_obj1, &_arg1))
12298         return NULL;
12299 }
12300 {
12301     wxPy_BEGIN_ALLOW_THREADS;
12302         wxGrid_SetSelectionForeground(_arg0,*_arg1);
12303
12304     wxPy_END_ALLOW_THREADS;
12305     if (PyErr_Occurred()) return NULL;
12306 }    Py_INCREF(Py_None);
12307     _resultobj = Py_None;
12308     return _resultobj;
12309 }
12310
12311 #define wxGrid_RegisterDataType(_swigobj,_swigarg0,_swigarg1,_swigarg2)  (_swigobj->RegisterDataType(_swigarg0,_swigarg1,_swigarg2))
12312 static PyObject *_wrap_wxGrid_RegisterDataType(PyObject *self, PyObject *args, PyObject *kwargs) {
12313     PyObject * _resultobj;
12314     wxGrid * _arg0;
12315     wxString * _arg1;
12316     wxGridCellRenderer * _arg2;
12317     wxGridCellEditor * _arg3;
12318     PyObject * _argo0 = 0;
12319     PyObject * _obj1 = 0;
12320     PyObject * _argo2 = 0;
12321     PyObject * _argo3 = 0;
12322     char *_kwnames[] = { "self","typeName","renderer","editor", NULL };
12323
12324     self = self;
12325     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOOO:wxGrid_RegisterDataType",_kwnames,&_argo0,&_obj1,&_argo2,&_argo3))
12326         return NULL;
12327     if (_argo0) {
12328         if (_argo0 == Py_None) { _arg0 = NULL; }
12329         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12330             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_RegisterDataType. Expected _wxGrid_p.");
12331         return NULL;
12332         }
12333     }
12334 {
12335 #if PYTHON_API_VERSION >= 1009
12336     char* tmpPtr; int tmpSize;
12337     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12338         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12339         return NULL;
12340     }
12341     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12342         return NULL;
12343     _arg1 = new wxString(tmpPtr, tmpSize);
12344 #else
12345     if (!PyString_Check(_obj1)) {
12346         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12347         return NULL;
12348     }
12349     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12350 #endif
12351 }
12352     if (_argo2) {
12353         if (_argo2 == Py_None) { _arg2 = NULL; }
12354         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGridCellRenderer_p")) {
12355             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of wxGrid_RegisterDataType. Expected _wxGridCellRenderer_p.");
12356         return NULL;
12357         }
12358     }
12359     if (_argo3) {
12360         if (_argo3 == Py_None) { _arg3 = NULL; }
12361         else if (SWIG_GetPtrObj(_argo3,(void **) &_arg3,"_wxGridCellEditor_p")) {
12362             PyErr_SetString(PyExc_TypeError,"Type error in argument 4 of wxGrid_RegisterDataType. Expected _wxGridCellEditor_p.");
12363         return NULL;
12364         }
12365     }
12366 {
12367     wxPy_BEGIN_ALLOW_THREADS;
12368         wxGrid_RegisterDataType(_arg0,*_arg1,_arg2,_arg3);
12369
12370     wxPy_END_ALLOW_THREADS;
12371     if (PyErr_Occurred()) return NULL;
12372 }    Py_INCREF(Py_None);
12373     _resultobj = Py_None;
12374 {
12375     if (_obj1)
12376         delete _arg1;
12377 }
12378     return _resultobj;
12379 }
12380
12381 #define wxGrid_GetDefaultEditorForCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultEditorForCell(_swigarg0,_swigarg1))
12382 static PyObject *_wrap_wxGrid_GetDefaultEditorForCell(PyObject *self, PyObject *args, PyObject *kwargs) {
12383     PyObject * _resultobj;
12384     wxGridCellEditor * _result;
12385     wxGrid * _arg0;
12386     int  _arg1;
12387     int  _arg2;
12388     PyObject * _argo0 = 0;
12389     char *_kwnames[] = { "self","row","col", NULL };
12390     char _ptemp[128];
12391
12392     self = self;
12393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultEditorForCell",_kwnames,&_argo0,&_arg1,&_arg2))
12394         return NULL;
12395     if (_argo0) {
12396         if (_argo0 == Py_None) { _arg0 = NULL; }
12397         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12398             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditorForCell. Expected _wxGrid_p.");
12399         return NULL;
12400         }
12401     }
12402 {
12403     wxPy_BEGIN_ALLOW_THREADS;
12404         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForCell(_arg0,_arg1,_arg2);
12405
12406     wxPy_END_ALLOW_THREADS;
12407     if (PyErr_Occurred()) return NULL;
12408 }    if (_result) {
12409         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
12410         _resultobj = Py_BuildValue("s",_ptemp);
12411     } else {
12412         Py_INCREF(Py_None);
12413         _resultobj = Py_None;
12414     }
12415     return _resultobj;
12416 }
12417
12418 #define wxGrid_GetDefaultRendererForCell(_swigobj,_swigarg0,_swigarg1)  (_swigobj->GetDefaultRendererForCell(_swigarg0,_swigarg1))
12419 static PyObject *_wrap_wxGrid_GetDefaultRendererForCell(PyObject *self, PyObject *args, PyObject *kwargs) {
12420     PyObject * _resultobj;
12421     wxGridCellRenderer * _result;
12422     wxGrid * _arg0;
12423     int  _arg1;
12424     int  _arg2;
12425     PyObject * _argo0 = 0;
12426     char *_kwnames[] = { "self","row","col", NULL };
12427     char _ptemp[128];
12428
12429     self = self;
12430     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_GetDefaultRendererForCell",_kwnames,&_argo0,&_arg1,&_arg2))
12431         return NULL;
12432     if (_argo0) {
12433         if (_argo0 == Py_None) { _arg0 = NULL; }
12434         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12435             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRendererForCell. Expected _wxGrid_p.");
12436         return NULL;
12437         }
12438     }
12439 {
12440     wxPy_BEGIN_ALLOW_THREADS;
12441         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForCell(_arg0,_arg1,_arg2);
12442
12443     wxPy_END_ALLOW_THREADS;
12444     if (PyErr_Occurred()) return NULL;
12445 }    if (_result) {
12446         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
12447         _resultobj = Py_BuildValue("s",_ptemp);
12448     } else {
12449         Py_INCREF(Py_None);
12450         _resultobj = Py_None;
12451     }
12452     return _resultobj;
12453 }
12454
12455 #define wxGrid_GetDefaultEditorForType(_swigobj,_swigarg0)  (_swigobj->GetDefaultEditorForType(_swigarg0))
12456 static PyObject *_wrap_wxGrid_GetDefaultEditorForType(PyObject *self, PyObject *args, PyObject *kwargs) {
12457     PyObject * _resultobj;
12458     wxGridCellEditor * _result;
12459     wxGrid * _arg0;
12460     wxString * _arg1;
12461     PyObject * _argo0 = 0;
12462     PyObject * _obj1 = 0;
12463     char *_kwnames[] = { "self","typeName", NULL };
12464     char _ptemp[128];
12465
12466     self = self;
12467     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultEditorForType",_kwnames,&_argo0,&_obj1))
12468         return NULL;
12469     if (_argo0) {
12470         if (_argo0 == Py_None) { _arg0 = NULL; }
12471         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12472             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultEditorForType. Expected _wxGrid_p.");
12473         return NULL;
12474         }
12475     }
12476 {
12477 #if PYTHON_API_VERSION >= 1009
12478     char* tmpPtr; int tmpSize;
12479     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12480         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12481         return NULL;
12482     }
12483     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12484         return NULL;
12485     _arg1 = new wxString(tmpPtr, tmpSize);
12486 #else
12487     if (!PyString_Check(_obj1)) {
12488         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12489         return NULL;
12490     }
12491     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12492 #endif
12493 }
12494 {
12495     wxPy_BEGIN_ALLOW_THREADS;
12496         _result = (wxGridCellEditor *)wxGrid_GetDefaultEditorForType(_arg0,*_arg1);
12497
12498     wxPy_END_ALLOW_THREADS;
12499     if (PyErr_Occurred()) return NULL;
12500 }    if (_result) {
12501         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellEditor_p");
12502         _resultobj = Py_BuildValue("s",_ptemp);
12503     } else {
12504         Py_INCREF(Py_None);
12505         _resultobj = Py_None;
12506     }
12507 {
12508     if (_obj1)
12509         delete _arg1;
12510 }
12511     return _resultobj;
12512 }
12513
12514 #define wxGrid_GetDefaultRendererForType(_swigobj,_swigarg0)  (_swigobj->GetDefaultRendererForType(_swigarg0))
12515 static PyObject *_wrap_wxGrid_GetDefaultRendererForType(PyObject *self, PyObject *args, PyObject *kwargs) {
12516     PyObject * _resultobj;
12517     wxGridCellRenderer * _result;
12518     wxGrid * _arg0;
12519     wxString * _arg1;
12520     PyObject * _argo0 = 0;
12521     PyObject * _obj1 = 0;
12522     char *_kwnames[] = { "self","typeName", NULL };
12523     char _ptemp[128];
12524
12525     self = self;
12526     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGrid_GetDefaultRendererForType",_kwnames,&_argo0,&_obj1))
12527         return NULL;
12528     if (_argo0) {
12529         if (_argo0 == Py_None) { _arg0 = NULL; }
12530         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12531             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetDefaultRendererForType. Expected _wxGrid_p.");
12532         return NULL;
12533         }
12534     }
12535 {
12536 #if PYTHON_API_VERSION >= 1009
12537     char* tmpPtr; int tmpSize;
12538     if (!PyString_Check(_obj1) && !PyUnicode_Check(_obj1)) {
12539         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12540         return NULL;
12541     }
12542     if (PyString_AsStringAndSize(_obj1, &tmpPtr, &tmpSize) == -1)
12543         return NULL;
12544     _arg1 = new wxString(tmpPtr, tmpSize);
12545 #else
12546     if (!PyString_Check(_obj1)) {
12547         PyErr_SetString(PyExc_TypeError, wxStringErrorMsg);
12548         return NULL;
12549     }
12550     _arg1 = new wxString(PyString_AS_STRING(_obj1), PyString_GET_SIZE(_obj1));
12551 #endif
12552 }
12553 {
12554     wxPy_BEGIN_ALLOW_THREADS;
12555         _result = (wxGridCellRenderer *)wxGrid_GetDefaultRendererForType(_arg0,*_arg1);
12556
12557     wxPy_END_ALLOW_THREADS;
12558     if (PyErr_Occurred()) return NULL;
12559 }    if (_result) {
12560         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridCellRenderer_p");
12561         _resultobj = Py_BuildValue("s",_ptemp);
12562     } else {
12563         Py_INCREF(Py_None);
12564         _resultobj = Py_None;
12565     }
12566 {
12567     if (_obj1)
12568         delete _arg1;
12569 }
12570     return _resultobj;
12571 }
12572
12573 #define wxGrid_SetMargins(_swigobj,_swigarg0,_swigarg1)  (_swigobj->SetMargins(_swigarg0,_swigarg1))
12574 static PyObject *_wrap_wxGrid_SetMargins(PyObject *self, PyObject *args, PyObject *kwargs) {
12575     PyObject * _resultobj;
12576     wxGrid * _arg0;
12577     int  _arg1;
12578     int  _arg2;
12579     PyObject * _argo0 = 0;
12580     char *_kwnames[] = { "self","extraWidth","extraHeight", NULL };
12581
12582     self = self;
12583     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxGrid_SetMargins",_kwnames,&_argo0,&_arg1,&_arg2))
12584         return NULL;
12585     if (_argo0) {
12586         if (_argo0 == Py_None) { _arg0 = NULL; }
12587         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12588             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_SetMargins. Expected _wxGrid_p.");
12589         return NULL;
12590         }
12591     }
12592 {
12593     wxPy_BEGIN_ALLOW_THREADS;
12594         wxGrid_SetMargins(_arg0,_arg1,_arg2);
12595
12596     wxPy_END_ALLOW_THREADS;
12597     if (PyErr_Occurred()) return NULL;
12598 }    Py_INCREF(Py_None);
12599     _resultobj = Py_None;
12600     return _resultobj;
12601 }
12602
12603 #define wxGrid_GetGridWindow(_swigobj)  (_swigobj->GetGridWindow())
12604 static PyObject *_wrap_wxGrid_GetGridWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12605     PyObject * _resultobj;
12606     wxWindow * _result;
12607     wxGrid * _arg0;
12608     PyObject * _argo0 = 0;
12609     char *_kwnames[] = { "self", NULL };
12610
12611     self = self;
12612     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridWindow",_kwnames,&_argo0))
12613         return NULL;
12614     if (_argo0) {
12615         if (_argo0 == Py_None) { _arg0 = NULL; }
12616         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12617             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridWindow. Expected _wxGrid_p.");
12618         return NULL;
12619         }
12620     }
12621 {
12622     wxPy_BEGIN_ALLOW_THREADS;
12623         _result = (wxWindow *)wxGrid_GetGridWindow(_arg0);
12624
12625     wxPy_END_ALLOW_THREADS;
12626     if (PyErr_Occurred()) return NULL;
12627 }{ _resultobj = wxPyMake_wxObject(_result); }
12628     return _resultobj;
12629 }
12630
12631 #define wxGrid_GetGridRowLabelWindow(_swigobj)  (_swigobj->GetGridRowLabelWindow())
12632 static PyObject *_wrap_wxGrid_GetGridRowLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12633     PyObject * _resultobj;
12634     wxWindow * _result;
12635     wxGrid * _arg0;
12636     PyObject * _argo0 = 0;
12637     char *_kwnames[] = { "self", NULL };
12638
12639     self = self;
12640     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridRowLabelWindow",_kwnames,&_argo0))
12641         return NULL;
12642     if (_argo0) {
12643         if (_argo0 == Py_None) { _arg0 = NULL; }
12644         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12645             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridRowLabelWindow. Expected _wxGrid_p.");
12646         return NULL;
12647         }
12648     }
12649 {
12650     wxPy_BEGIN_ALLOW_THREADS;
12651         _result = (wxWindow *)wxGrid_GetGridRowLabelWindow(_arg0);
12652
12653     wxPy_END_ALLOW_THREADS;
12654     if (PyErr_Occurred()) return NULL;
12655 }{ _resultobj = wxPyMake_wxObject(_result); }
12656     return _resultobj;
12657 }
12658
12659 #define wxGrid_GetGridColLabelWindow(_swigobj)  (_swigobj->GetGridColLabelWindow())
12660 static PyObject *_wrap_wxGrid_GetGridColLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12661     PyObject * _resultobj;
12662     wxWindow * _result;
12663     wxGrid * _arg0;
12664     PyObject * _argo0 = 0;
12665     char *_kwnames[] = { "self", NULL };
12666
12667     self = self;
12668     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridColLabelWindow",_kwnames,&_argo0))
12669         return NULL;
12670     if (_argo0) {
12671         if (_argo0 == Py_None) { _arg0 = NULL; }
12672         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12673             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridColLabelWindow. Expected _wxGrid_p.");
12674         return NULL;
12675         }
12676     }
12677 {
12678     wxPy_BEGIN_ALLOW_THREADS;
12679         _result = (wxWindow *)wxGrid_GetGridColLabelWindow(_arg0);
12680
12681     wxPy_END_ALLOW_THREADS;
12682     if (PyErr_Occurred()) return NULL;
12683 }{ _resultobj = wxPyMake_wxObject(_result); }
12684     return _resultobj;
12685 }
12686
12687 #define wxGrid_GetGridCornerLabelWindow(_swigobj)  (_swigobj->GetGridCornerLabelWindow())
12688 static PyObject *_wrap_wxGrid_GetGridCornerLabelWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
12689     PyObject * _resultobj;
12690     wxWindow * _result;
12691     wxGrid * _arg0;
12692     PyObject * _argo0 = 0;
12693     char *_kwnames[] = { "self", NULL };
12694
12695     self = self;
12696     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGrid_GetGridCornerLabelWindow",_kwnames,&_argo0))
12697         return NULL;
12698     if (_argo0) {
12699         if (_argo0 == Py_None) { _arg0 = NULL; }
12700         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGrid_p")) {
12701             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGrid_GetGridCornerLabelWindow. Expected _wxGrid_p.");
12702         return NULL;
12703         }
12704     }
12705 {
12706     wxPy_BEGIN_ALLOW_THREADS;
12707         _result = (wxWindow *)wxGrid_GetGridCornerLabelWindow(_arg0);
12708
12709     wxPy_END_ALLOW_THREADS;
12710     if (PyErr_Occurred()) return NULL;
12711 }{ _resultobj = wxPyMake_wxObject(_result); }
12712     return _resultobj;
12713 }
12714
12715 static void *SwigwxGridEventTowxNotifyEvent(void *ptr) {
12716     wxGridEvent *src;
12717     wxNotifyEvent *dest;
12718     src = (wxGridEvent *) ptr;
12719     dest = (wxNotifyEvent *) src;
12720     return (void *) dest;
12721 }
12722
12723 static void *SwigwxGridEventTowxCommandEvent(void *ptr) {
12724     wxGridEvent *src;
12725     wxCommandEvent *dest;
12726     src = (wxGridEvent *) ptr;
12727     dest = (wxCommandEvent *) src;
12728     return (void *) dest;
12729 }
12730
12731 static void *SwigwxGridEventTowxEvent(void *ptr) {
12732     wxGridEvent *src;
12733     wxEvent *dest;
12734     src = (wxGridEvent *) ptr;
12735     dest = (wxEvent *) src;
12736     return (void *) dest;
12737 }
12738
12739 static void *SwigwxGridEventTowxObject(void *ptr) {
12740     wxGridEvent *src;
12741     wxObject *dest;
12742     src = (wxGridEvent *) ptr;
12743     dest = (wxObject *) src;
12744     return (void *) dest;
12745 }
12746
12747 #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))
12748 static PyObject *_wrap_new_wxGridEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
12749     PyObject * _resultobj;
12750     wxGridEvent * _result;
12751     int  _arg0;
12752     wxEventType  _arg1;
12753     wxGrid * _arg2;
12754     int  _arg3 = (int ) -1;
12755     int  _arg4 = (int ) -1;
12756     int  _arg5 = (int ) -1;
12757     int  _arg6 = (int ) -1;
12758     bool  _arg7 = (bool ) TRUE;
12759     bool  _arg8 = (bool ) FALSE;
12760     bool  _arg9 = (bool ) FALSE;
12761     bool  _arg10 = (bool ) FALSE;
12762     bool  _arg11 = (bool ) FALSE;
12763     PyObject * _argo2 = 0;
12764     int tempbool7 = (int) TRUE;
12765     int tempbool8 = (int) FALSE;
12766     int tempbool9 = (int) FALSE;
12767     int tempbool10 = (int) FALSE;
12768     int tempbool11 = (int) FALSE;
12769     char *_kwnames[] = { "id","type","obj","row","col","x","y","sel","control","shift","alt","meta", NULL };
12770     char _ptemp[128];
12771
12772     self = self;
12773     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO|iiiiiiiii:new_wxGridEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_arg5,&_arg6,&tempbool7,&tempbool8,&tempbool9,&tempbool10,&tempbool11))
12774         return NULL;
12775     if (_argo2) {
12776         if (_argo2 == Py_None) { _arg2 = NULL; }
12777         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
12778             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridEvent. Expected _wxGrid_p.");
12779         return NULL;
12780         }
12781     }
12782     _arg7 = (bool ) tempbool7;
12783     _arg8 = (bool ) tempbool8;
12784     _arg9 = (bool ) tempbool9;
12785     _arg10 = (bool ) tempbool10;
12786     _arg11 = (bool ) tempbool11;
12787 {
12788     wxPy_BEGIN_ALLOW_THREADS;
12789         _result = (wxGridEvent *)new_wxGridEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9,_arg10,_arg11);
12790
12791     wxPy_END_ALLOW_THREADS;
12792     if (PyErr_Occurred()) return NULL;
12793 }    if (_result) {
12794         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEvent_p");
12795         _resultobj = Py_BuildValue("s",_ptemp);
12796     } else {
12797         Py_INCREF(Py_None);
12798         _resultobj = Py_None;
12799     }
12800     return _resultobj;
12801 }
12802
12803 #define wxGridEvent_GetRow(_swigobj)  (_swigobj->GetRow())
12804 static PyObject *_wrap_wxGridEvent_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
12805     PyObject * _resultobj;
12806     int  _result;
12807     wxGridEvent * _arg0;
12808     PyObject * _argo0 = 0;
12809     char *_kwnames[] = { "self", NULL };
12810
12811     self = self;
12812     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetRow",_kwnames,&_argo0))
12813         return NULL;
12814     if (_argo0) {
12815         if (_argo0 == Py_None) { _arg0 = NULL; }
12816         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12817             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetRow. Expected _wxGridEvent_p.");
12818         return NULL;
12819         }
12820     }
12821 {
12822     wxPy_BEGIN_ALLOW_THREADS;
12823         _result = (int )wxGridEvent_GetRow(_arg0);
12824
12825     wxPy_END_ALLOW_THREADS;
12826     if (PyErr_Occurred()) return NULL;
12827 }    _resultobj = Py_BuildValue("i",_result);
12828     return _resultobj;
12829 }
12830
12831 #define wxGridEvent_GetCol(_swigobj)  (_swigobj->GetCol())
12832 static PyObject *_wrap_wxGridEvent_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
12833     PyObject * _resultobj;
12834     int  _result;
12835     wxGridEvent * _arg0;
12836     PyObject * _argo0 = 0;
12837     char *_kwnames[] = { "self", NULL };
12838
12839     self = self;
12840     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetCol",_kwnames,&_argo0))
12841         return NULL;
12842     if (_argo0) {
12843         if (_argo0 == Py_None) { _arg0 = NULL; }
12844         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12845             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetCol. Expected _wxGridEvent_p.");
12846         return NULL;
12847         }
12848     }
12849 {
12850     wxPy_BEGIN_ALLOW_THREADS;
12851         _result = (int )wxGridEvent_GetCol(_arg0);
12852
12853     wxPy_END_ALLOW_THREADS;
12854     if (PyErr_Occurred()) return NULL;
12855 }    _resultobj = Py_BuildValue("i",_result);
12856     return _resultobj;
12857 }
12858
12859 #define wxGridEvent_GetPosition(_swigobj)  (_swigobj->GetPosition())
12860 static PyObject *_wrap_wxGridEvent_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
12861     PyObject * _resultobj;
12862     wxPoint * _result;
12863     wxGridEvent * _arg0;
12864     PyObject * _argo0 = 0;
12865     char *_kwnames[] = { "self", NULL };
12866     char _ptemp[128];
12867
12868     self = self;
12869     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_GetPosition",_kwnames,&_argo0))
12870         return NULL;
12871     if (_argo0) {
12872         if (_argo0 == Py_None) { _arg0 = NULL; }
12873         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12874             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_GetPosition. Expected _wxGridEvent_p.");
12875         return NULL;
12876         }
12877     }
12878 {
12879     wxPy_BEGIN_ALLOW_THREADS;
12880         _result = new wxPoint (wxGridEvent_GetPosition(_arg0));
12881
12882     wxPy_END_ALLOW_THREADS;
12883     if (PyErr_Occurred()) return NULL;
12884 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
12885     _resultobj = Py_BuildValue("s",_ptemp);
12886     return _resultobj;
12887 }
12888
12889 #define wxGridEvent_Selecting(_swigobj)  (_swigobj->Selecting())
12890 static PyObject *_wrap_wxGridEvent_Selecting(PyObject *self, PyObject *args, PyObject *kwargs) {
12891     PyObject * _resultobj;
12892     bool  _result;
12893     wxGridEvent * _arg0;
12894     PyObject * _argo0 = 0;
12895     char *_kwnames[] = { "self", NULL };
12896
12897     self = self;
12898     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_Selecting",_kwnames,&_argo0))
12899         return NULL;
12900     if (_argo0) {
12901         if (_argo0 == Py_None) { _arg0 = NULL; }
12902         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12903             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_Selecting. Expected _wxGridEvent_p.");
12904         return NULL;
12905         }
12906     }
12907 {
12908     wxPy_BEGIN_ALLOW_THREADS;
12909         _result = (bool )wxGridEvent_Selecting(_arg0);
12910
12911     wxPy_END_ALLOW_THREADS;
12912     if (PyErr_Occurred()) return NULL;
12913 }    _resultobj = Py_BuildValue("i",_result);
12914     return _resultobj;
12915 }
12916
12917 #define wxGridEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
12918 static PyObject *_wrap_wxGridEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12919     PyObject * _resultobj;
12920     bool  _result;
12921     wxGridEvent * _arg0;
12922     PyObject * _argo0 = 0;
12923     char *_kwnames[] = { "self", NULL };
12924
12925     self = self;
12926     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_ControlDown",_kwnames,&_argo0))
12927         return NULL;
12928     if (_argo0) {
12929         if (_argo0 == Py_None) { _arg0 = NULL; }
12930         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12931             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_ControlDown. Expected _wxGridEvent_p.");
12932         return NULL;
12933         }
12934     }
12935 {
12936     wxPy_BEGIN_ALLOW_THREADS;
12937         _result = (bool )wxGridEvent_ControlDown(_arg0);
12938
12939     wxPy_END_ALLOW_THREADS;
12940     if (PyErr_Occurred()) return NULL;
12941 }    _resultobj = Py_BuildValue("i",_result);
12942     return _resultobj;
12943 }
12944
12945 #define wxGridEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
12946 static PyObject *_wrap_wxGridEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12947     PyObject * _resultobj;
12948     bool  _result;
12949     wxGridEvent * _arg0;
12950     PyObject * _argo0 = 0;
12951     char *_kwnames[] = { "self", NULL };
12952
12953     self = self;
12954     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_MetaDown",_kwnames,&_argo0))
12955         return NULL;
12956     if (_argo0) {
12957         if (_argo0 == Py_None) { _arg0 = NULL; }
12958         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12959             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_MetaDown. Expected _wxGridEvent_p.");
12960         return NULL;
12961         }
12962     }
12963 {
12964     wxPy_BEGIN_ALLOW_THREADS;
12965         _result = (bool )wxGridEvent_MetaDown(_arg0);
12966
12967     wxPy_END_ALLOW_THREADS;
12968     if (PyErr_Occurred()) return NULL;
12969 }    _resultobj = Py_BuildValue("i",_result);
12970     return _resultobj;
12971 }
12972
12973 #define wxGridEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
12974 static PyObject *_wrap_wxGridEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
12975     PyObject * _resultobj;
12976     bool  _result;
12977     wxGridEvent * _arg0;
12978     PyObject * _argo0 = 0;
12979     char *_kwnames[] = { "self", NULL };
12980
12981     self = self;
12982     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_ShiftDown",_kwnames,&_argo0))
12983         return NULL;
12984     if (_argo0) {
12985         if (_argo0 == Py_None) { _arg0 = NULL; }
12986         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
12987             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_ShiftDown. Expected _wxGridEvent_p.");
12988         return NULL;
12989         }
12990     }
12991 {
12992     wxPy_BEGIN_ALLOW_THREADS;
12993         _result = (bool )wxGridEvent_ShiftDown(_arg0);
12994
12995     wxPy_END_ALLOW_THREADS;
12996     if (PyErr_Occurred()) return NULL;
12997 }    _resultobj = Py_BuildValue("i",_result);
12998     return _resultobj;
12999 }
13000
13001 #define wxGridEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13002 static PyObject *_wrap_wxGridEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13003     PyObject * _resultobj;
13004     bool  _result;
13005     wxGridEvent * _arg0;
13006     PyObject * _argo0 = 0;
13007     char *_kwnames[] = { "self", NULL };
13008
13009     self = self;
13010     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEvent_AltDown",_kwnames,&_argo0))
13011         return NULL;
13012     if (_argo0) {
13013         if (_argo0 == Py_None) { _arg0 = NULL; }
13014         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEvent_p")) {
13015             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEvent_AltDown. Expected _wxGridEvent_p.");
13016         return NULL;
13017         }
13018     }
13019 {
13020     wxPy_BEGIN_ALLOW_THREADS;
13021         _result = (bool )wxGridEvent_AltDown(_arg0);
13022
13023     wxPy_END_ALLOW_THREADS;
13024     if (PyErr_Occurred()) return NULL;
13025 }    _resultobj = Py_BuildValue("i",_result);
13026     return _resultobj;
13027 }
13028
13029 static void *SwigwxGridSizeEventTowxNotifyEvent(void *ptr) {
13030     wxGridSizeEvent *src;
13031     wxNotifyEvent *dest;
13032     src = (wxGridSizeEvent *) ptr;
13033     dest = (wxNotifyEvent *) src;
13034     return (void *) dest;
13035 }
13036
13037 static void *SwigwxGridSizeEventTowxCommandEvent(void *ptr) {
13038     wxGridSizeEvent *src;
13039     wxCommandEvent *dest;
13040     src = (wxGridSizeEvent *) ptr;
13041     dest = (wxCommandEvent *) src;
13042     return (void *) dest;
13043 }
13044
13045 static void *SwigwxGridSizeEventTowxEvent(void *ptr) {
13046     wxGridSizeEvent *src;
13047     wxEvent *dest;
13048     src = (wxGridSizeEvent *) ptr;
13049     dest = (wxEvent *) src;
13050     return (void *) dest;
13051 }
13052
13053 static void *SwigwxGridSizeEventTowxObject(void *ptr) {
13054     wxGridSizeEvent *src;
13055     wxObject *dest;
13056     src = (wxGridSizeEvent *) ptr;
13057     dest = (wxObject *) src;
13058     return (void *) dest;
13059 }
13060
13061 #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))
13062 static PyObject *_wrap_new_wxGridSizeEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13063     PyObject * _resultobj;
13064     wxGridSizeEvent * _result;
13065     int  _arg0;
13066     wxEventType  _arg1;
13067     wxGrid * _arg2;
13068     int  _arg3 = (int ) -1;
13069     int  _arg4 = (int ) -1;
13070     int  _arg5 = (int ) -1;
13071     bool  _arg6 = (bool ) FALSE;
13072     bool  _arg7 = (bool ) FALSE;
13073     bool  _arg8 = (bool ) FALSE;
13074     bool  _arg9 = (bool ) FALSE;
13075     PyObject * _argo2 = 0;
13076     int tempbool6 = (int) FALSE;
13077     int tempbool7 = (int) FALSE;
13078     int tempbool8 = (int) FALSE;
13079     int tempbool9 = (int) FALSE;
13080     char *_kwnames[] = { "id","type","obj","rowOrCol","x","y","control","shift","alt","meta", NULL };
13081     char _ptemp[128];
13082
13083     self = self;
13084     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiO|iiiiiii:new_wxGridSizeEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_arg5,&tempbool6,&tempbool7,&tempbool8,&tempbool9))
13085         return NULL;
13086     if (_argo2) {
13087         if (_argo2 == Py_None) { _arg2 = NULL; }
13088         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
13089             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridSizeEvent. Expected _wxGrid_p.");
13090         return NULL;
13091         }
13092     }
13093     _arg6 = (bool ) tempbool6;
13094     _arg7 = (bool ) tempbool7;
13095     _arg8 = (bool ) tempbool8;
13096     _arg9 = (bool ) tempbool9;
13097 {
13098     wxPy_BEGIN_ALLOW_THREADS;
13099         _result = (wxGridSizeEvent *)new_wxGridSizeEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
13100
13101     wxPy_END_ALLOW_THREADS;
13102     if (PyErr_Occurred()) return NULL;
13103 }    if (_result) {
13104         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridSizeEvent_p");
13105         _resultobj = Py_BuildValue("s",_ptemp);
13106     } else {
13107         Py_INCREF(Py_None);
13108         _resultobj = Py_None;
13109     }
13110     return _resultobj;
13111 }
13112
13113 #define wxGridSizeEvent_GetRowOrCol(_swigobj)  (_swigobj->GetRowOrCol())
13114 static PyObject *_wrap_wxGridSizeEvent_GetRowOrCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13115     PyObject * _resultobj;
13116     int  _result;
13117     wxGridSizeEvent * _arg0;
13118     PyObject * _argo0 = 0;
13119     char *_kwnames[] = { "self", NULL };
13120
13121     self = self;
13122     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_GetRowOrCol",_kwnames,&_argo0))
13123         return NULL;
13124     if (_argo0) {
13125         if (_argo0 == Py_None) { _arg0 = NULL; }
13126         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13127             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_GetRowOrCol. Expected _wxGridSizeEvent_p.");
13128         return NULL;
13129         }
13130     }
13131 {
13132     wxPy_BEGIN_ALLOW_THREADS;
13133         _result = (int )wxGridSizeEvent_GetRowOrCol(_arg0);
13134
13135     wxPy_END_ALLOW_THREADS;
13136     if (PyErr_Occurred()) return NULL;
13137 }    _resultobj = Py_BuildValue("i",_result);
13138     return _resultobj;
13139 }
13140
13141 #define wxGridSizeEvent_GetPosition(_swigobj)  (_swigobj->GetPosition())
13142 static PyObject *_wrap_wxGridSizeEvent_GetPosition(PyObject *self, PyObject *args, PyObject *kwargs) {
13143     PyObject * _resultobj;
13144     wxPoint * _result;
13145     wxGridSizeEvent * _arg0;
13146     PyObject * _argo0 = 0;
13147     char *_kwnames[] = { "self", NULL };
13148     char _ptemp[128];
13149
13150     self = self;
13151     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_GetPosition",_kwnames,&_argo0))
13152         return NULL;
13153     if (_argo0) {
13154         if (_argo0 == Py_None) { _arg0 = NULL; }
13155         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13156             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_GetPosition. Expected _wxGridSizeEvent_p.");
13157         return NULL;
13158         }
13159     }
13160 {
13161     wxPy_BEGIN_ALLOW_THREADS;
13162         _result = new wxPoint (wxGridSizeEvent_GetPosition(_arg0));
13163
13164     wxPy_END_ALLOW_THREADS;
13165     if (PyErr_Occurred()) return NULL;
13166 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxPoint_p");
13167     _resultobj = Py_BuildValue("s",_ptemp);
13168     return _resultobj;
13169 }
13170
13171 #define wxGridSizeEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
13172 static PyObject *_wrap_wxGridSizeEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13173     PyObject * _resultobj;
13174     bool  _result;
13175     wxGridSizeEvent * _arg0;
13176     PyObject * _argo0 = 0;
13177     char *_kwnames[] = { "self", NULL };
13178
13179     self = self;
13180     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_ControlDown",_kwnames,&_argo0))
13181         return NULL;
13182     if (_argo0) {
13183         if (_argo0 == Py_None) { _arg0 = NULL; }
13184         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13185             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_ControlDown. Expected _wxGridSizeEvent_p.");
13186         return NULL;
13187         }
13188     }
13189 {
13190     wxPy_BEGIN_ALLOW_THREADS;
13191         _result = (bool )wxGridSizeEvent_ControlDown(_arg0);
13192
13193     wxPy_END_ALLOW_THREADS;
13194     if (PyErr_Occurred()) return NULL;
13195 }    _resultobj = Py_BuildValue("i",_result);
13196     return _resultobj;
13197 }
13198
13199 #define wxGridSizeEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
13200 static PyObject *_wrap_wxGridSizeEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13201     PyObject * _resultobj;
13202     bool  _result;
13203     wxGridSizeEvent * _arg0;
13204     PyObject * _argo0 = 0;
13205     char *_kwnames[] = { "self", NULL };
13206
13207     self = self;
13208     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_MetaDown",_kwnames,&_argo0))
13209         return NULL;
13210     if (_argo0) {
13211         if (_argo0 == Py_None) { _arg0 = NULL; }
13212         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13213             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_MetaDown. Expected _wxGridSizeEvent_p.");
13214         return NULL;
13215         }
13216     }
13217 {
13218     wxPy_BEGIN_ALLOW_THREADS;
13219         _result = (bool )wxGridSizeEvent_MetaDown(_arg0);
13220
13221     wxPy_END_ALLOW_THREADS;
13222     if (PyErr_Occurred()) return NULL;
13223 }    _resultobj = Py_BuildValue("i",_result);
13224     return _resultobj;
13225 }
13226
13227 #define wxGridSizeEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13228 static PyObject *_wrap_wxGridSizeEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13229     PyObject * _resultobj;
13230     bool  _result;
13231     wxGridSizeEvent * _arg0;
13232     PyObject * _argo0 = 0;
13233     char *_kwnames[] = { "self", NULL };
13234
13235     self = self;
13236     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_ShiftDown",_kwnames,&_argo0))
13237         return NULL;
13238     if (_argo0) {
13239         if (_argo0 == Py_None) { _arg0 = NULL; }
13240         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13241             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_ShiftDown. Expected _wxGridSizeEvent_p.");
13242         return NULL;
13243         }
13244     }
13245 {
13246     wxPy_BEGIN_ALLOW_THREADS;
13247         _result = (bool )wxGridSizeEvent_ShiftDown(_arg0);
13248
13249     wxPy_END_ALLOW_THREADS;
13250     if (PyErr_Occurred()) return NULL;
13251 }    _resultobj = Py_BuildValue("i",_result);
13252     return _resultobj;
13253 }
13254
13255 #define wxGridSizeEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13256 static PyObject *_wrap_wxGridSizeEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13257     PyObject * _resultobj;
13258     bool  _result;
13259     wxGridSizeEvent * _arg0;
13260     PyObject * _argo0 = 0;
13261     char *_kwnames[] = { "self", NULL };
13262
13263     self = self;
13264     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridSizeEvent_AltDown",_kwnames,&_argo0))
13265         return NULL;
13266     if (_argo0) {
13267         if (_argo0 == Py_None) { _arg0 = NULL; }
13268         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridSizeEvent_p")) {
13269             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridSizeEvent_AltDown. Expected _wxGridSizeEvent_p.");
13270         return NULL;
13271         }
13272     }
13273 {
13274     wxPy_BEGIN_ALLOW_THREADS;
13275         _result = (bool )wxGridSizeEvent_AltDown(_arg0);
13276
13277     wxPy_END_ALLOW_THREADS;
13278     if (PyErr_Occurred()) return NULL;
13279 }    _resultobj = Py_BuildValue("i",_result);
13280     return _resultobj;
13281 }
13282
13283 static void *SwigwxGridRangeSelectEventTowxNotifyEvent(void *ptr) {
13284     wxGridRangeSelectEvent *src;
13285     wxNotifyEvent *dest;
13286     src = (wxGridRangeSelectEvent *) ptr;
13287     dest = (wxNotifyEvent *) src;
13288     return (void *) dest;
13289 }
13290
13291 static void *SwigwxGridRangeSelectEventTowxCommandEvent(void *ptr) {
13292     wxGridRangeSelectEvent *src;
13293     wxCommandEvent *dest;
13294     src = (wxGridRangeSelectEvent *) ptr;
13295     dest = (wxCommandEvent *) src;
13296     return (void *) dest;
13297 }
13298
13299 static void *SwigwxGridRangeSelectEventTowxEvent(void *ptr) {
13300     wxGridRangeSelectEvent *src;
13301     wxEvent *dest;
13302     src = (wxGridRangeSelectEvent *) ptr;
13303     dest = (wxEvent *) src;
13304     return (void *) dest;
13305 }
13306
13307 static void *SwigwxGridRangeSelectEventTowxObject(void *ptr) {
13308     wxGridRangeSelectEvent *src;
13309     wxObject *dest;
13310     src = (wxGridRangeSelectEvent *) ptr;
13311     dest = (wxObject *) src;
13312     return (void *) dest;
13313 }
13314
13315 #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))
13316 static PyObject *_wrap_new_wxGridRangeSelectEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13317     PyObject * _resultobj;
13318     wxGridRangeSelectEvent * _result;
13319     int  _arg0;
13320     wxEventType  _arg1;
13321     wxGrid * _arg2;
13322     wxGridCellCoords * _arg3;
13323     wxGridCellCoords * _arg4;
13324     bool  _arg5 = (bool ) TRUE;
13325     bool  _arg6 = (bool ) FALSE;
13326     bool  _arg7 = (bool ) FALSE;
13327     bool  _arg8 = (bool ) FALSE;
13328     bool  _arg9 = (bool ) FALSE;
13329     PyObject * _argo2 = 0;
13330     wxGridCellCoords  temp;
13331     PyObject * _obj3 = 0;
13332     wxGridCellCoords  temp0;
13333     PyObject * _obj4 = 0;
13334     int tempbool5 = (int) TRUE;
13335     int tempbool6 = (int) FALSE;
13336     int tempbool7 = (int) FALSE;
13337     int tempbool8 = (int) FALSE;
13338     int tempbool9 = (int) FALSE;
13339     char *_kwnames[] = { "id","type","obj","topLeft","bottomRight","sel","control","shift","alt","meta", NULL };
13340     char _ptemp[128];
13341
13342     self = self;
13343     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiOOO|iiiii:new_wxGridRangeSelectEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_obj3,&_obj4,&tempbool5,&tempbool6,&tempbool7,&tempbool8,&tempbool9))
13344         return NULL;
13345     if (_argo2) {
13346         if (_argo2 == Py_None) { _arg2 = NULL; }
13347         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxGrid_p")) {
13348             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridRangeSelectEvent. Expected _wxGrid_p.");
13349         return NULL;
13350         }
13351     }
13352 {
13353     _arg3 = &temp;
13354     if (! wxGridCellCoords_helper(_obj3, &_arg3))
13355         return NULL;
13356 }
13357 {
13358     _arg4 = &temp0;
13359     if (! wxGridCellCoords_helper(_obj4, &_arg4))
13360         return NULL;
13361 }
13362     _arg5 = (bool ) tempbool5;
13363     _arg6 = (bool ) tempbool6;
13364     _arg7 = (bool ) tempbool7;
13365     _arg8 = (bool ) tempbool8;
13366     _arg9 = (bool ) tempbool9;
13367 {
13368     wxPy_BEGIN_ALLOW_THREADS;
13369         _result = (wxGridRangeSelectEvent *)new_wxGridRangeSelectEvent(_arg0,_arg1,_arg2,*_arg3,*_arg4,_arg5,_arg6,_arg7,_arg8,_arg9);
13370
13371     wxPy_END_ALLOW_THREADS;
13372     if (PyErr_Occurred()) return NULL;
13373 }    if (_result) {
13374         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridRangeSelectEvent_p");
13375         _resultobj = Py_BuildValue("s",_ptemp);
13376     } else {
13377         Py_INCREF(Py_None);
13378         _resultobj = Py_None;
13379     }
13380     return _resultobj;
13381 }
13382
13383 #define wxGridRangeSelectEvent_GetTopLeftCoords(_swigobj)  (_swigobj->GetTopLeftCoords())
13384 static PyObject *_wrap_wxGridRangeSelectEvent_GetTopLeftCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
13385     PyObject * _resultobj;
13386     wxGridCellCoords * _result;
13387     wxGridRangeSelectEvent * _arg0;
13388     PyObject * _argo0 = 0;
13389     char *_kwnames[] = { "self", NULL };
13390     char _ptemp[128];
13391
13392     self = self;
13393     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetTopLeftCoords",_kwnames,&_argo0))
13394         return NULL;
13395     if (_argo0) {
13396         if (_argo0 == Py_None) { _arg0 = NULL; }
13397         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13398             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetTopLeftCoords. Expected _wxGridRangeSelectEvent_p.");
13399         return NULL;
13400         }
13401     }
13402 {
13403     wxPy_BEGIN_ALLOW_THREADS;
13404         _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetTopLeftCoords(_arg0));
13405
13406     wxPy_END_ALLOW_THREADS;
13407     if (PyErr_Occurred()) return NULL;
13408 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
13409     _resultobj = Py_BuildValue("s",_ptemp);
13410     return _resultobj;
13411 }
13412
13413 #define wxGridRangeSelectEvent_GetBottomRightCoords(_swigobj)  (_swigobj->GetBottomRightCoords())
13414 static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRightCoords(PyObject *self, PyObject *args, PyObject *kwargs) {
13415     PyObject * _resultobj;
13416     wxGridCellCoords * _result;
13417     wxGridRangeSelectEvent * _arg0;
13418     PyObject * _argo0 = 0;
13419     char *_kwnames[] = { "self", NULL };
13420     char _ptemp[128];
13421
13422     self = self;
13423     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetBottomRightCoords",_kwnames,&_argo0))
13424         return NULL;
13425     if (_argo0) {
13426         if (_argo0 == Py_None) { _arg0 = NULL; }
13427         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13428             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetBottomRightCoords. Expected _wxGridRangeSelectEvent_p.");
13429         return NULL;
13430         }
13431     }
13432 {
13433     wxPy_BEGIN_ALLOW_THREADS;
13434         _result = new wxGridCellCoords (wxGridRangeSelectEvent_GetBottomRightCoords(_arg0));
13435
13436     wxPy_END_ALLOW_THREADS;
13437     if (PyErr_Occurred()) return NULL;
13438 }    SWIG_MakePtr(_ptemp, (void *) _result,"_wxGridCellCoords_p");
13439     _resultobj = Py_BuildValue("s",_ptemp);
13440     return _resultobj;
13441 }
13442
13443 #define wxGridRangeSelectEvent_GetTopRow(_swigobj)  (_swigobj->GetTopRow())
13444 static PyObject *_wrap_wxGridRangeSelectEvent_GetTopRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13445     PyObject * _resultobj;
13446     int  _result;
13447     wxGridRangeSelectEvent * _arg0;
13448     PyObject * _argo0 = 0;
13449     char *_kwnames[] = { "self", NULL };
13450
13451     self = self;
13452     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetTopRow",_kwnames,&_argo0))
13453         return NULL;
13454     if (_argo0) {
13455         if (_argo0 == Py_None) { _arg0 = NULL; }
13456         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13457             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetTopRow. Expected _wxGridRangeSelectEvent_p.");
13458         return NULL;
13459         }
13460     }
13461 {
13462     wxPy_BEGIN_ALLOW_THREADS;
13463         _result = (int )wxGridRangeSelectEvent_GetTopRow(_arg0);
13464
13465     wxPy_END_ALLOW_THREADS;
13466     if (PyErr_Occurred()) return NULL;
13467 }    _resultobj = Py_BuildValue("i",_result);
13468     return _resultobj;
13469 }
13470
13471 #define wxGridRangeSelectEvent_GetBottomRow(_swigobj)  (_swigobj->GetBottomRow())
13472 static PyObject *_wrap_wxGridRangeSelectEvent_GetBottomRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13473     PyObject * _resultobj;
13474     int  _result;
13475     wxGridRangeSelectEvent * _arg0;
13476     PyObject * _argo0 = 0;
13477     char *_kwnames[] = { "self", NULL };
13478
13479     self = self;
13480     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetBottomRow",_kwnames,&_argo0))
13481         return NULL;
13482     if (_argo0) {
13483         if (_argo0 == Py_None) { _arg0 = NULL; }
13484         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13485             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetBottomRow. Expected _wxGridRangeSelectEvent_p.");
13486         return NULL;
13487         }
13488     }
13489 {
13490     wxPy_BEGIN_ALLOW_THREADS;
13491         _result = (int )wxGridRangeSelectEvent_GetBottomRow(_arg0);
13492
13493     wxPy_END_ALLOW_THREADS;
13494     if (PyErr_Occurred()) return NULL;
13495 }    _resultobj = Py_BuildValue("i",_result);
13496     return _resultobj;
13497 }
13498
13499 #define wxGridRangeSelectEvent_GetLeftCol(_swigobj)  (_swigobj->GetLeftCol())
13500 static PyObject *_wrap_wxGridRangeSelectEvent_GetLeftCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13501     PyObject * _resultobj;
13502     int  _result;
13503     wxGridRangeSelectEvent * _arg0;
13504     PyObject * _argo0 = 0;
13505     char *_kwnames[] = { "self", NULL };
13506
13507     self = self;
13508     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetLeftCol",_kwnames,&_argo0))
13509         return NULL;
13510     if (_argo0) {
13511         if (_argo0 == Py_None) { _arg0 = NULL; }
13512         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13513             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetLeftCol. Expected _wxGridRangeSelectEvent_p.");
13514         return NULL;
13515         }
13516     }
13517 {
13518     wxPy_BEGIN_ALLOW_THREADS;
13519         _result = (int )wxGridRangeSelectEvent_GetLeftCol(_arg0);
13520
13521     wxPy_END_ALLOW_THREADS;
13522     if (PyErr_Occurred()) return NULL;
13523 }    _resultobj = Py_BuildValue("i",_result);
13524     return _resultobj;
13525 }
13526
13527 #define wxGridRangeSelectEvent_GetRightCol(_swigobj)  (_swigobj->GetRightCol())
13528 static PyObject *_wrap_wxGridRangeSelectEvent_GetRightCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13529     PyObject * _resultobj;
13530     int  _result;
13531     wxGridRangeSelectEvent * _arg0;
13532     PyObject * _argo0 = 0;
13533     char *_kwnames[] = { "self", NULL };
13534
13535     self = self;
13536     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_GetRightCol",_kwnames,&_argo0))
13537         return NULL;
13538     if (_argo0) {
13539         if (_argo0 == Py_None) { _arg0 = NULL; }
13540         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13541             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_GetRightCol. Expected _wxGridRangeSelectEvent_p.");
13542         return NULL;
13543         }
13544     }
13545 {
13546     wxPy_BEGIN_ALLOW_THREADS;
13547         _result = (int )wxGridRangeSelectEvent_GetRightCol(_arg0);
13548
13549     wxPy_END_ALLOW_THREADS;
13550     if (PyErr_Occurred()) return NULL;
13551 }    _resultobj = Py_BuildValue("i",_result);
13552     return _resultobj;
13553 }
13554
13555 #define wxGridRangeSelectEvent_Selecting(_swigobj)  (_swigobj->Selecting())
13556 static PyObject *_wrap_wxGridRangeSelectEvent_Selecting(PyObject *self, PyObject *args, PyObject *kwargs) {
13557     PyObject * _resultobj;
13558     bool  _result;
13559     wxGridRangeSelectEvent * _arg0;
13560     PyObject * _argo0 = 0;
13561     char *_kwnames[] = { "self", NULL };
13562
13563     self = self;
13564     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_Selecting",_kwnames,&_argo0))
13565         return NULL;
13566     if (_argo0) {
13567         if (_argo0 == Py_None) { _arg0 = NULL; }
13568         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13569             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_Selecting. Expected _wxGridRangeSelectEvent_p.");
13570         return NULL;
13571         }
13572     }
13573 {
13574     wxPy_BEGIN_ALLOW_THREADS;
13575         _result = (bool )wxGridRangeSelectEvent_Selecting(_arg0);
13576
13577     wxPy_END_ALLOW_THREADS;
13578     if (PyErr_Occurred()) return NULL;
13579 }    _resultobj = Py_BuildValue("i",_result);
13580     return _resultobj;
13581 }
13582
13583 #define wxGridRangeSelectEvent_ControlDown(_swigobj)  (_swigobj->ControlDown())
13584 static PyObject *_wrap_wxGridRangeSelectEvent_ControlDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13585     PyObject * _resultobj;
13586     bool  _result;
13587     wxGridRangeSelectEvent * _arg0;
13588     PyObject * _argo0 = 0;
13589     char *_kwnames[] = { "self", NULL };
13590
13591     self = self;
13592     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_ControlDown",_kwnames,&_argo0))
13593         return NULL;
13594     if (_argo0) {
13595         if (_argo0 == Py_None) { _arg0 = NULL; }
13596         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13597             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_ControlDown. Expected _wxGridRangeSelectEvent_p.");
13598         return NULL;
13599         }
13600     }
13601 {
13602     wxPy_BEGIN_ALLOW_THREADS;
13603         _result = (bool )wxGridRangeSelectEvent_ControlDown(_arg0);
13604
13605     wxPy_END_ALLOW_THREADS;
13606     if (PyErr_Occurred()) return NULL;
13607 }    _resultobj = Py_BuildValue("i",_result);
13608     return _resultobj;
13609 }
13610
13611 #define wxGridRangeSelectEvent_MetaDown(_swigobj)  (_swigobj->MetaDown())
13612 static PyObject *_wrap_wxGridRangeSelectEvent_MetaDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13613     PyObject * _resultobj;
13614     bool  _result;
13615     wxGridRangeSelectEvent * _arg0;
13616     PyObject * _argo0 = 0;
13617     char *_kwnames[] = { "self", NULL };
13618
13619     self = self;
13620     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_MetaDown",_kwnames,&_argo0))
13621         return NULL;
13622     if (_argo0) {
13623         if (_argo0 == Py_None) { _arg0 = NULL; }
13624         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13625             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_MetaDown. Expected _wxGridRangeSelectEvent_p.");
13626         return NULL;
13627         }
13628     }
13629 {
13630     wxPy_BEGIN_ALLOW_THREADS;
13631         _result = (bool )wxGridRangeSelectEvent_MetaDown(_arg0);
13632
13633     wxPy_END_ALLOW_THREADS;
13634     if (PyErr_Occurred()) return NULL;
13635 }    _resultobj = Py_BuildValue("i",_result);
13636     return _resultobj;
13637 }
13638
13639 #define wxGridRangeSelectEvent_ShiftDown(_swigobj)  (_swigobj->ShiftDown())
13640 static PyObject *_wrap_wxGridRangeSelectEvent_ShiftDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13641     PyObject * _resultobj;
13642     bool  _result;
13643     wxGridRangeSelectEvent * _arg0;
13644     PyObject * _argo0 = 0;
13645     char *_kwnames[] = { "self", NULL };
13646
13647     self = self;
13648     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_ShiftDown",_kwnames,&_argo0))
13649         return NULL;
13650     if (_argo0) {
13651         if (_argo0 == Py_None) { _arg0 = NULL; }
13652         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13653             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_ShiftDown. Expected _wxGridRangeSelectEvent_p.");
13654         return NULL;
13655         }
13656     }
13657 {
13658     wxPy_BEGIN_ALLOW_THREADS;
13659         _result = (bool )wxGridRangeSelectEvent_ShiftDown(_arg0);
13660
13661     wxPy_END_ALLOW_THREADS;
13662     if (PyErr_Occurred()) return NULL;
13663 }    _resultobj = Py_BuildValue("i",_result);
13664     return _resultobj;
13665 }
13666
13667 #define wxGridRangeSelectEvent_AltDown(_swigobj)  (_swigobj->AltDown())
13668 static PyObject *_wrap_wxGridRangeSelectEvent_AltDown(PyObject *self, PyObject *args, PyObject *kwargs) {
13669     PyObject * _resultobj;
13670     bool  _result;
13671     wxGridRangeSelectEvent * _arg0;
13672     PyObject * _argo0 = 0;
13673     char *_kwnames[] = { "self", NULL };
13674
13675     self = self;
13676     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridRangeSelectEvent_AltDown",_kwnames,&_argo0))
13677         return NULL;
13678     if (_argo0) {
13679         if (_argo0 == Py_None) { _arg0 = NULL; }
13680         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridRangeSelectEvent_p")) {
13681             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridRangeSelectEvent_AltDown. Expected _wxGridRangeSelectEvent_p.");
13682         return NULL;
13683         }
13684     }
13685 {
13686     wxPy_BEGIN_ALLOW_THREADS;
13687         _result = (bool )wxGridRangeSelectEvent_AltDown(_arg0);
13688
13689     wxPy_END_ALLOW_THREADS;
13690     if (PyErr_Occurred()) return NULL;
13691 }    _resultobj = Py_BuildValue("i",_result);
13692     return _resultobj;
13693 }
13694
13695 static void *SwigwxGridEditorCreatedEventTowxCommandEvent(void *ptr) {
13696     wxGridEditorCreatedEvent *src;
13697     wxCommandEvent *dest;
13698     src = (wxGridEditorCreatedEvent *) ptr;
13699     dest = (wxCommandEvent *) src;
13700     return (void *) dest;
13701 }
13702
13703 static void *SwigwxGridEditorCreatedEventTowxEvent(void *ptr) {
13704     wxGridEditorCreatedEvent *src;
13705     wxEvent *dest;
13706     src = (wxGridEditorCreatedEvent *) ptr;
13707     dest = (wxEvent *) src;
13708     return (void *) dest;
13709 }
13710
13711 static void *SwigwxGridEditorCreatedEventTowxObject(void *ptr) {
13712     wxGridEditorCreatedEvent *src;
13713     wxObject *dest;
13714     src = (wxGridEditorCreatedEvent *) ptr;
13715     dest = (wxObject *) src;
13716     return (void *) dest;
13717 }
13718
13719 #define new_wxGridEditorCreatedEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5) (new wxGridEditorCreatedEvent(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4,_swigarg5))
13720 static PyObject *_wrap_new_wxGridEditorCreatedEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
13721     PyObject * _resultobj;
13722     wxGridEditorCreatedEvent * _result;
13723     int  _arg0;
13724     wxEventType  _arg1;
13725     wxObject * _arg2;
13726     int  _arg3;
13727     int  _arg4;
13728     wxControl * _arg5;
13729     PyObject * _argo2 = 0;
13730     PyObject * _argo5 = 0;
13731     char *_kwnames[] = { "id","type","obj","row","col","ctrl", NULL };
13732     char _ptemp[128];
13733
13734     self = self;
13735     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"iiOiiO:new_wxGridEditorCreatedEvent",_kwnames,&_arg0,&_arg1,&_argo2,&_arg3,&_arg4,&_argo5))
13736         return NULL;
13737     if (_argo2) {
13738         if (_argo2 == Py_None) { _arg2 = NULL; }
13739         else if (SWIG_GetPtrObj(_argo2,(void **) &_arg2,"_wxObject_p")) {
13740             PyErr_SetString(PyExc_TypeError,"Type error in argument 3 of new_wxGridEditorCreatedEvent. Expected _wxObject_p.");
13741         return NULL;
13742         }
13743     }
13744     if (_argo5) {
13745         if (_argo5 == Py_None) { _arg5 = NULL; }
13746         else if (SWIG_GetPtrObj(_argo5,(void **) &_arg5,"_wxControl_p")) {
13747             PyErr_SetString(PyExc_TypeError,"Type error in argument 6 of new_wxGridEditorCreatedEvent. Expected _wxControl_p.");
13748         return NULL;
13749         }
13750     }
13751 {
13752     wxPy_BEGIN_ALLOW_THREADS;
13753         _result = (wxGridEditorCreatedEvent *)new_wxGridEditorCreatedEvent(_arg0,_arg1,_arg2,_arg3,_arg4,_arg5);
13754
13755     wxPy_END_ALLOW_THREADS;
13756     if (PyErr_Occurred()) return NULL;
13757 }    if (_result) {
13758         SWIG_MakePtr(_ptemp, (char *) _result,"_wxGridEditorCreatedEvent_p");
13759         _resultobj = Py_BuildValue("s",_ptemp);
13760     } else {
13761         Py_INCREF(Py_None);
13762         _resultobj = Py_None;
13763     }
13764     return _resultobj;
13765 }
13766
13767 #define wxGridEditorCreatedEvent_GetRow(_swigobj)  (_swigobj->GetRow())
13768 static PyObject *_wrap_wxGridEditorCreatedEvent_GetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13769     PyObject * _resultobj;
13770     int  _result;
13771     wxGridEditorCreatedEvent * _arg0;
13772     PyObject * _argo0 = 0;
13773     char *_kwnames[] = { "self", NULL };
13774
13775     self = self;
13776     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetRow",_kwnames,&_argo0))
13777         return NULL;
13778     if (_argo0) {
13779         if (_argo0 == Py_None) { _arg0 = NULL; }
13780         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13781             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetRow. Expected _wxGridEditorCreatedEvent_p.");
13782         return NULL;
13783         }
13784     }
13785 {
13786     wxPy_BEGIN_ALLOW_THREADS;
13787         _result = (int )wxGridEditorCreatedEvent_GetRow(_arg0);
13788
13789     wxPy_END_ALLOW_THREADS;
13790     if (PyErr_Occurred()) return NULL;
13791 }    _resultobj = Py_BuildValue("i",_result);
13792     return _resultobj;
13793 }
13794
13795 #define wxGridEditorCreatedEvent_GetCol(_swigobj)  (_swigobj->GetCol())
13796 static PyObject *_wrap_wxGridEditorCreatedEvent_GetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13797     PyObject * _resultobj;
13798     int  _result;
13799     wxGridEditorCreatedEvent * _arg0;
13800     PyObject * _argo0 = 0;
13801     char *_kwnames[] = { "self", NULL };
13802
13803     self = self;
13804     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetCol",_kwnames,&_argo0))
13805         return NULL;
13806     if (_argo0) {
13807         if (_argo0 == Py_None) { _arg0 = NULL; }
13808         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13809             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetCol. Expected _wxGridEditorCreatedEvent_p.");
13810         return NULL;
13811         }
13812     }
13813 {
13814     wxPy_BEGIN_ALLOW_THREADS;
13815         _result = (int )wxGridEditorCreatedEvent_GetCol(_arg0);
13816
13817     wxPy_END_ALLOW_THREADS;
13818     if (PyErr_Occurred()) return NULL;
13819 }    _resultobj = Py_BuildValue("i",_result);
13820     return _resultobj;
13821 }
13822
13823 #define wxGridEditorCreatedEvent_GetControl(_swigobj)  (_swigobj->GetControl())
13824 static PyObject *_wrap_wxGridEditorCreatedEvent_GetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
13825     PyObject * _resultobj;
13826     wxControl * _result;
13827     wxGridEditorCreatedEvent * _arg0;
13828     PyObject * _argo0 = 0;
13829     char *_kwnames[] = { "self", NULL };
13830
13831     self = self;
13832     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxGridEditorCreatedEvent_GetControl",_kwnames,&_argo0))
13833         return NULL;
13834     if (_argo0) {
13835         if (_argo0 == Py_None) { _arg0 = NULL; }
13836         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13837             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_GetControl. Expected _wxGridEditorCreatedEvent_p.");
13838         return NULL;
13839         }
13840     }
13841 {
13842     wxPy_BEGIN_ALLOW_THREADS;
13843         _result = (wxControl *)wxGridEditorCreatedEvent_GetControl(_arg0);
13844
13845     wxPy_END_ALLOW_THREADS;
13846     if (PyErr_Occurred()) return NULL;
13847 }{ _resultobj = wxPyMake_wxObject(_result); }
13848     return _resultobj;
13849 }
13850
13851 #define wxGridEditorCreatedEvent_SetRow(_swigobj,_swigarg0)  (_swigobj->SetRow(_swigarg0))
13852 static PyObject *_wrap_wxGridEditorCreatedEvent_SetRow(PyObject *self, PyObject *args, PyObject *kwargs) {
13853     PyObject * _resultobj;
13854     wxGridEditorCreatedEvent * _arg0;
13855     int  _arg1;
13856     PyObject * _argo0 = 0;
13857     char *_kwnames[] = { "self","row", NULL };
13858
13859     self = self;
13860     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridEditorCreatedEvent_SetRow",_kwnames,&_argo0,&_arg1))
13861         return NULL;
13862     if (_argo0) {
13863         if (_argo0 == Py_None) { _arg0 = NULL; }
13864         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13865             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetRow. Expected _wxGridEditorCreatedEvent_p.");
13866         return NULL;
13867         }
13868     }
13869 {
13870     wxPy_BEGIN_ALLOW_THREADS;
13871         wxGridEditorCreatedEvent_SetRow(_arg0,_arg1);
13872
13873     wxPy_END_ALLOW_THREADS;
13874     if (PyErr_Occurred()) return NULL;
13875 }    Py_INCREF(Py_None);
13876     _resultobj = Py_None;
13877     return _resultobj;
13878 }
13879
13880 #define wxGridEditorCreatedEvent_SetCol(_swigobj,_swigarg0)  (_swigobj->SetCol(_swigarg0))
13881 static PyObject *_wrap_wxGridEditorCreatedEvent_SetCol(PyObject *self, PyObject *args, PyObject *kwargs) {
13882     PyObject * _resultobj;
13883     wxGridEditorCreatedEvent * _arg0;
13884     int  _arg1;
13885     PyObject * _argo0 = 0;
13886     char *_kwnames[] = { "self","col", NULL };
13887
13888     self = self;
13889     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi:wxGridEditorCreatedEvent_SetCol",_kwnames,&_argo0,&_arg1))
13890         return NULL;
13891     if (_argo0) {
13892         if (_argo0 == Py_None) { _arg0 = NULL; }
13893         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13894             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetCol. Expected _wxGridEditorCreatedEvent_p.");
13895         return NULL;
13896         }
13897     }
13898 {
13899     wxPy_BEGIN_ALLOW_THREADS;
13900         wxGridEditorCreatedEvent_SetCol(_arg0,_arg1);
13901
13902     wxPy_END_ALLOW_THREADS;
13903     if (PyErr_Occurred()) return NULL;
13904 }    Py_INCREF(Py_None);
13905     _resultobj = Py_None;
13906     return _resultobj;
13907 }
13908
13909 #define wxGridEditorCreatedEvent_SetControl(_swigobj,_swigarg0)  (_swigobj->SetControl(_swigarg0))
13910 static PyObject *_wrap_wxGridEditorCreatedEvent_SetControl(PyObject *self, PyObject *args, PyObject *kwargs) {
13911     PyObject * _resultobj;
13912     wxGridEditorCreatedEvent * _arg0;
13913     wxControl * _arg1;
13914     PyObject * _argo0 = 0;
13915     PyObject * _argo1 = 0;
13916     char *_kwnames[] = { "self","ctrl", NULL };
13917
13918     self = self;
13919     if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxGridEditorCreatedEvent_SetControl",_kwnames,&_argo0,&_argo1))
13920         return NULL;
13921     if (_argo0) {
13922         if (_argo0 == Py_None) { _arg0 = NULL; }
13923         else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxGridEditorCreatedEvent_p")) {
13924             PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxGridEditorCreatedEvent_SetControl. Expected _wxGridEditorCreatedEvent_p.");
13925         return NULL;
13926         }
13927     }
13928     if (_argo1) {
13929         if (_argo1 == Py_None) { _arg1 = NULL; }
13930         else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxControl_p")) {
13931             PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxGridEditorCreatedEvent_SetControl. Expected _wxControl_p.");
13932         return NULL;
13933         }
13934     }
13935 {
13936     wxPy_BEGIN_ALLOW_THREADS;
13937         wxGridEditorCreatedEvent_SetControl(_arg0,_arg1);
13938
13939     wxPy_END_ALLOW_THREADS;
13940     if (PyErr_Occurred()) return NULL;
13941 }    Py_INCREF(Py_None);
13942     _resultobj = Py_None;
13943     return _resultobj;
13944 }
13945
13946 static PyMethodDef gridcMethods[] = {
13947          { "wxGridEditorCreatedEvent_SetControl", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetControl, METH_VARARGS | METH_KEYWORDS },
13948          { "wxGridEditorCreatedEvent_SetCol", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetCol, METH_VARARGS | METH_KEYWORDS },
13949          { "wxGridEditorCreatedEvent_SetRow", (PyCFunction) _wrap_wxGridEditorCreatedEvent_SetRow, METH_VARARGS | METH_KEYWORDS },
13950          { "wxGridEditorCreatedEvent_GetControl", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetControl, METH_VARARGS | METH_KEYWORDS },
13951          { "wxGridEditorCreatedEvent_GetCol", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetCol, METH_VARARGS | METH_KEYWORDS },
13952          { "wxGridEditorCreatedEvent_GetRow", (PyCFunction) _wrap_wxGridEditorCreatedEvent_GetRow, METH_VARARGS | METH_KEYWORDS },
13953          { "new_wxGridEditorCreatedEvent", (PyCFunction) _wrap_new_wxGridEditorCreatedEvent, METH_VARARGS | METH_KEYWORDS },
13954          { "wxGridRangeSelectEvent_AltDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
13955          { "wxGridRangeSelectEvent_ShiftDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
13956          { "wxGridRangeSelectEvent_MetaDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
13957          { "wxGridRangeSelectEvent_ControlDown", (PyCFunction) _wrap_wxGridRangeSelectEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
13958          { "wxGridRangeSelectEvent_Selecting", (PyCFunction) _wrap_wxGridRangeSelectEvent_Selecting, METH_VARARGS | METH_KEYWORDS },
13959          { "wxGridRangeSelectEvent_GetRightCol", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetRightCol, METH_VARARGS | METH_KEYWORDS },
13960          { "wxGridRangeSelectEvent_GetLeftCol", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetLeftCol, METH_VARARGS | METH_KEYWORDS },
13961          { "wxGridRangeSelectEvent_GetBottomRow", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetBottomRow, METH_VARARGS | METH_KEYWORDS },
13962          { "wxGridRangeSelectEvent_GetTopRow", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetTopRow, METH_VARARGS | METH_KEYWORDS },
13963          { "wxGridRangeSelectEvent_GetBottomRightCoords", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetBottomRightCoords, METH_VARARGS | METH_KEYWORDS },
13964          { "wxGridRangeSelectEvent_GetTopLeftCoords", (PyCFunction) _wrap_wxGridRangeSelectEvent_GetTopLeftCoords, METH_VARARGS | METH_KEYWORDS },
13965          { "new_wxGridRangeSelectEvent", (PyCFunction) _wrap_new_wxGridRangeSelectEvent, METH_VARARGS | METH_KEYWORDS },
13966          { "wxGridSizeEvent_AltDown", (PyCFunction) _wrap_wxGridSizeEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
13967          { "wxGridSizeEvent_ShiftDown", (PyCFunction) _wrap_wxGridSizeEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
13968          { "wxGridSizeEvent_MetaDown", (PyCFunction) _wrap_wxGridSizeEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
13969          { "wxGridSizeEvent_ControlDown", (PyCFunction) _wrap_wxGridSizeEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
13970          { "wxGridSizeEvent_GetPosition", (PyCFunction) _wrap_wxGridSizeEvent_GetPosition, METH_VARARGS | METH_KEYWORDS },
13971          { "wxGridSizeEvent_GetRowOrCol", (PyCFunction) _wrap_wxGridSizeEvent_GetRowOrCol, METH_VARARGS | METH_KEYWORDS },
13972          { "new_wxGridSizeEvent", (PyCFunction) _wrap_new_wxGridSizeEvent, METH_VARARGS | METH_KEYWORDS },
13973          { "wxGridEvent_AltDown", (PyCFunction) _wrap_wxGridEvent_AltDown, METH_VARARGS | METH_KEYWORDS },
13974          { "wxGridEvent_ShiftDown", (PyCFunction) _wrap_wxGridEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS },
13975          { "wxGridEvent_MetaDown", (PyCFunction) _wrap_wxGridEvent_MetaDown, METH_VARARGS | METH_KEYWORDS },
13976          { "wxGridEvent_ControlDown", (PyCFunction) _wrap_wxGridEvent_ControlDown, METH_VARARGS | METH_KEYWORDS },
13977          { "wxGridEvent_Selecting", (PyCFunction) _wrap_wxGridEvent_Selecting, METH_VARARGS | METH_KEYWORDS },
13978          { "wxGridEvent_GetPosition", (PyCFunction) _wrap_wxGridEvent_GetPosition, METH_VARARGS | METH_KEYWORDS },
13979          { "wxGridEvent_GetCol", (PyCFunction) _wrap_wxGridEvent_GetCol, METH_VARARGS | METH_KEYWORDS },
13980          { "wxGridEvent_GetRow", (PyCFunction) _wrap_wxGridEvent_GetRow, METH_VARARGS | METH_KEYWORDS },
13981          { "new_wxGridEvent", (PyCFunction) _wrap_new_wxGridEvent, METH_VARARGS | METH_KEYWORDS },
13982          { "wxGrid_GetGridCornerLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridCornerLabelWindow, METH_VARARGS | METH_KEYWORDS },
13983          { "wxGrid_GetGridColLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridColLabelWindow, METH_VARARGS | METH_KEYWORDS },
13984          { "wxGrid_GetGridRowLabelWindow", (PyCFunction) _wrap_wxGrid_GetGridRowLabelWindow, METH_VARARGS | METH_KEYWORDS },
13985          { "wxGrid_GetGridWindow", (PyCFunction) _wrap_wxGrid_GetGridWindow, METH_VARARGS | METH_KEYWORDS },
13986          { "wxGrid_SetMargins", (PyCFunction) _wrap_wxGrid_SetMargins, METH_VARARGS | METH_KEYWORDS },
13987          { "wxGrid_GetDefaultRendererForType", (PyCFunction) _wrap_wxGrid_GetDefaultRendererForType, METH_VARARGS | METH_KEYWORDS },
13988          { "wxGrid_GetDefaultEditorForType", (PyCFunction) _wrap_wxGrid_GetDefaultEditorForType, METH_VARARGS | METH_KEYWORDS },
13989          { "wxGrid_GetDefaultRendererForCell", (PyCFunction) _wrap_wxGrid_GetDefaultRendererForCell, METH_VARARGS | METH_KEYWORDS },
13990          { "wxGrid_GetDefaultEditorForCell", (PyCFunction) _wrap_wxGrid_GetDefaultEditorForCell, METH_VARARGS | METH_KEYWORDS },
13991          { "wxGrid_RegisterDataType", (PyCFunction) _wrap_wxGrid_RegisterDataType, METH_VARARGS | METH_KEYWORDS },
13992          { "wxGrid_SetSelectionForeground", (PyCFunction) _wrap_wxGrid_SetSelectionForeground, METH_VARARGS | METH_KEYWORDS },
13993          { "wxGrid_SetSelectionBackground", (PyCFunction) _wrap_wxGrid_SetSelectionBackground, METH_VARARGS | METH_KEYWORDS },
13994          { "wxGrid_GetSelectionForeground", (PyCFunction) _wrap_wxGrid_GetSelectionForeground, METH_VARARGS | METH_KEYWORDS },
13995          { "wxGrid_GetSelectionBackground", (PyCFunction) _wrap_wxGrid_GetSelectionBackground, METH_VARARGS | METH_KEYWORDS },
13996          { "wxGrid_BlockToDeviceRect", (PyCFunction) _wrap_wxGrid_BlockToDeviceRect, METH_VARARGS | METH_KEYWORDS },
13997          { "wxGrid_IsInSelection", (PyCFunction) _wrap_wxGrid_IsInSelection, METH_VARARGS | METH_KEYWORDS },
13998          { "wxGrid_ClearSelection", (PyCFunction) _wrap_wxGrid_ClearSelection, METH_VARARGS | METH_KEYWORDS },
13999          { "wxGrid_IsSelection", (PyCFunction) _wrap_wxGrid_IsSelection, METH_VARARGS | METH_KEYWORDS },
14000          { "wxGrid_SelectAll", (PyCFunction) _wrap_wxGrid_SelectAll, METH_VARARGS | METH_KEYWORDS },
14001          { "wxGrid_SelectBlock", (PyCFunction) _wrap_wxGrid_SelectBlock, METH_VARARGS | METH_KEYWORDS },
14002          { "wxGrid_SelectCol", (PyCFunction) _wrap_wxGrid_SelectCol, METH_VARARGS | METH_KEYWORDS },
14003          { "wxGrid_SelectRow", (PyCFunction) _wrap_wxGrid_SelectRow, METH_VARARGS | METH_KEYWORDS },
14004          { "wxGrid_SetReadOnly", (PyCFunction) _wrap_wxGrid_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
14005          { "wxGrid_IsReadOnly", (PyCFunction) _wrap_wxGrid_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
14006          { "wxGrid_SetCellValue", (PyCFunction) _wrap_wxGrid_SetCellValue, METH_VARARGS | METH_KEYWORDS },
14007          { "wxGrid_GetCellValue", (PyCFunction) _wrap_wxGrid_GetCellValue, METH_VARARGS | METH_KEYWORDS },
14008          { "wxGrid_GetCellEditor", (PyCFunction) _wrap_wxGrid_GetCellEditor, METH_VARARGS | METH_KEYWORDS },
14009          { "wxGrid_GetDefaultEditor", (PyCFunction) _wrap_wxGrid_GetDefaultEditor, METH_VARARGS | METH_KEYWORDS },
14010          { "wxGrid_SetCellEditor", (PyCFunction) _wrap_wxGrid_SetCellEditor, METH_VARARGS | METH_KEYWORDS },
14011          { "wxGrid_SetDefaultEditor", (PyCFunction) _wrap_wxGrid_SetDefaultEditor, METH_VARARGS | METH_KEYWORDS },
14012          { "wxGrid_GetCellRenderer", (PyCFunction) _wrap_wxGrid_GetCellRenderer, METH_VARARGS | METH_KEYWORDS },
14013          { "wxGrid_GetDefaultRenderer", (PyCFunction) _wrap_wxGrid_GetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
14014          { "wxGrid_SetCellRenderer", (PyCFunction) _wrap_wxGrid_SetCellRenderer, METH_VARARGS | METH_KEYWORDS },
14015          { "wxGrid_SetDefaultRenderer", (PyCFunction) _wrap_wxGrid_SetDefaultRenderer, METH_VARARGS | METH_KEYWORDS },
14016          { "wxGrid_SetCellAlignment", (PyCFunction) _wrap_wxGrid_SetCellAlignment, METH_VARARGS | METH_KEYWORDS },
14017          { "wxGrid_SetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_SetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
14018          { "wxGrid_SetCellFont", (PyCFunction) _wrap_wxGrid_SetCellFont, METH_VARARGS | METH_KEYWORDS },
14019          { "wxGrid_SetDefaultCellFont", (PyCFunction) _wrap_wxGrid_SetDefaultCellFont, METH_VARARGS | METH_KEYWORDS },
14020          { "wxGrid_SetCellTextColour", (PyCFunction) _wrap_wxGrid_SetCellTextColour, METH_VARARGS | METH_KEYWORDS },
14021          { "wxGrid_SetDefaultCellTextColour", (PyCFunction) _wrap_wxGrid_SetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS },
14022          { "wxGrid_SetCellBackgroundColour", (PyCFunction) _wrap_wxGrid_SetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14023          { "wxGrid_SetDefaultCellBackgroundColour", (PyCFunction) _wrap_wxGrid_SetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14024          { "wxGrid_SetRowMinimalHeight", (PyCFunction) _wrap_wxGrid_SetRowMinimalHeight, METH_VARARGS | METH_KEYWORDS },
14025          { "wxGrid_SetColMinimalWidth", (PyCFunction) _wrap_wxGrid_SetColMinimalWidth, METH_VARARGS | METH_KEYWORDS },
14026          { "wxGrid_AutoSize", (PyCFunction) _wrap_wxGrid_AutoSize, METH_VARARGS | METH_KEYWORDS },
14027          { "wxGrid_AutoSizeRows", (PyCFunction) _wrap_wxGrid_AutoSizeRows, METH_VARARGS | METH_KEYWORDS },
14028          { "wxGrid_AutoSizeColumns", (PyCFunction) _wrap_wxGrid_AutoSizeColumns, METH_VARARGS | METH_KEYWORDS },
14029          { "wxGrid_AutoSizeRow", (PyCFunction) _wrap_wxGrid_AutoSizeRow, METH_VARARGS | METH_KEYWORDS },
14030          { "wxGrid_AutoSizeColumn", (PyCFunction) _wrap_wxGrid_AutoSizeColumn, METH_VARARGS | METH_KEYWORDS },
14031          { "wxGrid_SetColSize", (PyCFunction) _wrap_wxGrid_SetColSize, METH_VARARGS | METH_KEYWORDS },
14032          { "wxGrid_SetDefaultColSize", (PyCFunction) _wrap_wxGrid_SetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
14033          { "wxGrid_SetRowSize", (PyCFunction) _wrap_wxGrid_SetRowSize, METH_VARARGS | METH_KEYWORDS },
14034          { "wxGrid_SetDefaultRowSize", (PyCFunction) _wrap_wxGrid_SetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
14035          { "wxGrid_GetCellAlignment", (PyCFunction) _wrap_wxGrid_GetCellAlignment, METH_VARARGS | METH_KEYWORDS },
14036          { "wxGrid_GetDefaultCellAlignment", (PyCFunction) _wrap_wxGrid_GetDefaultCellAlignment, METH_VARARGS | METH_KEYWORDS },
14037          { "wxGrid_GetCellFont", (PyCFunction) _wrap_wxGrid_GetCellFont, METH_VARARGS | METH_KEYWORDS },
14038          { "wxGrid_GetDefaultCellFont", (PyCFunction) _wrap_wxGrid_GetDefaultCellFont, METH_VARARGS | METH_KEYWORDS },
14039          { "wxGrid_GetCellTextColour", (PyCFunction) _wrap_wxGrid_GetCellTextColour, METH_VARARGS | METH_KEYWORDS },
14040          { "wxGrid_GetDefaultCellTextColour", (PyCFunction) _wrap_wxGrid_GetDefaultCellTextColour, METH_VARARGS | METH_KEYWORDS },
14041          { "wxGrid_GetCellBackgroundColour", (PyCFunction) _wrap_wxGrid_GetCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14042          { "wxGrid_GetDefaultCellBackgroundColour", (PyCFunction) _wrap_wxGrid_GetDefaultCellBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14043          { "wxGrid_GetColSize", (PyCFunction) _wrap_wxGrid_GetColSize, METH_VARARGS | METH_KEYWORDS },
14044          { "wxGrid_GetDefaultColSize", (PyCFunction) _wrap_wxGrid_GetDefaultColSize, METH_VARARGS | METH_KEYWORDS },
14045          { "wxGrid_GetRowSize", (PyCFunction) _wrap_wxGrid_GetRowSize, METH_VARARGS | METH_KEYWORDS },
14046          { "wxGrid_GetDefaultRowSize", (PyCFunction) _wrap_wxGrid_GetDefaultRowSize, METH_VARARGS | METH_KEYWORDS },
14047          { "wxGrid_GridLinesEnabled", (PyCFunction) _wrap_wxGrid_GridLinesEnabled, METH_VARARGS | METH_KEYWORDS },
14048          { "wxGrid_EnableGridLines", (PyCFunction) _wrap_wxGrid_EnableGridLines, METH_VARARGS | METH_KEYWORDS },
14049          { "wxGrid_SetColFormatCustom", (PyCFunction) _wrap_wxGrid_SetColFormatCustom, METH_VARARGS | METH_KEYWORDS },
14050          { "wxGrid_SetColFormatFloat", (PyCFunction) _wrap_wxGrid_SetColFormatFloat, METH_VARARGS | METH_KEYWORDS },
14051          { "wxGrid_SetColFormatNumber", (PyCFunction) _wrap_wxGrid_SetColFormatNumber, METH_VARARGS | METH_KEYWORDS },
14052          { "wxGrid_SetColFormatBool", (PyCFunction) _wrap_wxGrid_SetColFormatBool, METH_VARARGS | METH_KEYWORDS },
14053          { "wxGrid_SetColAttr", (PyCFunction) _wrap_wxGrid_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14054          { "wxGrid_SetRowAttr", (PyCFunction) _wrap_wxGrid_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14055          { "wxGrid_CanDragGridSize", (PyCFunction) _wrap_wxGrid_CanDragGridSize, METH_VARARGS | METH_KEYWORDS },
14056          { "wxGrid_DisableDragGridSize", (PyCFunction) _wrap_wxGrid_DisableDragGridSize, METH_VARARGS | METH_KEYWORDS },
14057          { "wxGrid_EnableDragGridSize", (PyCFunction) _wrap_wxGrid_EnableDragGridSize, METH_VARARGS | METH_KEYWORDS },
14058          { "wxGrid_CanDragColSize", (PyCFunction) _wrap_wxGrid_CanDragColSize, METH_VARARGS | METH_KEYWORDS },
14059          { "wxGrid_DisableDragColSize", (PyCFunction) _wrap_wxGrid_DisableDragColSize, METH_VARARGS | METH_KEYWORDS },
14060          { "wxGrid_EnableDragColSize", (PyCFunction) _wrap_wxGrid_EnableDragColSize, METH_VARARGS | METH_KEYWORDS },
14061          { "wxGrid_CanDragRowSize", (PyCFunction) _wrap_wxGrid_CanDragRowSize, METH_VARARGS | METH_KEYWORDS },
14062          { "wxGrid_DisableDragRowSize", (PyCFunction) _wrap_wxGrid_DisableDragRowSize, METH_VARARGS | METH_KEYWORDS },
14063          { "wxGrid_EnableDragRowSize", (PyCFunction) _wrap_wxGrid_EnableDragRowSize, METH_VARARGS | METH_KEYWORDS },
14064          { "wxGrid_SetCellHighlightROPenWidth", (PyCFunction) _wrap_wxGrid_SetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS },
14065          { "wxGrid_SetCellHighlightPenWidth", (PyCFunction) _wrap_wxGrid_SetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS },
14066          { "wxGrid_SetCellHighlightColour", (PyCFunction) _wrap_wxGrid_SetCellHighlightColour, METH_VARARGS | METH_KEYWORDS },
14067          { "wxGrid_SetGridLineColour", (PyCFunction) _wrap_wxGrid_SetGridLineColour, METH_VARARGS | METH_KEYWORDS },
14068          { "wxGrid_SetColLabelValue", (PyCFunction) _wrap_wxGrid_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14069          { "wxGrid_SetRowLabelValue", (PyCFunction) _wrap_wxGrid_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14070          { "wxGrid_SetColLabelAlignment", (PyCFunction) _wrap_wxGrid_SetColLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14071          { "wxGrid_SetRowLabelAlignment", (PyCFunction) _wrap_wxGrid_SetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14072          { "wxGrid_SetLabelFont", (PyCFunction) _wrap_wxGrid_SetLabelFont, METH_VARARGS | METH_KEYWORDS },
14073          { "wxGrid_SetLabelTextColour", (PyCFunction) _wrap_wxGrid_SetLabelTextColour, METH_VARARGS | METH_KEYWORDS },
14074          { "wxGrid_SetLabelBackgroundColour", (PyCFunction) _wrap_wxGrid_SetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14075          { "wxGrid_SetColLabelSize", (PyCFunction) _wrap_wxGrid_SetColLabelSize, METH_VARARGS | METH_KEYWORDS },
14076          { "wxGrid_SetRowLabelSize", (PyCFunction) _wrap_wxGrid_SetRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14077          { "wxGrid_GetCellHighlightROPenWidth", (PyCFunction) _wrap_wxGrid_GetCellHighlightROPenWidth, METH_VARARGS | METH_KEYWORDS },
14078          { "wxGrid_GetCellHighlightPenWidth", (PyCFunction) _wrap_wxGrid_GetCellHighlightPenWidth, METH_VARARGS | METH_KEYWORDS },
14079          { "wxGrid_GetCellHighlightColour", (PyCFunction) _wrap_wxGrid_GetCellHighlightColour, METH_VARARGS | METH_KEYWORDS },
14080          { "wxGrid_GetGridLineColour", (PyCFunction) _wrap_wxGrid_GetGridLineColour, METH_VARARGS | METH_KEYWORDS },
14081          { "wxGrid_GetColLabelValue", (PyCFunction) _wrap_wxGrid_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14082          { "wxGrid_GetRowLabelValue", (PyCFunction) _wrap_wxGrid_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14083          { "wxGrid_GetColLabelAlignment", (PyCFunction) _wrap_wxGrid_GetColLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14084          { "wxGrid_GetRowLabelAlignment", (PyCFunction) _wrap_wxGrid_GetRowLabelAlignment, METH_VARARGS | METH_KEYWORDS },
14085          { "wxGrid_GetLabelFont", (PyCFunction) _wrap_wxGrid_GetLabelFont, METH_VARARGS | METH_KEYWORDS },
14086          { "wxGrid_GetLabelTextColour", (PyCFunction) _wrap_wxGrid_GetLabelTextColour, METH_VARARGS | METH_KEYWORDS },
14087          { "wxGrid_GetLabelBackgroundColour", (PyCFunction) _wrap_wxGrid_GetLabelBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14088          { "wxGrid_GetColLabelSize", (PyCFunction) _wrap_wxGrid_GetColLabelSize, METH_VARARGS | METH_KEYWORDS },
14089          { "wxGrid_GetDefaultColLabelSize", (PyCFunction) _wrap_wxGrid_GetDefaultColLabelSize, METH_VARARGS | METH_KEYWORDS },
14090          { "wxGrid_GetRowLabelSize", (PyCFunction) _wrap_wxGrid_GetRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14091          { "wxGrid_GetDefaultRowLabelSize", (PyCFunction) _wrap_wxGrid_GetDefaultRowLabelSize, METH_VARARGS | METH_KEYWORDS },
14092          { "wxGrid_MoveCursorRightBlock", (PyCFunction) _wrap_wxGrid_MoveCursorRightBlock, METH_VARARGS | METH_KEYWORDS },
14093          { "wxGrid_MoveCursorLeftBlock", (PyCFunction) _wrap_wxGrid_MoveCursorLeftBlock, METH_VARARGS | METH_KEYWORDS },
14094          { "wxGrid_MoveCursorDownBlock", (PyCFunction) _wrap_wxGrid_MoveCursorDownBlock, METH_VARARGS | METH_KEYWORDS },
14095          { "wxGrid_MoveCursorUpBlock", (PyCFunction) _wrap_wxGrid_MoveCursorUpBlock, METH_VARARGS | METH_KEYWORDS },
14096          { "wxGrid_MovePageUp", (PyCFunction) _wrap_wxGrid_MovePageUp, METH_VARARGS | METH_KEYWORDS },
14097          { "wxGrid_MovePageDown", (PyCFunction) _wrap_wxGrid_MovePageDown, METH_VARARGS | METH_KEYWORDS },
14098          { "wxGrid_MoveCursorRight", (PyCFunction) _wrap_wxGrid_MoveCursorRight, METH_VARARGS | METH_KEYWORDS },
14099          { "wxGrid_MoveCursorLeft", (PyCFunction) _wrap_wxGrid_MoveCursorLeft, METH_VARARGS | METH_KEYWORDS },
14100          { "wxGrid_MoveCursorDown", (PyCFunction) _wrap_wxGrid_MoveCursorDown, METH_VARARGS | METH_KEYWORDS },
14101          { "wxGrid_MoveCursorUp", (PyCFunction) _wrap_wxGrid_MoveCursorUp, METH_VARARGS | METH_KEYWORDS },
14102          { "wxGrid_SetGridCursor", (PyCFunction) _wrap_wxGrid_SetGridCursor, METH_VARARGS | METH_KEYWORDS },
14103          { "wxGrid_MakeCellVisible", (PyCFunction) _wrap_wxGrid_MakeCellVisible, METH_VARARGS | METH_KEYWORDS },
14104          { "wxGrid_IsVisible", (PyCFunction) _wrap_wxGrid_IsVisible, METH_VARARGS | METH_KEYWORDS },
14105          { "wxGrid_GetGridCursorCol", (PyCFunction) _wrap_wxGrid_GetGridCursorCol, METH_VARARGS | METH_KEYWORDS },
14106          { "wxGrid_GetGridCursorRow", (PyCFunction) _wrap_wxGrid_GetGridCursorRow, METH_VARARGS | METH_KEYWORDS },
14107          { "wxGrid_CellToRect", (PyCFunction) _wrap_wxGrid_CellToRect, METH_VARARGS | METH_KEYWORDS },
14108          { "wxGrid_XToEdgeOfCol", (PyCFunction) _wrap_wxGrid_XToEdgeOfCol, METH_VARARGS | METH_KEYWORDS },
14109          { "wxGrid_YToEdgeOfRow", (PyCFunction) _wrap_wxGrid_YToEdgeOfRow, METH_VARARGS | METH_KEYWORDS },
14110          { "wxGrid_XToCol", (PyCFunction) _wrap_wxGrid_XToCol, METH_VARARGS | METH_KEYWORDS },
14111          { "wxGrid_YToRow", (PyCFunction) _wrap_wxGrid_YToRow, METH_VARARGS | METH_KEYWORDS },
14112          { "wxGrid_XYToCell", (PyCFunction) _wrap_wxGrid_XYToCell, METH_VARARGS | METH_KEYWORDS },
14113          { "wxGrid_SaveEditControlValue", (PyCFunction) _wrap_wxGrid_SaveEditControlValue, METH_VARARGS | METH_KEYWORDS },
14114          { "wxGrid_HideCellEditControl", (PyCFunction) _wrap_wxGrid_HideCellEditControl, METH_VARARGS | METH_KEYWORDS },
14115          { "wxGrid_ShowCellEditControl", (PyCFunction) _wrap_wxGrid_ShowCellEditControl, METH_VARARGS | METH_KEYWORDS },
14116          { "wxGrid_IsCurrentCellReadOnly", (PyCFunction) _wrap_wxGrid_IsCurrentCellReadOnly, METH_VARARGS | METH_KEYWORDS },
14117          { "wxGrid_IsCellEditControlShown", (PyCFunction) _wrap_wxGrid_IsCellEditControlShown, METH_VARARGS | METH_KEYWORDS },
14118          { "wxGrid_IsCellEditControlEnabled", (PyCFunction) _wrap_wxGrid_IsCellEditControlEnabled, METH_VARARGS | METH_KEYWORDS },
14119          { "wxGrid_CanEnableCellControl", (PyCFunction) _wrap_wxGrid_CanEnableCellControl, METH_VARARGS | METH_KEYWORDS },
14120          { "wxGrid_DisableCellEditControl", (PyCFunction) _wrap_wxGrid_DisableCellEditControl, METH_VARARGS | METH_KEYWORDS },
14121          { "wxGrid_EnableCellEditControl", (PyCFunction) _wrap_wxGrid_EnableCellEditControl, METH_VARARGS | METH_KEYWORDS },
14122          { "wxGrid_EnableEditing", (PyCFunction) _wrap_wxGrid_EnableEditing, METH_VARARGS | METH_KEYWORDS },
14123          { "wxGrid_IsEditable", (PyCFunction) _wrap_wxGrid_IsEditable, METH_VARARGS | METH_KEYWORDS },
14124          { "wxGrid_ForceRefresh", (PyCFunction) _wrap_wxGrid_ForceRefresh, METH_VARARGS | METH_KEYWORDS },
14125          { "wxGrid_GetBatchCount", (PyCFunction) _wrap_wxGrid_GetBatchCount, METH_VARARGS | METH_KEYWORDS },
14126          { "wxGrid_EndBatch", (PyCFunction) _wrap_wxGrid_EndBatch, METH_VARARGS | METH_KEYWORDS },
14127          { "wxGrid_BeginBatch", (PyCFunction) _wrap_wxGrid_BeginBatch, METH_VARARGS | METH_KEYWORDS },
14128          { "wxGrid_GetTextBoxSize", (PyCFunction) _wrap_wxGrid_GetTextBoxSize, METH_VARARGS | METH_KEYWORDS },
14129          { "wxGrid_DrawTextRectangle", (PyCFunction) _wrap_wxGrid_DrawTextRectangle, METH_VARARGS | METH_KEYWORDS },
14130          { "wxGrid_DrawCellHighlight", (PyCFunction) _wrap_wxGrid_DrawCellHighlight, METH_VARARGS | METH_KEYWORDS },
14131          { "wxGrid_DeleteCols", (PyCFunction) _wrap_wxGrid_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14132          { "wxGrid_AppendCols", (PyCFunction) _wrap_wxGrid_AppendCols, METH_VARARGS | METH_KEYWORDS },
14133          { "wxGrid_InsertCols", (PyCFunction) _wrap_wxGrid_InsertCols, METH_VARARGS | METH_KEYWORDS },
14134          { "wxGrid_DeleteRows", (PyCFunction) _wrap_wxGrid_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14135          { "wxGrid_AppendRows", (PyCFunction) _wrap_wxGrid_AppendRows, METH_VARARGS | METH_KEYWORDS },
14136          { "wxGrid_InsertRows", (PyCFunction) _wrap_wxGrid_InsertRows, METH_VARARGS | METH_KEYWORDS },
14137          { "wxGrid_ClearGrid", (PyCFunction) _wrap_wxGrid_ClearGrid, METH_VARARGS | METH_KEYWORDS },
14138          { "wxGrid_SetTable", (PyCFunction) _wrap_wxGrid_SetTable, METH_VARARGS | METH_KEYWORDS },
14139          { "wxGrid_GetTable", (PyCFunction) _wrap_wxGrid_GetTable, METH_VARARGS | METH_KEYWORDS },
14140          { "wxGrid_ProcessTableMessage", (PyCFunction) _wrap_wxGrid_ProcessTableMessage, METH_VARARGS | METH_KEYWORDS },
14141          { "wxGrid_GetNumberCols", (PyCFunction) _wrap_wxGrid_GetNumberCols, METH_VARARGS | METH_KEYWORDS },
14142          { "wxGrid_GetNumberRows", (PyCFunction) _wrap_wxGrid_GetNumberRows, METH_VARARGS | METH_KEYWORDS },
14143          { "wxGrid_SetSelectionMode", (PyCFunction) _wrap_wxGrid_SetSelectionMode, METH_VARARGS | METH_KEYWORDS },
14144          { "wxGrid_CreateGrid", (PyCFunction) _wrap_wxGrid_CreateGrid, METH_VARARGS | METH_KEYWORDS },
14145          { "new_wxGrid", (PyCFunction) _wrap_new_wxGrid, METH_VARARGS | METH_KEYWORDS },
14146          { "wxGridCellCoords___cmp__", (PyCFunction) _wrap_wxGridCellCoords___cmp__, METH_VARARGS | METH_KEYWORDS },
14147          { "wxGridCellCoords_asTuple", (PyCFunction) _wrap_wxGridCellCoords_asTuple, METH_VARARGS | METH_KEYWORDS },
14148          { "wxGridCellCoords_Set", (PyCFunction) _wrap_wxGridCellCoords_Set, METH_VARARGS | METH_KEYWORDS },
14149          { "wxGridCellCoords_SetCol", (PyCFunction) _wrap_wxGridCellCoords_SetCol, METH_VARARGS | METH_KEYWORDS },
14150          { "wxGridCellCoords_GetCol", (PyCFunction) _wrap_wxGridCellCoords_GetCol, METH_VARARGS | METH_KEYWORDS },
14151          { "wxGridCellCoords_SetRow", (PyCFunction) _wrap_wxGridCellCoords_SetRow, METH_VARARGS | METH_KEYWORDS },
14152          { "wxGridCellCoords_GetRow", (PyCFunction) _wrap_wxGridCellCoords_GetRow, METH_VARARGS | METH_KEYWORDS },
14153          { "delete_wxGridCellCoords", (PyCFunction) _wrap_delete_wxGridCellCoords, METH_VARARGS | METH_KEYWORDS },
14154          { "new_wxGridCellCoords", (PyCFunction) _wrap_new_wxGridCellCoords, METH_VARARGS | METH_KEYWORDS },
14155          { "wxGridTableMessage_GetCommandInt2", (PyCFunction) _wrap_wxGridTableMessage_GetCommandInt2, METH_VARARGS | METH_KEYWORDS },
14156          { "wxGridTableMessage_SetCommandInt2", (PyCFunction) _wrap_wxGridTableMessage_SetCommandInt2, METH_VARARGS | METH_KEYWORDS },
14157          { "wxGridTableMessage_GetCommandInt", (PyCFunction) _wrap_wxGridTableMessage_GetCommandInt, METH_VARARGS | METH_KEYWORDS },
14158          { "wxGridTableMessage_SetCommandInt", (PyCFunction) _wrap_wxGridTableMessage_SetCommandInt, METH_VARARGS | METH_KEYWORDS },
14159          { "wxGridTableMessage_GetId", (PyCFunction) _wrap_wxGridTableMessage_GetId, METH_VARARGS | METH_KEYWORDS },
14160          { "wxGridTableMessage_SetId", (PyCFunction) _wrap_wxGridTableMessage_SetId, METH_VARARGS | METH_KEYWORDS },
14161          { "wxGridTableMessage_GetTableObject", (PyCFunction) _wrap_wxGridTableMessage_GetTableObject, METH_VARARGS | METH_KEYWORDS },
14162          { "wxGridTableMessage_SetTableObject", (PyCFunction) _wrap_wxGridTableMessage_SetTableObject, METH_VARARGS | METH_KEYWORDS },
14163          { "delete_wxGridTableMessage", (PyCFunction) _wrap_delete_wxGridTableMessage, METH_VARARGS | METH_KEYWORDS },
14164          { "new_wxGridTableMessage", (PyCFunction) _wrap_new_wxGridTableMessage, METH_VARARGS | METH_KEYWORDS },
14165          { "new_wxGridStringTable", (PyCFunction) _wrap_new_wxGridStringTable, METH_VARARGS | METH_KEYWORDS },
14166          { "wxPyGridTableBase_base_SetColAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14167          { "wxPyGridTableBase_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14168          { "wxPyGridTableBase_base_SetAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
14169          { "wxPyGridTableBase_base_GetAttr", (PyCFunction) _wrap_wxPyGridTableBase_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
14170          { "wxPyGridTableBase_base_CanHaveAttributes", (PyCFunction) _wrap_wxPyGridTableBase_base_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS },
14171          { "wxPyGridTableBase_base_SetColLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14172          { "wxPyGridTableBase_base_SetRowLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14173          { "wxPyGridTableBase_base_GetColLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14174          { "wxPyGridTableBase_base_GetRowLabelValue", (PyCFunction) _wrap_wxPyGridTableBase_base_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14175          { "wxPyGridTableBase_base_DeleteCols", (PyCFunction) _wrap_wxPyGridTableBase_base_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14176          { "wxPyGridTableBase_base_AppendCols", (PyCFunction) _wrap_wxPyGridTableBase_base_AppendCols, METH_VARARGS | METH_KEYWORDS },
14177          { "wxPyGridTableBase_base_InsertCols", (PyCFunction) _wrap_wxPyGridTableBase_base_InsertCols, METH_VARARGS | METH_KEYWORDS },
14178          { "wxPyGridTableBase_base_DeleteRows", (PyCFunction) _wrap_wxPyGridTableBase_base_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14179          { "wxPyGridTableBase_base_AppendRows", (PyCFunction) _wrap_wxPyGridTableBase_base_AppendRows, METH_VARARGS | METH_KEYWORDS },
14180          { "wxPyGridTableBase_base_InsertRows", (PyCFunction) _wrap_wxPyGridTableBase_base_InsertRows, METH_VARARGS | METH_KEYWORDS },
14181          { "wxPyGridTableBase_base_Clear", (PyCFunction) _wrap_wxPyGridTableBase_base_Clear, METH_VARARGS | METH_KEYWORDS },
14182          { "wxPyGridTableBase_base_CanSetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanSetValueAs, METH_VARARGS | METH_KEYWORDS },
14183          { "wxPyGridTableBase_base_CanGetValueAs", (PyCFunction) _wrap_wxPyGridTableBase_base_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
14184          { "wxPyGridTableBase_base_GetTypeName", (PyCFunction) _wrap_wxPyGridTableBase_base_GetTypeName, METH_VARARGS | METH_KEYWORDS },
14185          { "wxPyGridTableBase_Destroy", (PyCFunction) _wrap_wxPyGridTableBase_Destroy, METH_VARARGS | METH_KEYWORDS },
14186          { "wxPyGridTableBase__setCallbackInfo", (PyCFunction) _wrap_wxPyGridTableBase__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14187          { "new_wxPyGridTableBase", (PyCFunction) _wrap_new_wxPyGridTableBase, METH_VARARGS | METH_KEYWORDS },
14188          { "wxGridTableBase_SetColAttr", (PyCFunction) _wrap_wxGridTableBase_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14189          { "wxGridTableBase_SetRowAttr", (PyCFunction) _wrap_wxGridTableBase_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14190          { "wxGridTableBase_SetAttr", (PyCFunction) _wrap_wxGridTableBase_SetAttr, METH_VARARGS | METH_KEYWORDS },
14191          { "wxGridTableBase_GetAttr", (PyCFunction) _wrap_wxGridTableBase_GetAttr, METH_VARARGS | METH_KEYWORDS },
14192          { "wxGridTableBase_CanHaveAttributes", (PyCFunction) _wrap_wxGridTableBase_CanHaveAttributes, METH_VARARGS | METH_KEYWORDS },
14193          { "wxGridTableBase_SetColLabelValue", (PyCFunction) _wrap_wxGridTableBase_SetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14194          { "wxGridTableBase_SetRowLabelValue", (PyCFunction) _wrap_wxGridTableBase_SetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14195          { "wxGridTableBase_GetColLabelValue", (PyCFunction) _wrap_wxGridTableBase_GetColLabelValue, METH_VARARGS | METH_KEYWORDS },
14196          { "wxGridTableBase_GetRowLabelValue", (PyCFunction) _wrap_wxGridTableBase_GetRowLabelValue, METH_VARARGS | METH_KEYWORDS },
14197          { "wxGridTableBase_DeleteCols", (PyCFunction) _wrap_wxGridTableBase_DeleteCols, METH_VARARGS | METH_KEYWORDS },
14198          { "wxGridTableBase_AppendCols", (PyCFunction) _wrap_wxGridTableBase_AppendCols, METH_VARARGS | METH_KEYWORDS },
14199          { "wxGridTableBase_InsertCols", (PyCFunction) _wrap_wxGridTableBase_InsertCols, METH_VARARGS | METH_KEYWORDS },
14200          { "wxGridTableBase_DeleteRows", (PyCFunction) _wrap_wxGridTableBase_DeleteRows, METH_VARARGS | METH_KEYWORDS },
14201          { "wxGridTableBase_AppendRows", (PyCFunction) _wrap_wxGridTableBase_AppendRows, METH_VARARGS | METH_KEYWORDS },
14202          { "wxGridTableBase_InsertRows", (PyCFunction) _wrap_wxGridTableBase_InsertRows, METH_VARARGS | METH_KEYWORDS },
14203          { "wxGridTableBase_Clear", (PyCFunction) _wrap_wxGridTableBase_Clear, METH_VARARGS | METH_KEYWORDS },
14204          { "wxGridTableBase_SetValueAsBool", (PyCFunction) _wrap_wxGridTableBase_SetValueAsBool, METH_VARARGS | METH_KEYWORDS },
14205          { "wxGridTableBase_SetValueAsDouble", (PyCFunction) _wrap_wxGridTableBase_SetValueAsDouble, METH_VARARGS | METH_KEYWORDS },
14206          { "wxGridTableBase_SetValueAsLong", (PyCFunction) _wrap_wxGridTableBase_SetValueAsLong, METH_VARARGS | METH_KEYWORDS },
14207          { "wxGridTableBase_GetValueAsBool", (PyCFunction) _wrap_wxGridTableBase_GetValueAsBool, METH_VARARGS | METH_KEYWORDS },
14208          { "wxGridTableBase_GetValueAsDouble", (PyCFunction) _wrap_wxGridTableBase_GetValueAsDouble, METH_VARARGS | METH_KEYWORDS },
14209          { "wxGridTableBase_GetValueAsLong", (PyCFunction) _wrap_wxGridTableBase_GetValueAsLong, METH_VARARGS | METH_KEYWORDS },
14210          { "wxGridTableBase_CanSetValueAs", (PyCFunction) _wrap_wxGridTableBase_CanSetValueAs, METH_VARARGS | METH_KEYWORDS },
14211          { "wxGridTableBase_CanGetValueAs", (PyCFunction) _wrap_wxGridTableBase_CanGetValueAs, METH_VARARGS | METH_KEYWORDS },
14212          { "wxGridTableBase_GetTypeName", (PyCFunction) _wrap_wxGridTableBase_GetTypeName, METH_VARARGS | METH_KEYWORDS },
14213          { "wxGridTableBase_SetValue", (PyCFunction) _wrap_wxGridTableBase_SetValue, METH_VARARGS | METH_KEYWORDS },
14214          { "wxGridTableBase_GetValue", (PyCFunction) _wrap_wxGridTableBase_GetValue, METH_VARARGS | METH_KEYWORDS },
14215          { "wxGridTableBase_IsEmptyCell", (PyCFunction) _wrap_wxGridTableBase_IsEmptyCell, METH_VARARGS | METH_KEYWORDS },
14216          { "wxGridTableBase_GetNumberCols", (PyCFunction) _wrap_wxGridTableBase_GetNumberCols, METH_VARARGS | METH_KEYWORDS },
14217          { "wxGridTableBase_GetNumberRows", (PyCFunction) _wrap_wxGridTableBase_GetNumberRows, METH_VARARGS | METH_KEYWORDS },
14218          { "wxGridTableBase_GetView", (PyCFunction) _wrap_wxGridTableBase_GetView, METH_VARARGS | METH_KEYWORDS },
14219          { "wxGridTableBase_SetView", (PyCFunction) _wrap_wxGridTableBase_SetView, METH_VARARGS | METH_KEYWORDS },
14220          { "wxGridTableBase_GetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_GetAttrProvider, METH_VARARGS | METH_KEYWORDS },
14221          { "wxGridTableBase_SetAttrProvider", (PyCFunction) _wrap_wxGridTableBase_SetAttrProvider, METH_VARARGS | METH_KEYWORDS },
14222          { "wxPyGridCellAttrProvider_base_SetColAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14223          { "wxPyGridCellAttrProvider_base_SetRowAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14224          { "wxPyGridCellAttrProvider_base_SetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_SetAttr, METH_VARARGS | METH_KEYWORDS },
14225          { "wxPyGridCellAttrProvider_base_GetAttr", (PyCFunction) _wrap_wxPyGridCellAttrProvider_base_GetAttr, METH_VARARGS | METH_KEYWORDS },
14226          { "wxPyGridCellAttrProvider__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellAttrProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14227          { "new_wxPyGridCellAttrProvider", (PyCFunction) _wrap_new_wxPyGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
14228          { "wxGridCellAttrProvider_UpdateAttrCols", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrCols, METH_VARARGS | METH_KEYWORDS },
14229          { "wxGridCellAttrProvider_UpdateAttrRows", (PyCFunction) _wrap_wxGridCellAttrProvider_UpdateAttrRows, METH_VARARGS | METH_KEYWORDS },
14230          { "wxGridCellAttrProvider_SetColAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetColAttr, METH_VARARGS | METH_KEYWORDS },
14231          { "wxGridCellAttrProvider_SetRowAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetRowAttr, METH_VARARGS | METH_KEYWORDS },
14232          { "wxGridCellAttrProvider_SetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_SetAttr, METH_VARARGS | METH_KEYWORDS },
14233          { "wxGridCellAttrProvider_GetAttr", (PyCFunction) _wrap_wxGridCellAttrProvider_GetAttr, METH_VARARGS | METH_KEYWORDS },
14234          { "new_wxGridCellAttrProvider", (PyCFunction) _wrap_new_wxGridCellAttrProvider, METH_VARARGS | METH_KEYWORDS },
14235          { "wxGridCellAttr_SetDefAttr", (PyCFunction) _wrap_wxGridCellAttr_SetDefAttr, METH_VARARGS | METH_KEYWORDS },
14236          { "wxGridCellAttr_IsReadOnly", (PyCFunction) _wrap_wxGridCellAttr_IsReadOnly, METH_VARARGS | METH_KEYWORDS },
14237          { "wxGridCellAttr_GetEditor", (PyCFunction) _wrap_wxGridCellAttr_GetEditor, METH_VARARGS | METH_KEYWORDS },
14238          { "wxGridCellAttr_GetRenderer", (PyCFunction) _wrap_wxGridCellAttr_GetRenderer, METH_VARARGS | METH_KEYWORDS },
14239          { "wxGridCellAttr_GetAlignment", (PyCFunction) _wrap_wxGridCellAttr_GetAlignment, METH_VARARGS | METH_KEYWORDS },
14240          { "wxGridCellAttr_GetFont", (PyCFunction) _wrap_wxGridCellAttr_GetFont, METH_VARARGS | METH_KEYWORDS },
14241          { "wxGridCellAttr_GetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14242          { "wxGridCellAttr_GetTextColour", (PyCFunction) _wrap_wxGridCellAttr_GetTextColour, METH_VARARGS | METH_KEYWORDS },
14243          { "wxGridCellAttr_HasReadWriteMode", (PyCFunction) _wrap_wxGridCellAttr_HasReadWriteMode, METH_VARARGS | METH_KEYWORDS },
14244          { "wxGridCellAttr_HasEditor", (PyCFunction) _wrap_wxGridCellAttr_HasEditor, METH_VARARGS | METH_KEYWORDS },
14245          { "wxGridCellAttr_HasRenderer", (PyCFunction) _wrap_wxGridCellAttr_HasRenderer, METH_VARARGS | METH_KEYWORDS },
14246          { "wxGridCellAttr_HasAlignment", (PyCFunction) _wrap_wxGridCellAttr_HasAlignment, METH_VARARGS | METH_KEYWORDS },
14247          { "wxGridCellAttr_HasFont", (PyCFunction) _wrap_wxGridCellAttr_HasFont, METH_VARARGS | METH_KEYWORDS },
14248          { "wxGridCellAttr_HasBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_HasBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14249          { "wxGridCellAttr_HasTextColour", (PyCFunction) _wrap_wxGridCellAttr_HasTextColour, METH_VARARGS | METH_KEYWORDS },
14250          { "wxGridCellAttr_SetKind", (PyCFunction) _wrap_wxGridCellAttr_SetKind, METH_VARARGS | METH_KEYWORDS },
14251          { "wxGridCellAttr_SetEditor", (PyCFunction) _wrap_wxGridCellAttr_SetEditor, METH_VARARGS | METH_KEYWORDS },
14252          { "wxGridCellAttr_SetRenderer", (PyCFunction) _wrap_wxGridCellAttr_SetRenderer, METH_VARARGS | METH_KEYWORDS },
14253          { "wxGridCellAttr_SetReadOnly", (PyCFunction) _wrap_wxGridCellAttr_SetReadOnly, METH_VARARGS | METH_KEYWORDS },
14254          { "wxGridCellAttr_SetAlignment", (PyCFunction) _wrap_wxGridCellAttr_SetAlignment, METH_VARARGS | METH_KEYWORDS },
14255          { "wxGridCellAttr_SetFont", (PyCFunction) _wrap_wxGridCellAttr_SetFont, METH_VARARGS | METH_KEYWORDS },
14256          { "wxGridCellAttr_SetBackgroundColour", (PyCFunction) _wrap_wxGridCellAttr_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS },
14257          { "wxGridCellAttr_SetTextColour", (PyCFunction) _wrap_wxGridCellAttr_SetTextColour, METH_VARARGS | METH_KEYWORDS },
14258          { "wxGridCellAttr_DecRef", (PyCFunction) _wrap_wxGridCellAttr_DecRef, METH_VARARGS | METH_KEYWORDS },
14259          { "wxGridCellAttr_IncRef", (PyCFunction) _wrap_wxGridCellAttr_IncRef, METH_VARARGS | METH_KEYWORDS },
14260          { "wxGridCellAttr_MergeWith", (PyCFunction) _wrap_wxGridCellAttr_MergeWith, METH_VARARGS | METH_KEYWORDS },
14261          { "wxGridCellAttr_Clone", (PyCFunction) _wrap_wxGridCellAttr_Clone, METH_VARARGS | METH_KEYWORDS },
14262          { "new_wxGridCellAttr", (PyCFunction) _wrap_new_wxGridCellAttr, METH_VARARGS | METH_KEYWORDS },
14263          { "new_wxGridCellAutoWrapStringEditor", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringEditor, METH_VARARGS | METH_KEYWORDS },
14264          { "new_wxGridCellEnumEditor", (PyCFunction) _wrap_new_wxGridCellEnumEditor, METH_VARARGS | METH_KEYWORDS },
14265          { "new_wxGridCellChoiceEditor", (PyCFunction) _wrap_new_wxGridCellChoiceEditor, METH_VARARGS | METH_KEYWORDS },
14266          { "new_wxGridCellBoolEditor", (PyCFunction) _wrap_new_wxGridCellBoolEditor, METH_VARARGS | METH_KEYWORDS },
14267          { "new_wxGridCellFloatEditor", (PyCFunction) _wrap_new_wxGridCellFloatEditor, METH_VARARGS | METH_KEYWORDS },
14268          { "new_wxGridCellNumberEditor", (PyCFunction) _wrap_new_wxGridCellNumberEditor, METH_VARARGS | METH_KEYWORDS },
14269          { "new_wxGridCellTextEditor", (PyCFunction) _wrap_new_wxGridCellTextEditor, METH_VARARGS | METH_KEYWORDS },
14270          { "wxPyGridCellEditor_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
14271          { "wxPyGridCellEditor_base_Destroy", (PyCFunction) _wrap_wxPyGridCellEditor_base_Destroy, METH_VARARGS | METH_KEYWORDS },
14272          { "wxPyGridCellEditor_base_HandleReturn", (PyCFunction) _wrap_wxPyGridCellEditor_base_HandleReturn, METH_VARARGS | METH_KEYWORDS },
14273          { "wxPyGridCellEditor_base_StartingClick", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingClick, METH_VARARGS | METH_KEYWORDS },
14274          { "wxPyGridCellEditor_base_StartingKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_StartingKey, METH_VARARGS | METH_KEYWORDS },
14275          { "wxPyGridCellEditor_base_IsAcceptedKey", (PyCFunction) _wrap_wxPyGridCellEditor_base_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
14276          { "wxPyGridCellEditor_base_PaintBackground", (PyCFunction) _wrap_wxPyGridCellEditor_base_PaintBackground, METH_VARARGS | METH_KEYWORDS },
14277          { "wxPyGridCellEditor_base_Show", (PyCFunction) _wrap_wxPyGridCellEditor_base_Show, METH_VARARGS | METH_KEYWORDS },
14278          { "wxPyGridCellEditor_base_SetSize", (PyCFunction) _wrap_wxPyGridCellEditor_base_SetSize, METH_VARARGS | METH_KEYWORDS },
14279          { "wxPyGridCellEditor__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellEditor__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14280          { "new_wxPyGridCellEditor", (PyCFunction) _wrap_new_wxPyGridCellEditor, METH_VARARGS | METH_KEYWORDS },
14281          { "wxGridCellEditor_Destroy", (PyCFunction) _wrap_wxGridCellEditor_Destroy, METH_VARARGS | METH_KEYWORDS },
14282          { "wxGridCellEditor_HandleReturn", (PyCFunction) _wrap_wxGridCellEditor_HandleReturn, METH_VARARGS | METH_KEYWORDS },
14283          { "wxGridCellEditor_StartingClick", (PyCFunction) _wrap_wxGridCellEditor_StartingClick, METH_VARARGS | METH_KEYWORDS },
14284          { "wxGridCellEditor_StartingKey", (PyCFunction) _wrap_wxGridCellEditor_StartingKey, METH_VARARGS | METH_KEYWORDS },
14285          { "wxGridCellEditor_IsAcceptedKey", (PyCFunction) _wrap_wxGridCellEditor_IsAcceptedKey, METH_VARARGS | METH_KEYWORDS },
14286          { "wxGridCellEditor_PaintBackground", (PyCFunction) _wrap_wxGridCellEditor_PaintBackground, METH_VARARGS | METH_KEYWORDS },
14287          { "wxGridCellEditor_Show", (PyCFunction) _wrap_wxGridCellEditor_Show, METH_VARARGS | METH_KEYWORDS },
14288          { "wxGridCellEditor_SetSize", (PyCFunction) _wrap_wxGridCellEditor_SetSize, METH_VARARGS | METH_KEYWORDS },
14289          { "wxGridCellEditor_Clone", (PyCFunction) _wrap_wxGridCellEditor_Clone, METH_VARARGS | METH_KEYWORDS },
14290          { "wxGridCellEditor_Reset", (PyCFunction) _wrap_wxGridCellEditor_Reset, METH_VARARGS | METH_KEYWORDS },
14291          { "wxGridCellEditor_EndEdit", (PyCFunction) _wrap_wxGridCellEditor_EndEdit, METH_VARARGS | METH_KEYWORDS },
14292          { "wxGridCellEditor_BeginEdit", (PyCFunction) _wrap_wxGridCellEditor_BeginEdit, METH_VARARGS | METH_KEYWORDS },
14293          { "wxGridCellEditor_Create", (PyCFunction) _wrap_wxGridCellEditor_Create, METH_VARARGS | METH_KEYWORDS },
14294          { "wxGridCellEditor_DecRef", (PyCFunction) _wrap_wxGridCellEditor_DecRef, METH_VARARGS | METH_KEYWORDS },
14295          { "wxGridCellEditor_IncRef", (PyCFunction) _wrap_wxGridCellEditor_IncRef, METH_VARARGS | METH_KEYWORDS },
14296          { "wxGridCellEditor_SetParameters", (PyCFunction) _wrap_wxGridCellEditor_SetParameters, METH_VARARGS | METH_KEYWORDS },
14297          { "wxGridCellEditor_SetControl", (PyCFunction) _wrap_wxGridCellEditor_SetControl, METH_VARARGS | METH_KEYWORDS },
14298          { "wxGridCellEditor_GetControl", (PyCFunction) _wrap_wxGridCellEditor_GetControl, METH_VARARGS | METH_KEYWORDS },
14299          { "wxGridCellEditor_IsCreated", (PyCFunction) _wrap_wxGridCellEditor_IsCreated, METH_VARARGS | METH_KEYWORDS },
14300          { "new_wxGridCellAutoWrapStringRenderer", (PyCFunction) _wrap_new_wxGridCellAutoWrapStringRenderer, METH_VARARGS | METH_KEYWORDS },
14301          { "new_wxGridCellEnumRenderer", (PyCFunction) _wrap_new_wxGridCellEnumRenderer, METH_VARARGS | METH_KEYWORDS },
14302          { "new_wxGridCellDateTimeRenderer", (PyCFunction) _wrap_new_wxGridCellDateTimeRenderer, METH_VARARGS | METH_KEYWORDS },
14303          { "new_wxGridCellBoolRenderer", (PyCFunction) _wrap_new_wxGridCellBoolRenderer, METH_VARARGS | METH_KEYWORDS },
14304          { "wxGridCellFloatRenderer_SetPrecision", (PyCFunction) _wrap_wxGridCellFloatRenderer_SetPrecision, METH_VARARGS | METH_KEYWORDS },
14305          { "wxGridCellFloatRenderer_GetPrecision", (PyCFunction) _wrap_wxGridCellFloatRenderer_GetPrecision, METH_VARARGS | METH_KEYWORDS },
14306          { "wxGridCellFloatRenderer_SetWidth", (PyCFunction) _wrap_wxGridCellFloatRenderer_SetWidth, METH_VARARGS | METH_KEYWORDS },
14307          { "wxGridCellFloatRenderer_GetWidth", (PyCFunction) _wrap_wxGridCellFloatRenderer_GetWidth, METH_VARARGS | METH_KEYWORDS },
14308          { "new_wxGridCellFloatRenderer", (PyCFunction) _wrap_new_wxGridCellFloatRenderer, METH_VARARGS | METH_KEYWORDS },
14309          { "new_wxGridCellNumberRenderer", (PyCFunction) _wrap_new_wxGridCellNumberRenderer, METH_VARARGS | METH_KEYWORDS },
14310          { "new_wxGridCellStringRenderer", (PyCFunction) _wrap_new_wxGridCellStringRenderer, METH_VARARGS | METH_KEYWORDS },
14311          { "wxPyGridCellRenderer_base_SetParameters", (PyCFunction) _wrap_wxPyGridCellRenderer_base_SetParameters, METH_VARARGS | METH_KEYWORDS },
14312          { "wxPyGridCellRenderer__setCallbackInfo", (PyCFunction) _wrap_wxPyGridCellRenderer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
14313          { "new_wxPyGridCellRenderer", (PyCFunction) _wrap_new_wxPyGridCellRenderer, METH_VARARGS | METH_KEYWORDS },
14314          { "wxGridCellRenderer_Clone", (PyCFunction) _wrap_wxGridCellRenderer_Clone, METH_VARARGS | METH_KEYWORDS },
14315          { "wxGridCellRenderer_GetBestSize", (PyCFunction) _wrap_wxGridCellRenderer_GetBestSize, METH_VARARGS | METH_KEYWORDS },
14316          { "wxGridCellRenderer_Draw", (PyCFunction) _wrap_wxGridCellRenderer_Draw, METH_VARARGS | METH_KEYWORDS },
14317          { "wxGridCellRenderer_DecRef", (PyCFunction) _wrap_wxGridCellRenderer_DecRef, METH_VARARGS | METH_KEYWORDS },
14318          { "wxGridCellRenderer_IncRef", (PyCFunction) _wrap_wxGridCellRenderer_IncRef, METH_VARARGS | METH_KEYWORDS },
14319          { "wxGridCellRenderer_SetParameters", (PyCFunction) _wrap_wxGridCellRenderer_SetParameters, METH_VARARGS | METH_KEYWORDS },
14320          { NULL, NULL }
14321 };
14322 #ifdef __cplusplus
14323 }
14324 #endif
14325 /*
14326  * This table is used by the pointer type-checker
14327  */
14328 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
14329     { "_wxEvent","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxEvent},
14330     { "_wxEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxEvent},
14331     { "_wxEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxEvent},
14332     { "_wxEvent","_wxGridEvent",SwigwxGridEventTowxEvent},
14333     { "_signed_long","_long",0},
14334     { "_wxGridCellChoiceEditor","_wxGridCellEnumEditor",SwigwxGridCellEnumEditorTowxGridCellChoiceEditor},
14335     { "_wxPrintQuality","_WXGRIDSELECTIONMODES",0},
14336     { "_wxPrintQuality","_wxCoord",0},
14337     { "_wxPrintQuality","_int",0},
14338     { "_wxPrintQuality","_signed_int",0},
14339     { "_wxPrintQuality","_unsigned_int",0},
14340     { "_wxPrintQuality","_wxWindowID",0},
14341     { "_wxPrintQuality","_uint",0},
14342     { "_wxPrintQuality","_EBool",0},
14343     { "_wxPrintQuality","_size_t",0},
14344     { "_wxPrintQuality","_time_t",0},
14345     { "_wxNotifyEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxNotifyEvent},
14346     { "_wxNotifyEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxNotifyEvent},
14347     { "_wxNotifyEvent","_wxGridEvent",SwigwxGridEventTowxNotifyEvent},
14348     { "_byte","_unsigned_char",0},
14349     { "_long","_unsigned_long",0},
14350     { "_long","_signed_long",0},
14351     { "_size_t","_WXGRIDSELECTIONMODES",0},
14352     { "_size_t","_wxCoord",0},
14353     { "_size_t","_wxPrintQuality",0},
14354     { "_size_t","_time_t",0},
14355     { "_size_t","_unsigned_int",0},
14356     { "_size_t","_int",0},
14357     { "_size_t","_wxWindowID",0},
14358     { "_size_t","_uint",0},
14359     { "_wxPanel","_wxGrid",SwigwxGridTowxPanel},
14360     { "_uint","_WXGRIDSELECTIONMODES",0},
14361     { "_uint","_wxCoord",0},
14362     { "_uint","_wxPrintQuality",0},
14363     { "_uint","_time_t",0},
14364     { "_uint","_size_t",0},
14365     { "_uint","_unsigned_int",0},
14366     { "_uint","_int",0},
14367     { "_uint","_wxWindowID",0},
14368     { "_wxChar","_char",0},
14369     { "_wxCommandEvent","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxCommandEvent},
14370     { "_wxCommandEvent","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxCommandEvent},
14371     { "_wxCommandEvent","_wxGridSizeEvent",SwigwxGridSizeEventTowxCommandEvent},
14372     { "_wxCommandEvent","_wxGridEvent",SwigwxGridEventTowxCommandEvent},
14373     { "_char","_wxChar",0},
14374     { "_wxGridCellStringRenderer","_wxGridCellAutoWrapStringRenderer",SwigwxGridCellAutoWrapStringRendererTowxGridCellStringRenderer},
14375     { "_wxGridCellStringRenderer","_wxGridCellEnumRenderer",SwigwxGridCellEnumRendererTowxGridCellStringRenderer},
14376     { "_wxGridCellStringRenderer","_wxGridCellDateTimeRenderer",SwigwxGridCellDateTimeRendererTowxGridCellStringRenderer},
14377     { "_wxGridCellStringRenderer","_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellStringRenderer},
14378     { "_wxGridCellStringRenderer","_wxGridCellNumberRenderer",SwigwxGridCellNumberRendererTowxGridCellStringRenderer},
14379     { "_struct_wxNativeFontInfo","_wxNativeFontInfo",0},
14380     { "_wxGridTableBase","_wxGridStringTable",SwigwxGridStringTableTowxGridTableBase},
14381     { "_wxGridTableBase","_wxPyGridTableBase",SwigwxPyGridTableBaseTowxGridTableBase},
14382     { "_EBool","_WXGRIDSELECTIONMODES",0},
14383     { "_EBool","_wxCoord",0},
14384     { "_EBool","_wxPrintQuality",0},
14385     { "_EBool","_signed_int",0},
14386     { "_EBool","_int",0},
14387     { "_EBool","_wxWindowID",0},
14388     { "_unsigned_long","_long",0},
14389     { "_WXGRIDSELECTIONMODES","_int",0},
14390     { "_WXGRIDSELECTIONMODES","_signed_int",0},
14391     { "_WXGRIDSELECTIONMODES","_unsigned_int",0},
14392     { "_WXGRIDSELECTIONMODES","_wxWindowID",0},
14393     { "_WXGRIDSELECTIONMODES","_uint",0},
14394     { "_WXGRIDSELECTIONMODES","_EBool",0},
14395     { "_WXGRIDSELECTIONMODES","_size_t",0},
14396     { "_WXGRIDSELECTIONMODES","_time_t",0},
14397     { "_WXGRIDSELECTIONMODES","_wxPrintQuality",0},
14398     { "_WXGRIDSELECTIONMODES","_wxCoord",0},
14399     { "_wxNativeFontInfo","_struct_wxNativeFontInfo",0},
14400     { "_signed_int","_WXGRIDSELECTIONMODES",0},
14401     { "_signed_int","_wxCoord",0},
14402     { "_signed_int","_wxPrintQuality",0},
14403     { "_signed_int","_EBool",0},
14404     { "_signed_int","_wxWindowID",0},
14405     { "_signed_int","_int",0},
14406     { "_wxGridCellEditor","_wxGridCellAutoWrapStringEditor",SwigwxGridCellAutoWrapStringEditorTowxGridCellEditor},
14407     { "_wxGridCellEditor","_wxGridCellEnumEditor",SwigwxGridCellEnumEditorTowxGridCellEditor},
14408     { "_wxGridCellEditor","_wxGridCellChoiceEditor",SwigwxGridCellChoiceEditorTowxGridCellEditor},
14409     { "_wxGridCellEditor","_wxGridCellBoolEditor",SwigwxGridCellBoolEditorTowxGridCellEditor},
14410     { "_wxGridCellEditor","_wxGridCellFloatEditor",SwigwxGridCellFloatEditorTowxGridCellEditor},
14411     { "_wxGridCellEditor","_wxGridCellNumberEditor",SwigwxGridCellNumberEditorTowxGridCellEditor},
14412     { "_wxGridCellEditor","_wxGridCellTextEditor",SwigwxGridCellTextEditorTowxGridCellEditor},
14413     { "_wxGridCellEditor","_wxPyGridCellEditor",SwigwxPyGridCellEditorTowxGridCellEditor},
14414     { "_WXTYPE","_short",0},
14415     { "_WXTYPE","_signed_short",0},
14416     { "_WXTYPE","_unsigned_short",0},
14417     { "_wxGridCellAttrProvider","_wxPyGridCellAttrProvider",SwigwxPyGridCellAttrProviderTowxGridCellAttrProvider},
14418     { "_unsigned_short","_WXTYPE",0},
14419     { "_unsigned_short","_short",0},
14420     { "_wxObject","_wxGridEditorCreatedEvent",SwigwxGridEditorCreatedEventTowxObject},
14421     { "_wxObject","_wxGridRangeSelectEvent",SwigwxGridRangeSelectEventTowxObject},
14422     { "_wxObject","_wxGridSizeEvent",SwigwxGridSizeEventTowxObject},
14423     { "_wxObject","_wxGridEvent",SwigwxGridEventTowxObject},
14424     { "_wxObject","_wxGrid",SwigwxGridTowxObject},
14425     { "_wxObject","_wxGridStringTable",SwigwxGridStringTableTowxObject},
14426     { "_wxObject","_wxPyGridTableBase",SwigwxPyGridTableBaseTowxObject},
14427     { "_wxObject","_wxGridTableBase",SwigwxGridTableBaseTowxObject},
14428     { "_signed_short","_WXTYPE",0},
14429     { "_signed_short","_short",0},
14430     { "_wxScrolledWindow","_wxGrid",SwigwxGridTowxScrolledWindow},
14431     { "_unsigned_char","_byte",0},
14432     { "_unsigned_int","_WXGRIDSELECTIONMODES",0},
14433     { "_unsigned_int","_wxCoord",0},
14434     { "_unsigned_int","_wxPrintQuality",0},
14435     { "_unsigned_int","_time_t",0},
14436     { "_unsigned_int","_size_t",0},
14437     { "_unsigned_int","_uint",0},
14438     { "_unsigned_int","_wxWindowID",0},
14439     { "_unsigned_int","_int",0},
14440     { "_short","_WXTYPE",0},
14441     { "_short","_unsigned_short",0},
14442     { "_short","_signed_short",0},
14443     { "_wxWindowID","_WXGRIDSELECTIONMODES",0},
14444     { "_wxWindowID","_wxCoord",0},
14445     { "_wxWindowID","_wxPrintQuality",0},
14446     { "_wxWindowID","_time_t",0},
14447     { "_wxWindowID","_size_t",0},
14448     { "_wxWindowID","_EBool",0},
14449     { "_wxWindowID","_uint",0},
14450     { "_wxWindowID","_int",0},
14451     { "_wxWindowID","_signed_int",0},
14452     { "_wxWindowID","_unsigned_int",0},
14453     { "_int","_WXGRIDSELECTIONMODES",0},
14454     { "_int","_wxCoord",0},
14455     { "_int","_wxPrintQuality",0},
14456     { "_int","_time_t",0},
14457     { "_int","_size_t",0},
14458     { "_int","_EBool",0},
14459     { "_int","_uint",0},
14460     { "_int","_wxWindowID",0},
14461     { "_int","_unsigned_int",0},
14462     { "_int","_signed_int",0},
14463     { "_time_t","_WXGRIDSELECTIONMODES",0},
14464     { "_time_t","_wxCoord",0},
14465     { "_time_t","_wxPrintQuality",0},
14466     { "_time_t","_unsigned_int",0},
14467     { "_time_t","_int",0},
14468     { "_time_t","_wxWindowID",0},
14469     { "_time_t","_uint",0},
14470     { "_time_t","_size_t",0},
14471     { "_wxCoord","_WXGRIDSELECTIONMODES",0},
14472     { "_wxCoord","_int",0},
14473     { "_wxCoord","_signed_int",0},
14474     { "_wxCoord","_unsigned_int",0},
14475     { "_wxCoord","_wxWindowID",0},
14476     { "_wxCoord","_uint",0},
14477     { "_wxCoord","_EBool",0},
14478     { "_wxCoord","_size_t",0},
14479     { "_wxCoord","_time_t",0},
14480     { "_wxCoord","_wxPrintQuality",0},
14481     { "_wxGridCellRenderer","_wxGridCellAutoWrapStringRenderer",SwigwxGridCellAutoWrapStringRendererTowxGridCellRenderer},
14482     { "_wxGridCellRenderer","_wxGridCellEnumRenderer",SwigwxGridCellEnumRendererTowxGridCellRenderer},
14483     { "_wxGridCellRenderer","_wxGridCellDateTimeRenderer",SwigwxGridCellDateTimeRendererTowxGridCellRenderer},
14484     { "_wxGridCellRenderer","_wxGridCellBoolRenderer",SwigwxGridCellBoolRendererTowxGridCellRenderer},
14485     { "_wxGridCellRenderer","_wxGridCellFloatRenderer",SwigwxGridCellFloatRendererTowxGridCellRenderer},
14486     { "_wxGridCellRenderer","_wxGridCellNumberRenderer",SwigwxGridCellNumberRendererTowxGridCellRenderer},
14487     { "_wxGridCellRenderer","_wxGridCellStringRenderer",SwigwxGridCellStringRendererTowxGridCellRenderer},
14488     { "_wxGridCellRenderer","_wxPyGridCellRenderer",SwigwxPyGridCellRendererTowxGridCellRenderer},
14489     { "_wxGridCellTextEditor","_wxGridCellAutoWrapStringEditor",SwigwxGridCellAutoWrapStringEditorTowxGridCellTextEditor},
14490     { "_wxGridCellTextEditor","_wxGridCellFloatEditor",SwigwxGridCellFloatEditorTowxGridCellTextEditor},
14491     { "_wxGridCellTextEditor","_wxGridCellNumberEditor",SwigwxGridCellNumberEditorTowxGridCellTextEditor},
14492     { "_wxEvtHandler","_wxGrid",SwigwxGridTowxEvtHandler},
14493     { "_wxWindow","_wxGrid",SwigwxGridTowxWindow},
14494 {0,0,0}};
14495
14496 static PyObject *SWIG_globals;
14497 #ifdef __cplusplus
14498 extern "C"
14499 #endif
14500 SWIGEXPORT(void) initgridc() {
14501          PyObject *m, *d;
14502          SWIG_globals = SWIG_newvarlink();
14503          m = Py_InitModule("gridc", gridcMethods);
14504          d = PyModule_GetDict(m);
14505          PyDict_SetItemString(d,"wxGRID_VALUE_STRING", PyString_FromString("string"));
14506          PyDict_SetItemString(d,"wxGRID_VALUE_BOOL", PyString_FromString("bool"));
14507          PyDict_SetItemString(d,"wxGRID_VALUE_NUMBER", PyString_FromString("long"));
14508          PyDict_SetItemString(d,"wxGRID_VALUE_FLOAT", PyString_FromString("double"));
14509          PyDict_SetItemString(d,"wxGRID_VALUE_CHOICE", PyString_FromString("choice"));
14510          PyDict_SetItemString(d,"wxGRID_VALUE_TEXT", PyString_FromString("string"));
14511          PyDict_SetItemString(d,"wxGRID_VALUE_LONG", PyString_FromString("long"));
14512          PyDict_SetItemString(d,"cvar", SWIG_globals);
14513          SWIG_addvarlink(SWIG_globals,"wxGridNoCellCoords",_wrap_wxGridNoCellCoords_get, _wrap_wxGridNoCellCoords_set);
14514          SWIG_addvarlink(SWIG_globals,"wxGridNoCellRect",_wrap_wxGridNoCellRect_get, _wrap_wxGridNoCellRect_set);
14515          PyDict_SetItemString(d,"wxGRIDTABLE_REQUEST_VIEW_GET_VALUES", PyInt_FromLong((long) wxGRIDTABLE_REQUEST_VIEW_GET_VALUES));
14516          PyDict_SetItemString(d,"wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES", PyInt_FromLong((long) wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES));
14517          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_INSERTED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_INSERTED));
14518          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_APPENDED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_APPENDED));
14519          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_ROWS_DELETED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_ROWS_DELETED));
14520          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_INSERTED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_INSERTED));
14521          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_APPENDED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_APPENDED));
14522          PyDict_SetItemString(d,"wxGRIDTABLE_NOTIFY_COLS_DELETED", PyInt_FromLong((long) wxGRIDTABLE_NOTIFY_COLS_DELETED));
14523          PyDict_SetItemString(d,"wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_LEFT_CLICK));
14524          PyDict_SetItemString(d,"wxEVT_GRID_CELL_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_RIGHT_CLICK));
14525          PyDict_SetItemString(d,"wxEVT_GRID_CELL_LEFT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_LEFT_DCLICK));
14526          PyDict_SetItemString(d,"wxEVT_GRID_CELL_RIGHT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_CELL_RIGHT_DCLICK));
14527          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_LEFT_CLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_LEFT_CLICK));
14528          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_RIGHT_CLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_RIGHT_CLICK));
14529          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_LEFT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_LEFT_DCLICK));
14530          PyDict_SetItemString(d,"wxEVT_GRID_LABEL_RIGHT_DCLICK", PyInt_FromLong((long) wxEVT_GRID_LABEL_RIGHT_DCLICK));
14531          PyDict_SetItemString(d,"wxEVT_GRID_ROW_SIZE", PyInt_FromLong((long) wxEVT_GRID_ROW_SIZE));
14532          PyDict_SetItemString(d,"wxEVT_GRID_COL_SIZE", PyInt_FromLong((long) wxEVT_GRID_COL_SIZE));
14533          PyDict_SetItemString(d,"wxEVT_GRID_RANGE_SELECT", PyInt_FromLong((long) wxEVT_GRID_RANGE_SELECT));
14534          PyDict_SetItemString(d,"wxEVT_GRID_CELL_CHANGE", PyInt_FromLong((long) wxEVT_GRID_CELL_CHANGE));
14535          PyDict_SetItemString(d,"wxEVT_GRID_SELECT_CELL", PyInt_FromLong((long) wxEVT_GRID_SELECT_CELL));
14536          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_SHOWN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_SHOWN));
14537          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_HIDDEN", PyInt_FromLong((long) wxEVT_GRID_EDITOR_HIDDEN));
14538          PyDict_SetItemString(d,"wxEVT_GRID_EDITOR_CREATED", PyInt_FromLong((long) wxEVT_GRID_EDITOR_CREATED));
14539
14540     wxClassInfo::CleanUpClasses();
14541     wxClassInfo::InitializeClasses();
14542          PyDict_SetItemString(d,"wxGridCellAttr_Any", PyInt_FromLong((long) wxGridCellAttr::Any));
14543          PyDict_SetItemString(d,"wxGridCellAttr_Default", PyInt_FromLong((long) wxGridCellAttr::Default));
14544          PyDict_SetItemString(d,"wxGridCellAttr_Cell", PyInt_FromLong((long) wxGridCellAttr::Cell));
14545          PyDict_SetItemString(d,"wxGridCellAttr_Row", PyInt_FromLong((long) wxGridCellAttr::Row));
14546          PyDict_SetItemString(d,"wxGridCellAttr_Col", PyInt_FromLong((long) wxGridCellAttr::Col));
14547          PyDict_SetItemString(d,"wxGridCellAttr_Merged", PyInt_FromLong((long) wxGridCellAttr::Merged));
14548          PyDict_SetItemString(d,"wxGrid_wxGridSelectCells", PyInt_FromLong((long) wxGrid::wxGridSelectCells));
14549          PyDict_SetItemString(d,"wxGrid_wxGridSelectRows", PyInt_FromLong((long) wxGrid::wxGridSelectRows));
14550          PyDict_SetItemString(d,"wxGrid_wxGridSelectColumns", PyInt_FromLong((long) wxGrid::wxGridSelectColumns));
14551 {
14552    int i;
14553    for (i = 0; _swig_mapping[i].n1; i++)
14554         SWIG_RegisterMapping(_swig_mapping[i].n1,_swig_mapping[i].n2,_swig_mapping[i].pcnv);
14555 }
14556 }