wxPython/src/grid.i

   1 ////////////////////////////////////////////////////////////////////////////
   2 // Name:        grid.i
   3 // Purpose:     SWIG definitions for the new wxGrid and related classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     17-March-2000
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2000 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 %define DOCSTRING
  14 "Classes for implementing a spreadsheet-like control."
  15 %enddef
  16
  17 %module(package="wx", docstring=DOCSTRING) grid
  18
  19
  20 %{
  21 #include "wx/wxPython/wxPython.h"
  22 #include "wx/wxPython/pyclasses.h"
  23 #include "wx/wxPython/printfw.h"
  24
  25 #include <wx/grid.h>
  26 #include <wx/generic/gridctrl.h>
  27
  28 %}
  29
  30
  31 //---------------------------------------------------------------------------
  32
  33 %import windows.i
  34 %pythoncode { wx = _core }
  35 %pythoncode { __docfilter__ = wx.__DocFilter(globals()) }
  36
  37
  38 MAKE_CONST_WXSTRING_NOSWIG(EmptyString);
  39 MAKE_CONST_WXSTRING_NOSWIG(GridNameStr);
  40 MAKE_CONST_WXSTRING_NOSWIG(DefaultDateTimeFormat);
  41
  42 //---------------------------------------------------------------------------
  43 // OOR related typemaps and helper functions
  44
  45 %typemap(out) wxGridCellRenderer*     { $result = wxPyMake_wxGridCellRenderer($1, (bool)$owner); }
  46 %typemap(out) wxGridCellEditor*       { $result = wxPyMake_wxGridCellEditor($1,   (bool)$owner); }
  47 %typemap(out) wxGridCellAttr*         { $result = wxPyMake_wxGridCellAttr($1,     (bool)$owner); }
  48 %typemap(out) wxGridCellAttrProvider* { $result = wxPyMake_wxGridCellAttrProvider($1, (bool)$owner); }
  49 %typemap(out) wxGridTableBase*        { $result = wxPyMake_wxGridTableBase($1,    (bool)$owner); }
  50
  51
  52 %{
  53
  54 #define wxPyMake_TEMPLATE(TYPE) \
  55 PyObject* wxPyMake_##TYPE(TYPE* source, bool setThisOwn) { \
  56     PyObject* target = NULL; \
  57     if (source) { \
  58         /* Check if there is already a pointer to a Python object in the \
  59            OOR data that we can use. */ \
  60         wxPyOORClientData* data = (wxPyOORClientData*)source->GetClientObject(); \
  61         if (data) { \
  62             target = data->m_obj; \
  63             if (target) \
  64                 Py_INCREF(target); \
  65         } \
  66         /* Otherwise make a new wrapper for it the old fashioned way and \
  67            give it the OOR treatment */ \
  68         if (! target) { \
  69             target = wxPyConstructObject(source, wxT(#TYPE), setThisOwn); \
  70             if (target) \
  71                 source->SetClientObject(new wxPyOORClientData(target)); \
  72         } \
  73     } else {  /* source was NULL so return None. */ \
  74         Py_INCREF(Py_None); target = Py_None; \
  75     } \
  76     return target; \
  77 } \
  78
  79
  80 wxPyMake_TEMPLATE(wxGridCellRenderer)
  81 wxPyMake_TEMPLATE(wxGridCellEditor)
  82 wxPyMake_TEMPLATE(wxGridCellAttr)
  83 wxPyMake_TEMPLATE(wxGridCellAttrProvider)
  84 wxPyMake_TEMPLATE(wxGridTableBase)
  85
  86 %}
  87
  88 //---------------------------------------------------------------------------
  89 // Macros, similar to what's in helpers.h, to aid in the creation of
  90 // virtual methods that are able to make callbacks to Python.  Many of these
  91 // are specific to wxGrid and so are kept here to reduce the mess in helpers.h
  92 // a bit.
  93
  94
  95 %{
  96 #define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME)                               \
  97     wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) {        \
  98         wxGridCellAttr* rval = NULL;                                            \
  99         bool found;                                                             \
 100         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 101         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 102             PyObject* ro;                                                       \
 103             wxGridCellAttr* ptr;                                                \
 104             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
 105             if (ro) {                                                           \
 106                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellAttr"))) \
 107                     rval = ptr;                                                 \
 108                 Py_DECREF(ro);                                                  \
 109             }                                                                   \
 110         }                                                                       \
 111         wxPyEndBlockThreads(blocked);                                           \
 112         if (! found)                                                            \
 113             rval = PCLASS::CBNAME(a, b, c);                                     \
 114         return rval;                                                            \
 115     }
 116
 117
 118 #define PYCALLBACK__GCAINTINT(PCLASS, CBNAME)                                   \
 119     void CBNAME(wxGridCellAttr *attr, int a, int b) {                           \
 120         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 121         bool found;                                                             \
 122         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 123             PyObject* obj = wxPyMake_wxGridCellAttr(attr,false);                \
 124             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b));  \
 125             Py_DECREF(obj);                                                     \
 126         }                                                                       \
 127         wxPyEndBlockThreads(blocked);                                           \
 128         if (! found)                                                            \
 129             PCLASS::CBNAME(attr, a, b);                                         \
 130     }
 131
 132
 133
 134 #define PYCALLBACK__GCAINT(PCLASS, CBNAME)                                      \
 135     void CBNAME(wxGridCellAttr *attr, int val) {                                \
 136         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 137         bool found;                                                             \
 138         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 139             PyObject* obj = wxPyMake_wxGridCellAttr(attr,false);                \
 140             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val));    \
 141             Py_DECREF(obj);                                                     \
 142         }                                                                       \
 143         wxPyEndBlockThreads(blocked);                                           \
 144         if (! found)                                                            \
 145             PCLASS::CBNAME(attr, val);                                          \
 146     }
 147
 148
 149
 150 #define PYCALLBACK_INT__pure(CBNAME)                                            \
 151     int  CBNAME() {                                                             \
 152         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 153         int rval = 0;                                                           \
 154         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 155             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
 156         wxPyEndBlockThreads(blocked);                                           \
 157         return rval;                                                            \
 158     }
 159
 160
 161
 162 #define PYCALLBACK_BOOL_INTINT_pure(CBNAME)                                     \
 163     bool CBNAME(int a, int b) {                                                 \
 164         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 165         bool rval = 0;                                                          \
 166         if (wxPyCBH_findCallback(m_myInst, #CBNAME))                            \
 167             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b));   \
 168         wxPyEndBlockThreads(blocked);                                           \
 169         return rval;                                                            \
 170     }
 171
 172
 173 #define PYCALLBACK_STRING_INTINT_pure(CBNAME)                                   \
 174     wxString CBNAME(int a, int b) {                                             \
 175         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 176         wxString rval;                                                          \
 177         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 178             PyObject* ro;                                                       \
 179             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 180             if (ro) {                                                           \
 181                 rval = Py2wxString(ro);                                         \
 182                 Py_DECREF(ro);                                                  \
 183             }                                                                   \
 184         }                                                                       \
 185         wxPyEndBlockThreads(blocked);                                           \
 186         return rval;                                                            \
 187     }
 188
 189
 190 #define PYCALLBACK__INTINTSTRING_pure(CBNAME)                                   \
 191     void CBNAME(int a, int b, const wxString& c) {                              \
 192         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 193         if (wxPyCBH_findCallback(m_myInst, #CBNAME)) {                          \
 194             PyObject* s = wx2PyString(c);                                       \
 195             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
 196             Py_DECREF(s);                                                       \
 197         }                                                                       \
 198         wxPyEndBlockThreads(blocked);                                           \
 199     }
 200
 201
 202 #define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME)                                \
 203     wxString CBNAME(int a, int b) {                                             \
 204         bool found;                                                             \
 205         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 206         wxString rval;                                                          \
 207         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 208             PyObject* ro;                                                       \
 209             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 210             if (ro) {                                                           \
 211                 rval = Py2wxString(ro);                                         \
 212                 Py_DECREF(ro);                                                  \
 213             }                                                                   \
 214         }                                                                       \
 215         wxPyEndBlockThreads(blocked);                                           \
 216         if (! found)                                                            \
 217             rval = PCLASS::CBNAME(a, b);                                        \
 218         return rval;                                                            \
 219     }
 220
 221
 222 #define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME)                            \
 223     bool CBNAME(int a, int b, const wxString& c)  {                             \
 224         bool rval = 0;                                                          \
 225         bool found;                                                             \
 226         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 227         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 228             PyObject* s = wx2PyString(c);                                       \
 229             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",a,b,s));\
 230             Py_DECREF(s);                                                       \
 231         }                                                                       \
 232         wxPyEndBlockThreads(blocked);                                           \
 233         if (! found)                                                            \
 234             rval = PCLASS::CBNAME(a,b,c);                                       \
 235         return rval;                                                            \
 236     }
 237
 238
 239
 240
 241 #define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME)                                  \
 242     long CBNAME(int a, int b)  {                                                \
 243         long rval;                                                              \
 244         bool found;                                                             \
 245         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 246         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 247             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 248         wxPyEndBlockThreads(blocked);                                           \
 249         if (! found)                                                            \
 250             rval = PCLASS::CBNAME(a,b);                                         \
 251         return rval;                                                            \
 252     }
 253
 254
 255 #define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME)                                  \
 256     bool CBNAME(int a, int b)  {                                                \
 257         bool rval = 0;                                                          \
 258         bool found;                                                             \
 259         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 260         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 261             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 262         wxPyEndBlockThreads(blocked);                                           \
 263         if (! found)                                                            \
 264             rval = PCLASS::CBNAME(a,b);                                         \
 265         return rval;                                                            \
 266     }
 267
 268
 269
 270 #define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME)                                \
 271     double CBNAME(int a, int b) {                                               \
 272         bool found;                                                             \
 273         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 274         double rval;                                                            \
 275         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 276             PyObject* ro;                                                       \
 277             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b));  \
 278             if (ro) {                                                           \
 279                 PyObject* str = PyObject_Str(ro);                               \
 280                 rval = PyFloat_AsDouble(str);                                   \
 281                 Py_DECREF(ro);   Py_DECREF(str);                                \
 282             }                                                                   \
 283         }                                                                       \
 284         wxPyEndBlockThreads(blocked);                                           \
 285         if (! found)                                                            \
 286             rval = PCLASS::CBNAME(a, b);                                        \
 287         return rval;                                                            \
 288     }
 289
 290
 291
 292 #define PYCALLBACK__(PCLASS, CBNAME)                                            \
 293     void CBNAME()  {                                                            \
 294         bool found;                                                             \
 295         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 296         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 297             wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));                \
 298         wxPyEndBlockThreads(blocked);                                           \
 299         if (! found)                                                            \
 300             PCLASS::CBNAME();                                                   \
 301     }
 302
 303
 304
 305 #define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME)                              \
 306     bool CBNAME(size_t a, size_t b)  {                                          \
 307         bool rval = 0;                                                          \
 308         bool found;                                                             \
 309         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 310         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 311             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));  \
 312         wxPyEndBlockThreads(blocked);                                           \
 313         if (! found)                                                            \
 314             rval = PCLASS::CBNAME(a,b);                                         \
 315         return rval;                                                            \
 316     }
 317
 318
 319
 320 #define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME)                                   \
 321     bool CBNAME(size_t a)  {                                                    \
 322         bool rval = 0;                                                          \
 323         bool found;                                                             \
 324         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 325         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 326             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a));     \
 327         wxPyEndBlockThreads(blocked);                                           \
 328         if (! found)                                                            \
 329             rval = PCLASS::CBNAME(a);                                           \
 330         return rval;                                                            \
 331     }
 332
 333
 334 #define PYCALLBACK_STRING_INT(PCLASS, CBNAME)                                   \
 335     wxString CBNAME(int a) {                                                    \
 336         bool found;                                                             \
 337         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 338         wxString rval;                                                          \
 339         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 340             PyObject* ro;                                                       \
 341             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a));     \
 342             if (ro) {                                                           \
 343                 rval = Py2wxString(ro);                                         \
 344                 Py_DECREF(ro);                                                  \
 345             }                                                                   \
 346         }                                                                       \
 347         wxPyEndBlockThreads(blocked);                                           \
 348         if (! found)                                                            \
 349             rval = PCLASS::CBNAME(a);                                           \
 350         return rval;                                                            \
 351     }
 352
 353
 354 #define PYCALLBACK__INTSTRING(PCLASS, CBNAME)                                   \
 355     void CBNAME(int a, const wxString& c)  {                                    \
 356         bool found;                                                             \
 357         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 358         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME))) {                \
 359             PyObject* s = wx2PyString(c);                                       \
 360             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)",a,s));          \
 361             Py_DECREF(s);                                                       \
 362         }                                                                       \
 363         wxPyEndBlockThreads(blocked);                                           \
 364         if (! found)                                                            \
 365             PCLASS::CBNAME(a,c);                                                \
 366     }
 367
 368
 369
 370
 371 #define PYCALLBACK_BOOL_(PCLASS, CBNAME)                                        \
 372     bool CBNAME()  {                                                            \
 373         bool rval = 0;                                                          \
 374         bool found;                                                             \
 375         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 376         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 377             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));         \
 378         wxPyEndBlockThreads(blocked);                                           \
 379         if (! found)                                                            \
 380             rval = PCLASS::CBNAME();                                            \
 381         return rval;                                                            \
 382     }
 383
 384
 385
 386 #define PYCALLBACK__SIZETINT(PCLASS, CBNAME)                                    \
 387     void CBNAME(size_t a, int b)  {                                             \
 388         bool found;                                                             \
 389         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 390         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 391             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b));         \
 392         wxPyEndBlockThreads(blocked);                                           \
 393         if (! found)                                                            \
 394             PCLASS::CBNAME(a,b);                                                \
 395     }
 396
 397
 398
 399
 400 #define PYCALLBACK__INTINTLONG(PCLASS, CBNAME)                                  \
 401     void CBNAME(int a, int b, long c)  {                                        \
 402         bool found;                                                             \
 403         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 404         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 405             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
 406         wxPyEndBlockThreads(blocked);                                           \
 407         if (! found)                                                            \
 408             PCLASS::CBNAME(a,b,c);                                              \
 409     }
 410
 411
 412
 413
 414 #define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME)                                \
 415     void CBNAME(int a, int b, double c)  {                                      \
 416         bool found;                                                             \
 417         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 418         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 419             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c));      \
 420         wxPyEndBlockThreads(blocked);                                           \
 421         if (! found)                                                            \
 422             PCLASS::CBNAME(a,b,c);                                              \
 423     }
 424
 425
 426
 427 #define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME)                                  \
 428     void CBNAME(int a, int b, bool c)  {                                        \
 429         bool found;                                                             \
 430         wxPyBlock_t blocked = wxPyBeginBlockThreads();                          \
 431         if ((found = wxPyCBH_findCallback(m_myInst, #CBNAME)))                  \
 432             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c));      \
 433         wxPyEndBlockThreads(blocked);                                           \
 434         if (! found)                                                            \
 435             PCLASS::CBNAME(a,b,c);                                              \
 436     }
 437
 438
 439
 440 %}
 441
 442 //---------------------------------------------------------------------------
 443
 444 class wxGridCellCoords;
 445 class wxGridCellAttr;
 446
 447 #define wxGRID_VALUE_STRING     "string"
 448 #define wxGRID_VALUE_BOOL       "bool"
 449 #define wxGRID_VALUE_NUMBER     "long"
 450 #define wxGRID_VALUE_FLOAT      "double"
 451 #define wxGRID_VALUE_CHOICE     "choice"
 452 #define wxGRID_VALUE_TEXT       "string"
 453 #define wxGRID_VALUE_LONG       "long"
 454 #define wxGRID_VALUE_CHOICEINT  "choiceint"
 455 #define wxGRID_VALUE_DATETIME   "datetime"
 456
 457
 458 %immutable;
 459 const wxGridCellCoords wxGridNoCellCoords;
 460 const wxRect           wxGridNoCellRect;
 461 %mutable;
 462
 463
 464 %{
 465 #define wxGRID_DEFAULT_NUMBER_ROWS        WXGRID_DEFAULT_NUMBER_ROWS
 466 #define wxGRID_DEFAULT_NUMBER_COLS        WXGRID_DEFAULT_NUMBER_COLS
 467 #define wxGRID_DEFAULT_ROW_HEIGHT         WXGRID_DEFAULT_ROW_HEIGHT
 468 #define wxGRID_DEFAULT_COL_WIDTH          WXGRID_DEFAULT_COL_WIDTH
 469 #define wxGRID_DEFAULT_COL_LABEL_HEIGHT   WXGRID_DEFAULT_COL_LABEL_HEIGHT
 470 #define wxGRID_DEFAULT_ROW_LABEL_WIDTH    WXGRID_DEFAULT_ROW_LABEL_WIDTH
 471 #define wxGRID_LABEL_EDGE_ZONE            WXGRID_LABEL_EDGE_ZONE
 472 #define wxGRID_MIN_ROW_HEIGHT             WXGRID_MIN_ROW_HEIGHT
 473 #define wxGRID_MIN_COL_WIDTH              WXGRID_MIN_COL_WIDTH
 474 #define wxGRID_DEFAULT_SCROLLBAR_WIDTH    WXGRID_DEFAULT_SCROLLBAR_WIDTH
 475 %}
 476
 477 enum {
 478     wxGRID_DEFAULT_NUMBER_ROWS,
 479     wxGRID_DEFAULT_NUMBER_COLS,
 480     wxGRID_DEFAULT_ROW_HEIGHT,
 481     wxGRID_DEFAULT_COL_WIDTH,
 482     wxGRID_DEFAULT_COL_LABEL_HEIGHT,
 483     wxGRID_DEFAULT_ROW_LABEL_WIDTH,
 484     wxGRID_LABEL_EDGE_ZONE,
 485     wxGRID_MIN_ROW_HEIGHT,
 486     wxGRID_MIN_COL_WIDTH,
 487     wxGRID_DEFAULT_SCROLLBAR_WIDTH
 488 };
 489
 490
 491 //---------------------------------------------------------------------------
 492
 493 // TODO: Use these to have SWIG automatically handle the IncRef/DecRef calls:
 494 //
 495 //        %ref   wxGridCellWorker "$this->IncRef();";
 496 //        %unref wxGridCellWorker "$this->DecRef();";
 497 //
 498
 499 class  wxGridCellWorker
 500 {
 501 public:
 502     %extend {
 503         void _setOORInfo(PyObject* _self) {
 504             if (!self->GetClientObject())
 505                 self->SetClientObject(new wxPyOORClientData(_self));
 506         }
 507
 508         // A dummy dtor to shut up SWIG.  (The real one is protected and can
 509         // only be called by DecRef)
 510         ~wxGridCellWorker() {
 511         }
 512     }
 513
 514     void SetParameters(const wxString& params);
 515     void IncRef();
 516     void DecRef();
 517 };
 518
 519
 520
 521 // wxGridCellRenderer is an ABC, and several derived classes are available.
 522 // Classes implemented in Python should be derived from wxPyGridCellRenderer.
 523
 524 class wxGridCellRenderer : public wxGridCellWorker
 525 {
 526 public:
 527     virtual void Draw(wxGrid& grid,
 528                       wxGridCellAttr& attr,
 529                       wxDC& dc,
 530                       const wxRect& rect,
 531                       int row, int col,
 532                       bool isSelected);
 533
 534     virtual wxSize GetBestSize(wxGrid& grid,
 535                                wxGridCellAttr& attr,
 536                                wxDC& dc,
 537                                int row, int col);
 538
 539     virtual wxGridCellRenderer *Clone() const;
 540 };
 541
 542
 543
 544 // The C++ version of wxPyGridCellRenderer
 545 %{
 546 class wxPyGridCellRenderer : public wxGridCellRenderer
 547 {
 548 public:
 549     wxPyGridCellRenderer() : wxGridCellRenderer() {};
 550
 551     // Implement Python callback aware virtual methods
 552     void Draw(wxGrid& grid, wxGridCellAttr& attr,
 553               wxDC& dc, const wxRect& rect,
 554               int row, int col, bool isSelected) {
 555         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 556         if (wxPyCBH_findCallback(m_myInst, "Draw")) {
 557             PyObject* go = wxPyMake_wxObject(&grid,false);
 558             PyObject* dco = wxPyMake_wxObject(&dc,false);
 559             PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
 560             PyObject* ro = wxPyConstructObject((void*)&rect, wxT("wxRect"), 0);
 561
 562             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOOOiii)", go, ao, dco, ro,
 563                                                          row, col, isSelected));
 564             Py_DECREF(go);
 565             Py_DECREF(ao);
 566             Py_DECREF(dco);
 567             Py_DECREF(ro);
 568         }
 569         wxPyEndBlockThreads(blocked);
 570     }
 571
 572     wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
 573                        int row, int col) {
 574         wxSize rval;
 575         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 576         if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
 577             PyObject* ro;
 578             wxSize*   ptr;
 579             PyObject* go = wxPyMake_wxObject(&grid,false);
 580             PyObject* dco = wxPyMake_wxObject(&dc,false);
 581             PyObject* ao = wxPyMake_wxGridCellAttr(&attr,false);
 582
 583             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOOii)",
 584                                                                  go, ao, dco,
 585                                                                  row, col));
 586             Py_DECREF(go);
 587             Py_DECREF(ao);
 588             Py_DECREF(dco);
 589
 590             if (ro) {
 591                 const char* errmsg = "GetBestSize should return a 2-tuple of integers or a wxSize object.";
 592                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxSize"))) {
 593                     rval = *ptr;
 594                 }
 595                 else if (PySequence_Check(ro) && PyObject_Length(ro) == 2) {
 596                     PyObject* o1 = PySequence_GetItem(ro, 0);
 597                     PyObject* o2 = PySequence_GetItem(ro, 1);
 598                     if (PyNumber_Check(o1) && PyNumber_Check(o2))
 599                         rval = wxSize(PyInt_AsLong(o1), PyInt_AsLong(o2));
 600                     else
 601                         PyErr_SetString(PyExc_TypeError, errmsg);
 602                     Py_DECREF(o1);
 603                     Py_DECREF(o2);
 604                 }
 605                 else {
 606                     PyErr_SetString(PyExc_TypeError, errmsg);
 607                 }
 608                 Py_DECREF(ro);
 609             }
 610         }
 611         wxPyEndBlockThreads(blocked);
 612         return rval;
 613     }
 614
 615
 616     wxGridCellRenderer *Clone() const {
 617         wxGridCellRenderer* rval = NULL;
 618         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 619         if (wxPyCBH_findCallback(m_myInst, "Clone")) {
 620             PyObject* ro;
 621             wxGridCellRenderer* ptr;
 622             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 623             if (ro) {
 624                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellRenderer")))
 625                     rval = ptr;
 626                 Py_DECREF(ro);
 627             }
 628         }
 629         wxPyEndBlockThreads(blocked);
 630         return rval;
 631     }
 632
 633     DEC_PYCALLBACK__STRING(SetParameters);
 634
 635     PYPRIVATE;
 636 };
 637
 638 IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
 639
 640 %}
 641
 642
 643 // Let SWIG know about it so it can create the Python version
 644 class wxPyGridCellRenderer : public wxGridCellRenderer {
 645 public:
 646     %pythonAppend wxPyGridCellRenderer  "self._setOORInfo(self);"  setCallbackInfo(PyGridCellRenderer);
 647
 648     wxPyGridCellRenderer();
 649     void _setCallbackInfo(PyObject* self, PyObject* _class);
 650
 651     void SetParameters(const wxString& params);
 652     %MAKE_BASE_FUNC(PyGridCellRenderer, SetParameters);
 653 };
 654
 655 //---------------------------------------------------------------------------
 656 //  Predefined Renderers
 657
 658 class wxGridCellStringRenderer : public wxGridCellRenderer
 659 {
 660 public:
 661     %pythonAppend wxGridCellStringRenderer "self._setOORInfo(self)"
 662     wxGridCellStringRenderer();
 663 };
 664
 665
 666 class  wxGridCellNumberRenderer : public wxGridCellStringRenderer
 667 {
 668 public:
 669     %pythonAppend wxGridCellNumberRenderer "self._setOORInfo(self)"
 670     wxGridCellNumberRenderer();
 671 };
 672
 673
 674 class  wxGridCellFloatRenderer : public wxGridCellStringRenderer
 675 {
 676 public:
 677     %pythonAppend wxGridCellFloatRenderer "self._setOORInfo(self)"
 678     wxGridCellFloatRenderer(int width = -1, int precision = -1);
 679
 680     int GetWidth() const;
 681     void SetWidth(int width);
 682     int GetPrecision() const;
 683     void SetPrecision(int precision);
 684
 685     %property(Precision, GetPrecision, SetPrecision, doc="See `GetPrecision` and `SetPrecision`");
 686     %property(Width, GetWidth, SetWidth, doc="See `GetWidth` and `SetWidth`");
 687 };
 688
 689
 690 class  wxGridCellBoolRenderer : public wxGridCellRenderer
 691 {
 692 public:
 693     %pythonAppend wxGridCellBoolRenderer "self._setOORInfo(self)"
 694     wxGridCellBoolRenderer();
 695 };
 696
 697
 698 class wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
 699 {
 700 public:
 701     %pythonAppend wxGridCellDateTimeRenderer "self._setOORInfo(self)"
 702     wxGridCellDateTimeRenderer(wxString outformat = wxPyDefaultDateTimeFormat,
 703                                wxString informat =  wxPyDefaultDateTimeFormat);
 704 };
 705
 706
 707 class wxGridCellEnumRenderer : public wxGridCellStringRenderer
 708 {
 709 public:
 710     %pythonAppend wxGridCellEnumRenderer "self._setOORInfo(self)"
 711     wxGridCellEnumRenderer( const wxString& choices = wxPyEmptyString );
 712 };
 713
 714
 715 class wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
 716 {
 717 public:
 718     %pythonAppend wxGridCellAutoWrapStringRenderer "self._setOORInfo(self)"
 719     wxGridCellAutoWrapStringRenderer();
 720 };
 721
 722
 723 //---------------------------------------------------------------------------
 724 // wxGridCellEditor is an ABC, and several derived classes are available.
 725 // Classes implemented in Python should be derived from wxPyGridCellEditor.
 726
 727 class wxGridCellEditor : public wxGridCellWorker
 728 {
 729 public:
 730     bool IsCreated();
 731     wxControl* GetControl();
 732     void SetControl(wxControl* control);
 733
 734     wxGridCellAttr* GetCellAttr();
 735     void SetCellAttr(wxGridCellAttr* attr);
 736
 737     virtual void Create(wxWindow* parent,
 738                         wxWindowID id,
 739                         wxEvtHandler* evtHandler);
 740     virtual void BeginEdit(int row, int col, wxGrid* grid);
 741     virtual bool EndEdit(int row, int col, wxGrid* grid);
 742     virtual void Reset();
 743     virtual wxGridCellEditor *Clone() const;
 744
 745     virtual void SetSize(const wxRect& rect);
 746     virtual void Show(bool show, wxGridCellAttr *attr = NULL);
 747     virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
 748     virtual bool IsAcceptedKey(wxKeyEvent& event);
 749     virtual void StartingKey(wxKeyEvent& event);
 750     virtual void StartingClick();
 751     virtual void HandleReturn(wxKeyEvent& event);
 752
 753     %pythonPrepend Destroy "args[0].this.own(False)"
 754     virtual void Destroy();
 755
 756     %property(CellAttr, GetCellAttr, SetCellAttr, doc="See `GetCellAttr` and `SetCellAttr`");
 757     %property(Control, GetControl, SetControl, doc="See `GetControl` and `SetControl`");
 758 };
 759
 760
 761 // The C++ version of wxPyGridCellEditor
 762 %{
 763 class wxPyGridCellEditor : public wxGridCellEditor
 764 {
 765 public:
 766     wxPyGridCellEditor() : wxGridCellEditor() {}
 767
 768     void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
 769         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 770         if (wxPyCBH_findCallback(m_myInst, "Create")) {
 771             PyObject* po = wxPyMake_wxObject(parent,false);
 772             PyObject* eo = wxPyMake_wxObject(evtHandler,false);
 773
 774             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OiO)", po, id, eo));
 775             Py_DECREF(po);
 776             Py_DECREF(eo);
 777         }
 778         wxPyEndBlockThreads(blocked);
 779     }
 780
 781
 782     void BeginEdit(int row, int col, wxGrid* grid) {
 783         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 784         if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
 785             PyObject* go = wxPyMake_wxObject(grid,false);
 786             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
 787             Py_DECREF(go);
 788         }
 789         wxPyEndBlockThreads(blocked);
 790     }
 791
 792
 793     bool EndEdit(int row, int col, wxGrid* grid) {
 794         bool rv = false;
 795         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 796         if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
 797             PyObject* go = wxPyMake_wxObject(grid,false);
 798             rv = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)", row, col, go));
 799             Py_DECREF(go);
 800         }
 801         wxPyEndBlockThreads(blocked);
 802         return rv;
 803     }
 804
 805
 806     wxGridCellEditor* Clone() const {
 807         wxGridCellEditor* rval = NULL;
 808         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 809         if (wxPyCBH_findCallback(m_myInst, "Clone")) {
 810             PyObject* ro;
 811             wxGridCellEditor* ptr;
 812             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
 813             if (ro) {
 814                 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxGridCellEditor")))
 815                     rval = ptr;
 816                 Py_DECREF(ro);
 817             }
 818         }
 819         wxPyEndBlockThreads(blocked);
 820         return rval;
 821     }
 822
 823
 824     void Show(bool show, wxGridCellAttr *attr) {
 825         bool found;
 826         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 827         if ((found = wxPyCBH_findCallback(m_myInst, "Show"))) {
 828             PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
 829             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", show, ao));
 830             Py_DECREF(ao);
 831         }
 832         wxPyEndBlockThreads(blocked);
 833         if (! found)
 834             wxGridCellEditor::Show(show, attr);
 835     }
 836
 837
 838     void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
 839         bool found;
 840         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 841         if ((found = wxPyCBH_findCallback(m_myInst, "PaintBackground)"))) {
 842             PyObject* ao = wxPyMake_wxGridCellAttr(attr,false);
 843             PyObject* ro = wxPyConstructObject((void*)&rectCell, wxT("wxRect"), 0);
 844
 845             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)", ro, ao));
 846
 847             Py_DECREF(ro);
 848             Py_DECREF(ao);
 849         }
 850         wxPyEndBlockThreads(blocked);
 851         if (! found)
 852             wxGridCellEditor::PaintBackground(rectCell, attr);
 853     }
 854
 855
 856     DEC_PYCALLBACK___pure(Reset);
 857     DEC_PYCALLBACK__constany(SetSize, wxRect);
 858     DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
 859     DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
 860     DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
 861     DEC_PYCALLBACK__(StartingClick);
 862     DEC_PYCALLBACK__(Destroy);
 863     DEC_PYCALLBACK__STRING(SetParameters);
 864     DEC_PYCALLBACK_STRING__constpure(GetValue);
 865
 866     PYPRIVATE;
 867 };
 868
 869
 870 IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
 871 IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
 872 IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
 873 IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
 874 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
 875 IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
 876 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
 877 IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
 878 IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
 879
 880 %}
 881
 882
 883 // Let SWIG know about it so it can create the Python version
 884 class wxPyGridCellEditor : public wxGridCellEditor {
 885 public:
 886     %pythonAppend wxPyGridCellEditor  "self._setOORInfo(self);" setCallbackInfo(PyGridCellEditor)
 887
 888     wxPyGridCellEditor();
 889     void _setCallbackInfo(PyObject* self, PyObject* _class);
 890
 891     void SetSize(const wxRect& rect);
 892     void Show(bool show, wxGridCellAttr *attr = NULL);
 893     void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
 894     bool IsAcceptedKey(wxKeyEvent& event);
 895     void StartingKey(wxKeyEvent& event);
 896     void StartingClick();
 897     void HandleReturn(wxKeyEvent& event);
 898     void Destroy();
 899     void SetParameters(const wxString& params);
 900
 901     %MAKE_BASE_FUNC(PyGridCellEditor, SetSize);
 902     %MAKE_BASE_FUNC(PyGridCellEditor, Show);
 903     %MAKE_BASE_FUNC(PyGridCellEditor, PaintBackground);
 904     %MAKE_BASE_FUNC(PyGridCellEditor, IsAcceptedKey);
 905     %MAKE_BASE_FUNC(PyGridCellEditor, StartingKey);
 906     %MAKE_BASE_FUNC(PyGridCellEditor, StartingClick);
 907     %MAKE_BASE_FUNC(PyGridCellEditor, HandleReturn);
 908     %MAKE_BASE_FUNC(PyGridCellEditor, Destroy);
 909     %MAKE_BASE_FUNC(PyGridCellEditor, SetParameters);
 910 };
 911
 912 //---------------------------------------------------------------------------
 913 //  Predefined Editors
 914
 915 class wxGridCellTextEditor : public wxGridCellEditor
 916 {
 917 public:
 918     %pythonAppend wxGridCellTextEditor  "self._setOORInfo(self)"
 919     wxGridCellTextEditor();
 920     virtual wxString GetValue();
 921
 922     %property(Value, GetValue, doc="See `GetValue`");
 923 };
 924
 925
 926 class wxGridCellNumberEditor : public wxGridCellTextEditor
 927 {
 928 public:
 929     %pythonAppend wxGridCellNumberEditor  "self._setOORInfo(self)"
 930     wxGridCellNumberEditor(int min = -1, int max = -1);
 931 };
 932
 933
 934 class wxGridCellFloatEditor : public wxGridCellTextEditor
 935 {
 936 public:
 937     %pythonAppend wxGridCellFloatEditor  "self._setOORInfo(self)"
 938     wxGridCellFloatEditor(int width = -1, int precision = -1);
 939 };
 940
 941
 942 MAKE_CONST_WXSTRING2(OneString, _T("1"));
 943 class wxGridCellBoolEditor : public wxGridCellEditor
 944 {
 945 public:
 946     %pythonAppend wxGridCellBoolEditor  "self._setOORInfo(self)"
 947     wxGridCellBoolEditor();
 948
 949     // set the string values returned by GetValue() for the true and false
 950     // states, respectively
 951     static void UseStringValues(const wxString& valueTrue = wxPyOneString,
 952                                 const wxString& valueFalse = wxPyEmptyString);
 953
 954     // return true if the given string is equal to the string representation of
 955     // true value which we currently use
 956     static bool IsTrueValue(const wxString& value);
 957
 958 };
 959
 960 class wxGridCellChoiceEditor : public wxGridCellEditor
 961 {
 962 public:
 963     %pythonAppend wxGridCellChoiceEditor  "self._setOORInfo(self)"
 964     wxGridCellChoiceEditor(int choices = 0,
 965                            const wxString* choices_array = NULL,
 966                            bool allowOthers = false);
 967 };
 968
 969
 970 class wxGridCellEnumEditor : public wxGridCellChoiceEditor
 971 {
 972 public:
 973     %pythonAppend wxGridCellEnumEditor  "self._setOORInfo(self)"
 974     wxGridCellEnumEditor( const wxString& choices = wxPyEmptyString );
 975 };
 976
 977
 978 class wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
 979 {
 980 public:
 981     %pythonAppend wxGridCellAutoWrapStringEditor  "self._setOORInfo(self)"
 982     wxGridCellAutoWrapStringEditor();
 983 };
 984
 985
 986
 987 //---------------------------------------------------------------------------
 988
 989
 990 class wxGridCellAttr
 991 {
 992 public:
 993     enum wxAttrKind
 994     {
 995         Any,
 996         Default,
 997         Cell,
 998         Row,
 999         Col,
1000         Merged
1001     };
1002
1003     %extend {
1004         void _setOORInfo(PyObject* _self) {
1005             if (!self->GetClientObject())
1006                 self->SetClientObject(new wxPyOORClientData(_self));
1007         }
1008     }
1009
1010     %pythonAppend wxGridCellAttr  "self._setOORInfo(self)"
1011
1012     wxGridCellAttr(wxGridCellAttr *attrDefault = NULL);
1013
1014     %extend {
1015         // A dummy dtor to shut up SWIG.  (The real one is protected and can
1016         // only be called by DecRef)
1017         ~wxGridCellAttr() {
1018         }
1019     }
1020
1021     wxGridCellAttr *Clone() const;
1022     void MergeWith(wxGridCellAttr *mergefrom);
1023
1024     void IncRef();
1025     void DecRef();
1026
1027     void SetTextColour(const wxColour& colText);
1028     void SetBackgroundColour(const wxColour& colBack);
1029     void SetFont(const wxFont& font);
1030     void SetAlignment(int hAlign, int vAlign);
1031     void SetSize(int num_rows, int num_cols);
1032     void SetOverflow( bool allow = true );
1033     void SetReadOnly(bool isReadOnly = true);
1034
1035     void SetRenderer(wxGridCellRenderer *renderer);
1036     void SetEditor(wxGridCellEditor* editor);
1037     void SetKind(wxAttrKind kind);
1038
1039     bool HasTextColour() const;
1040     bool HasBackgroundColour() const;
1041     bool HasFont() const;
1042     bool HasAlignment() const;
1043     bool HasRenderer() const;
1044     bool HasEditor() const;
1045     bool HasReadWriteMode() const;
1046     bool HasOverflowMode() const;
1047
1048     wxColour GetTextColour() const;
1049     wxColour GetBackgroundColour() const;
1050     wxFont GetFont() const;
1051
1052     DocDeclA(
1053         void, GetAlignment(int *OUTPUT, int *OUTPUT) const,
1054         "GetAlignment() -> (hAlign, vAlign)");
1055
1056     DocDeclA(
1057         void, GetSize(int *OUTPUT, int *OUTPUT) const,
1058         "GetSize() -> (num_rows, num_cols)");
1059
1060     bool GetOverflow() const;
1061     wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
1062     wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
1063
1064     bool IsReadOnly() const;
1065     wxAttrKind GetKind();
1066     void SetDefAttr(wxGridCellAttr* defAttr);
1067
1068     %property(Alignment, GetAlignment, SetAlignment, doc="See `GetAlignment` and `SetAlignment`");
1069     %property(BackgroundColour, GetBackgroundColour, SetBackgroundColour, doc="See `GetBackgroundColour` and `SetBackgroundColour`");
1070     %property(Font, GetFont, SetFont, doc="See `GetFont` and `SetFont`");
1071     %property(Kind, GetKind, SetKind, doc="See `GetKind` and `SetKind`");
1072     %property(Overflow, GetOverflow, SetOverflow, doc="See `GetOverflow` and `SetOverflow`");
1073     %property(Size, GetSize, SetSize, doc="See `GetSize` and `SetSize`");
1074     %property(TextColour, GetTextColour, SetTextColour, doc="See `GetTextColour` and `SetTextColour`");
1075 };
1076
1077 //---------------------------------------------------------------------------
1078
1079 class wxGridCellAttrProvider
1080 {
1081 public:
1082     %pythonAppend wxGridCellAttrProvider "self._setOORInfo(self)"
1083     wxGridCellAttrProvider();
1084     // ???? virtual ~wxGridCellAttrProvider();
1085
1086     %extend {
1087         void _setOORInfo(PyObject* _self) {
1088             if (!self->GetClientObject())
1089                 self->SetClientObject(new wxPyOORClientData(_self));
1090         }
1091     }
1092
1093     wxGridCellAttr *GetAttr(int row, int col,
1094                             wxGridCellAttr::wxAttrKind  kind) const;
1095     void SetAttr(wxGridCellAttr *attr, int row, int col);
1096     void SetRowAttr(wxGridCellAttr *attr, int row);
1097     void SetColAttr(wxGridCellAttr *attr, int col);
1098
1099     void UpdateAttrRows( size_t pos, int numRows );
1100     void UpdateAttrCols( size_t pos, int numCols );
1101
1102 };
1103
1104
1105 // A Python-aware version
1106 %{
1107 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
1108 {
1109 public:
1110     wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
1111
1112     PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
1113     PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
1114     PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
1115     PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
1116
1117     PYPRIVATE;
1118 };
1119 %}
1120
1121
1122 // The python-aware version get's SWIGified
1123 class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
1124 {
1125 public:
1126     %pythonAppend wxPyGridCellAttrProvider  setCallbackInfo(PyGridCellAttrProvider)
1127     wxPyGridCellAttrProvider();
1128     void _setCallbackInfo(PyObject* self, PyObject* _class);
1129
1130     wxGridCellAttr *GetAttr(int row, int col,
1131                             wxGridCellAttr::wxAttrKind kind);
1132     void SetAttr(wxGridCellAttr *attr, int row, int col);
1133     void SetRowAttr(wxGridCellAttr *attr, int row);
1134     void SetColAttr(wxGridCellAttr *attr, int col);
1135
1136     %MAKE_BASE_FUNC(PyGridCellAttrProvider, GetAttr);
1137     %MAKE_BASE_FUNC(PyGridCellAttrProvider, SetAttr);
1138     %MAKE_BASE_FUNC(PyGridCellAttrProvider, SetRowAttr);
1139     %MAKE_BASE_FUNC(PyGridCellAttrProvider, SetColAttr);
1140 };
1141
1142
1143 //---------------------------------------------------------------------------
1144 // Grid Table Base class and Python aware version
1145
1146
1147 class wxGridTableBase : public wxObject
1148 {
1149 public:
1150     // wxGridTableBase();   This is an ABC
1151     ~wxGridTableBase();
1152
1153     %extend {
1154         void _setOORInfo(PyObject* _self) {
1155             if (!self->GetClientObject())
1156                 self->SetClientObject(new wxPyOORClientData(_self));
1157         }
1158     }
1159
1160     void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
1161     wxGridCellAttrProvider *GetAttrProvider() const;
1162     void SetView( wxGrid *grid );
1163     wxGrid * GetView() const;
1164
1165
1166     // pure virtuals
1167     virtual int GetNumberRows();
1168     virtual int GetNumberCols();
1169     virtual bool IsEmptyCell( int row, int col );
1170     virtual wxString GetValue( int row, int col );
1171     virtual void SetValue( int row, int col, const wxString& value );
1172
1173     // virtuals overridable in wxPyGridTableBase
1174     virtual wxString GetTypeName( int row, int col );
1175     virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
1176     virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
1177     virtual long GetValueAsLong( int row, int col );
1178     virtual double GetValueAsDouble( int row, int col );
1179     virtual bool GetValueAsBool( int row, int col );
1180     virtual void SetValueAsLong( int row, int col, long value );
1181     virtual void SetValueAsDouble( int row, int col, double value );
1182     virtual void SetValueAsBool( int row, int col, bool value );
1183
1184     //virtual void* GetValueAsCustom( int row, int col, const wxString& typeName );
1185     //virtual void  SetValueAsCustom( int row, int col, const wxString& typeName, void* value );
1186
1187
1188     virtual void Clear();
1189     virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
1190     virtual bool AppendRows( size_t numRows = 1 );
1191     virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
1192     virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
1193     virtual bool AppendCols( size_t numCols = 1 );
1194     virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
1195
1196     virtual wxString GetRowLabelValue( int row );
1197     virtual wxString GetColLabelValue( int col );
1198     virtual void SetRowLabelValue( int row, const wxString& value );
1199     virtual void SetColLabelValue( int col, const wxString& value );
1200
1201     virtual bool CanHaveAttributes();
1202
1203     virtual wxGridCellAttr *GetAttr( int row, int col,
1204                                      wxGridCellAttr::wxAttrKind  kind);
1205     virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
1206     virtual void SetRowAttr(wxGridCellAttr *attr, int row);
1207     virtual void SetColAttr(wxGridCellAttr *attr, int col);
1208
1209     %property(AttrProvider, GetAttrProvider, SetAttrProvider, doc="See `GetAttrProvider` and `SetAttrProvider`");
1210     %property(NumberCols, GetNumberCols, doc="See `GetNumberCols`");
1211     %property(NumberRows, GetNumberRows, doc="See `GetNumberRows`");
1212     %property(View, GetView, SetView, doc="See `GetView` and `SetView`");
1213 };
1214
1215
1216
1217 // Python-aware version
1218 %{
1219 class wxPyGridTableBase : public wxGridTableBase
1220 {
1221 public:
1222     wxPyGridTableBase() : wxGridTableBase() {}
1223
1224     PYCALLBACK_INT__pure(GetNumberRows);
1225     PYCALLBACK_INT__pure(GetNumberCols);
1226     PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
1227     PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
1228     PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
1229     PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
1230     PYCALLBACK__(wxGridTableBase, Clear);
1231     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
1232     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
1233     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
1234     PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
1235     PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
1236     PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
1237     PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
1238     PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
1239     PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
1240     PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
1241     PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
1242     PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
1243     PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
1244     PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
1245     PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
1246
1247
1248     wxString GetValue(int row, int col) {
1249         wxPyBlock_t blocked = wxPyBeginBlockThreads();
1250         wxString rval;
1251         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
1252             PyObject* ro;
1253             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
1254             if (ro) {
1255                 if (!PyString_Check(ro) && !PyUnicode_Check(ro)) {
1256                     PyObject* old = ro;
1257                     ro = PyObject_Str(ro);
1258                     Py_DECREF(old);
1259                 }
1260                 rval = Py2wxString(ro);
1261                 Py_DECREF(ro);
1262             }
1263         }
1264         wxPyEndBlockThreads(blocked);
1265         return rval;
1266     }
1267
1268     void SetValue(int row, int col, const wxString& val) {
1269         wxPyBlock_t blocked = wxPyBeginBlockThreads();
1270         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
1271             PyObject* s = wx2PyString(val);
1272             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",row,col,s));
1273             Py_DECREF(s);
1274         }
1275         wxPyEndBlockThreads(blocked);
1276     }
1277
1278
1279     // Map the Get/Set methods for the standard non-string types to
1280     // the GetValue and SetValue python methods.
1281     long GetValueAsLong( int row, int col ) {
1282         long rval = 0;
1283         wxPyBlock_t blocked = wxPyBeginBlockThreads();
1284         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
1285             PyObject* ro;
1286             PyObject* num;
1287             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
1288             if (ro && PyNumber_Check(ro)) {
1289                 num = PyNumber_Int(ro);
1290                 if (num) {
1291                     rval = PyInt_AsLong(num);
1292                     Py_DECREF(num);
1293                 }
1294                 Py_DECREF(ro);
1295             }
1296         }
1297         wxPyEndBlockThreads(blocked);
1298         return rval;
1299     }
1300
1301     double GetValueAsDouble( int row, int col ) {
1302         double rval = 0.0;
1303         wxPyBlock_t blocked = wxPyBeginBlockThreads();
1304         if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
1305             PyObject* ro;
1306             PyObject* num;
1307             ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
1308             if (ro && PyNumber_Check(ro)) {
1309                 num = PyNumber_Float(ro);
1310                 if (num) {
1311                     rval = PyFloat_AsDouble(num);
1312                     Py_DECREF(num);
1313                 }
1314                 Py_DECREF(ro);
1315             }
1316         }
1317         wxPyEndBlockThreads(blocked);
1318         return rval;
1319     }
1320
1321     bool GetValueAsBool( int row, int col ) {
1322         return (bool)GetValueAsLong(row, col);
1323     }
1324
1325     void SetValueAsLong( int row, int col, long value ) {
1326         wxPyBlock_t blocked = wxPyBeginBlockThreads();
1327         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
1328             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
1329         }
1330         wxPyEndBlockThreads(blocked);
1331     }
1332
1333     void SetValueAsDouble( int row, int col, double value ) {
1334         wxPyBlock_t blocked = wxPyBeginBlockThreads();
1335         if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
1336             wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
1337         }
1338         wxPyEndBlockThreads(blocked);
1339     }
1340
1341     void SetValueAsBool( int row, int col, bool value ) {
1342         SetValueAsLong( row, col, (long)value );
1343     }
1344
1345
1346     PYPRIVATE;
1347 };
1348 %}
1349
1350
1351 // The python-aware version get's SWIGified
1352 class wxPyGridTableBase : public wxGridTableBase
1353 {
1354 public:
1355     %pythonAppend wxPyGridTableBase  "self._setOORInfo(self);"  setCallbackInfo(PyGridTableBase)
1356     wxPyGridTableBase();
1357     void _setCallbackInfo(PyObject* self, PyObject* _class);
1358
1359     %pythonPrepend Destroy "args[0].this.own(False)"
1360     %extend { void Destroy() { delete self; } }
1361
1362     wxString GetTypeName( int row, int col );
1363     bool CanGetValueAs( int row, int col, const wxString& typeName );
1364     bool CanSetValueAs( int row, int col, const wxString& typeName );
1365     void Clear();
1366     bool InsertRows( size_t pos = 0, size_t numRows = 1 );
1367     bool AppendRows( size_t numRows = 1 );
1368     bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
1369     bool InsertCols( size_t pos = 0, size_t numCols = 1 );
1370     bool AppendCols( size_t numCols = 1 );
1371     bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
1372     wxString GetRowLabelValue( int row );
1373     wxString GetColLabelValue( int col );
1374     void SetRowLabelValue( int row, const wxString& value );
1375     void SetColLabelValue( int col, const wxString& value );
1376     bool CanHaveAttributes();
1377     wxGridCellAttr *GetAttr( int row, int col,
1378                                   wxGridCellAttr::wxAttrKind kind );
1379     void SetAttr(wxGridCellAttr* attr, int row, int col);
1380     void SetRowAttr(wxGridCellAttr *attr, int row);
1381     void SetColAttr(wxGridCellAttr *attr, int col);
1382
1383     %MAKE_BASE_FUNC(PyGridTableBase, GetTypeName);
1384     %MAKE_BASE_FUNC(PyGridTableBase, CanGetValueAs);
1385     %MAKE_BASE_FUNC(PyGridTableBase, CanSetValueAs);
1386     %MAKE_BASE_FUNC(PyGridTableBase, Clear);
1387     %MAKE_BASE_FUNC(PyGridTableBase, InsertRows);
1388     %MAKE_BASE_FUNC(PyGridTableBase, AppendRows);
1389     %MAKE_BASE_FUNC(PyGridTableBase, DeleteRows);
1390     %MAKE_BASE_FUNC(PyGridTableBase, InsertCols);
1391     %MAKE_BASE_FUNC(PyGridTableBase, AppendCols);
1392     %MAKE_BASE_FUNC(PyGridTableBase, DeleteCols);
1393     %MAKE_BASE_FUNC(PyGridTableBase, GetRowLabelValue);
1394     %MAKE_BASE_FUNC(PyGridTableBase, GetColLabelValue);
1395     %MAKE_BASE_FUNC(PyGridTableBase, SetRowLabelValue);
1396     %MAKE_BASE_FUNC(PyGridTableBase, SetColLabelValue);
1397     %MAKE_BASE_FUNC(PyGridTableBase, CanHaveAttributes);
1398     %MAKE_BASE_FUNC(PyGridTableBase, GetAttr);
1399     %MAKE_BASE_FUNC(PyGridTableBase, SetAttr);
1400     %MAKE_BASE_FUNC(PyGridTableBase, SetRowAttr);
1401     %MAKE_BASE_FUNC(PyGridTableBase, SetColAttr);
1402 };
1403
1404
1405 //---------------------------------------------------------------------------
1406 // Predefined Tables
1407
1408 class  wxGridStringTable : public wxGridTableBase
1409 {
1410 public:
1411     %pythonAppend wxGridStringTable "self._setOORInfo(self)"
1412     wxGridStringTable( int numRows=0, int numCols=0 );
1413 };
1414
1415 //---------------------------------------------------------------------------
1416 // The Table can pass messages to the grid to tell it to update itself if
1417 // something has changed.
1418
1419 enum wxGridTableRequest
1420 {
1421     wxGRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000,
1422     wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
1423     wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
1424     wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
1425     wxGRIDTABLE_NOTIFY_ROWS_DELETED,
1426     wxGRIDTABLE_NOTIFY_COLS_INSERTED,
1427     wxGRIDTABLE_NOTIFY_COLS_APPENDED,
1428     wxGRIDTABLE_NOTIFY_COLS_DELETED
1429 };
1430
1431
1432 class wxGridTableMessage
1433 {
1434 public:
1435     wxGridTableMessage( wxGridTableBase *table, int id,
1436                         int comInt1 = -1,
1437                         int comInt2 = -1 );
1438     ~wxGridTableMessage();
1439
1440     void SetTableObject( wxGridTableBase *table );
1441     wxGridTableBase * GetTableObject() const;
1442     void SetId( int id );
1443     int  GetId();
1444     void SetCommandInt( int comInt1 );
1445     int  GetCommandInt();
1446     void SetCommandInt2( int comInt2 );
1447     int  GetCommandInt2();
1448
1449     %property(CommandInt, GetCommandInt, SetCommandInt, doc="See `GetCommandInt` and `SetCommandInt`");
1450     %property(CommandInt2, GetCommandInt2, SetCommandInt2, doc="See `GetCommandInt2` and `SetCommandInt2`");
1451     %property(Id, GetId, SetId, doc="See `GetId` and `SetId`");
1452     %property(TableObject, GetTableObject, SetTableObject, doc="See `GetTableObject` and `SetTableObject`");
1453 };
1454
1455
1456 //---------------------------------------------------------------------------
1457
1458
1459 // Typemap to allow conversion of sequence objects to wxGridCellCoords...
1460 %typemap(in) wxGridCellCoords& (wxGridCellCoords temp) {
1461     $1 = &temp;
1462     if (! wxGridCellCoords_helper($input, &$1)) SWIG_fail;
1463 }
1464 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGridCellCoords& {
1465     $1 = wxGridCellCoords_typecheck($input);
1466 }
1467
1468
1469 // ...and here is the associated helper.
1470 %{
1471 bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
1472
1473     if (source == Py_None) {
1474         **obj = wxGridCellCoords(-1,-1);
1475         return true;
1476     }
1477
1478     // If source is an object instance then it may already be the right type
1479     if (wxPySwigInstance_Check(source)) {
1480         wxGridCellCoords* ptr;
1481         if (! wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
1482             goto error;
1483         *obj = ptr;
1484         return true;
1485     }
1486     // otherwise a 2-tuple of integers is expected
1487     else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
1488         PyObject* o1 = PySequence_GetItem(source, 0);
1489         PyObject* o2 = PySequence_GetItem(source, 1);
1490         if (!PyNumber_Check(o1) || !PyNumber_Check(o2)) {
1491             Py_DECREF(o1);
1492             Py_DECREF(o2);
1493             goto error;
1494         }
1495         **obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
1496         Py_DECREF(o1);
1497         Py_DECREF(o2);
1498         return true;
1499     }
1500
1501  error:
1502     PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
1503     return false;
1504 }
1505
1506
1507 bool wxGridCellCoords_typecheck(PyObject* source) {
1508     void* ptr;
1509
1510     if (wxPySwigInstance_Check(source) &&
1511         wxPyConvertSwigPtr(source, (void **)&ptr, wxT("wxGridCellCoords")))
1512         return true;
1513
1514     PyErr_Clear();
1515     if (PySequence_Check(source) && PySequence_Length(source) == 2)
1516         return true;
1517
1518     return false;
1519 }
1520 %}
1521
1522
1523 // Typemap to convert an array of cells coords to a list of tuples...
1524 %typemap(out) wxGridCellCoordsArray {
1525     $result = wxGridCellCoordsArray_helper($1);
1526 }
1527
1528 // %typemap(ret) wxGridCellCoordsArray {
1529 //     delete $1;
1530 // }
1531
1532
1533 // ...and the helper function for the above typemap.
1534 %{
1535 PyObject* wxGridCellCoordsArray_helper(const wxGridCellCoordsArray& source)
1536 {
1537     PyObject* list = PyList_New(0);
1538     size_t idx;
1539     for (idx = 0; idx < source.GetCount(); idx += 1) {
1540         wxGridCellCoords& coord = source.Item(idx);
1541         PyObject* tup = PyTuple_New(2);
1542         PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(coord.GetRow()));
1543         PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(coord.GetCol()));
1544         PyList_Append(list, tup);
1545         Py_DECREF(tup);
1546     }
1547     return list;
1548 }
1549 %}
1550
1551
1552
1553
1554
1555 class wxGridCellCoords
1556 {
1557 public:
1558     wxGridCellCoords( int r=-1, int c=-1 );
1559     ~wxGridCellCoords();
1560
1561     int GetRow() const;
1562     void SetRow( int n );
1563     int GetCol() const;
1564     void SetCol( int n );
1565     void Set( int row, int col );
1566
1567     %extend {
1568         KeepGIL(__eq__);
1569         DocStr(__eq__, "Test for equality of GridCellCoords objects.", "");
1570         bool __eq__(PyObject* other) {
1571             wxGridCellCoords  temp, *obj = &temp;
1572             if ( other == Py_None ) return false;
1573             if ( ! wxGridCellCoords_helper(other, &obj) ) {
1574                 PyErr_Clear();
1575                 return false;
1576             }
1577             return self->operator==(*obj);
1578         }
1579
1580
1581         KeepGIL(__ne__);
1582         DocStr(__ne__, "Test for inequality of GridCellCoords objects.", "");
1583         bool __ne__(PyObject* other) {
1584             wxGridCellCoords  temp, *obj = &temp;
1585             if ( other == Py_None ) return true;
1586             if ( ! wxGridCellCoords_helper(other, &obj)) {
1587                 PyErr_Clear();
1588                 return true;
1589             }
1590             return self->operator!=(*obj);
1591         }
1592     }
1593
1594
1595     %extend {
1596         PyObject* Get() {
1597             PyObject* tup = PyTuple_New(2);
1598             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
1599             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
1600             return tup;
1601         }
1602     }
1603     %pythoncode {
1604     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
1605     def __str__(self):                   return str(self.Get())
1606     def __repr__(self):                  return 'wxGridCellCoords'+str(self.Get())
1607     def __len__(self):                   return len(self.Get())
1608     def __getitem__(self, index):        return self.asTuple()[index]
1609     def __setitem__(self, index, val):
1610         if index == 0: self.SetRow(val)
1611         elif index == 1: self.SetCol(val)
1612         else: raise IndexError
1613     }
1614
1615     %property(Col, GetCol, SetCol, doc="See `GetCol` and `SetCol`");
1616     %property(Row, GetRow, SetRow, doc="See `GetRow` and `SetRow`");
1617 };
1618
1619
1620 //---------------------------------------------------------------------------
1621 //---------------------------------------------------------------------------
1622 // The grid itself
1623
1624
1625 // Fool SWIG into treating this enum as an int
1626 typedef int WXGRIDSELECTIONMODES;
1627
1628 // but let the C++ code know what it really is.
1629 %{
1630 typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
1631 %}
1632
1633
1634
1635 MustHaveApp(wxGrid);
1636
1637 class wxGrid : public wxScrolledWindow
1638 {
1639 public:
1640     %pythonAppend wxGrid "self._setOORInfo(self)"
1641     %pythonAppend wxGrid() ""
1642
1643     %typemap(out) wxGrid*;    // turn off this typemap
1644
1645     wxGrid( wxWindow *parent,
1646             wxWindowID id=-1,
1647             const wxPoint& pos = wxDefaultPosition,
1648             const wxSize& size = wxDefaultSize,
1649             long style = wxWANTS_CHARS,
1650             const wxString& name = wxPyGridNameStr);
1651
1652     %RenameCtor(PreGrid,  wxGrid());
1653
1654
1655     // Turn it back on again
1656     %typemap(out) wxGrid* { $result = wxPyMake_wxObject($1, $owner); }
1657
1658
1659     bool Create( wxWindow *parent,
1660                  wxWindowID id=-1,
1661                  const wxPoint& pos = wxDefaultPosition,
1662                  const wxSize& size = wxDefaultSize,
1663                  long style = wxWANTS_CHARS,
1664                  const wxString& name = wxPyGridNameStr );
1665
1666     // Override the global renamer to leave these as they are, for backwards
1667     // compatibility
1668     %rename(wxGridSelectCells)   wxGridSelectCells;
1669     %rename(wxGridSelectRows)    wxGridSelectRows;
1670     %rename(wxGridSelectColumns) wxGridSelectColumns;
1671
1672     enum wxGridSelectionModes {
1673         wxGridSelectCells,
1674         wxGridSelectRows,
1675         wxGridSelectColumns
1676     };
1677     %pythoncode {
1678         SelectCells =   wxGridSelectCells
1679         SelectRows =    wxGridSelectRows
1680         SelectColumns = wxGridSelectColumns
1681     }
1682
1683     bool CreateGrid( int numRows, int numCols,
1684                      WXGRIDSELECTIONMODES selmode = wxGrid::wxGridSelectCells );
1685     void SetSelectionMode(WXGRIDSELECTIONMODES selmode);
1686     WXGRIDSELECTIONMODES GetSelectionMode();
1687
1688
1689     // ------ grid dimensions
1690     //
1691     int      GetNumberRows();
1692     int      GetNumberCols();
1693
1694
1695     bool ProcessTableMessage( wxGridTableMessage& );
1696
1697
1698     wxGridTableBase * GetTable() const;
1699
1700     %disownarg(wxGridTableBase *);
1701     bool SetTable( wxGridTableBase *table, bool takeOwnership=false,
1702                    WXGRIDSELECTIONMODES selmode =
1703                    wxGrid::wxGridSelectCells );
1704     %cleardisown(wxGridTableBase *);
1705
1706     void ClearGrid();
1707     bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels=true );
1708     bool AppendRows( int numRows = 1, bool updateLabels=true );
1709     bool DeleteRows( int pos = 0, int numRows = 1, bool updateLabels=true );
1710     bool InsertCols( int pos = 0, int numCols = 1, bool updateLabels=true );
1711     bool AppendCols( int numCols = 1, bool updateLabels=true );
1712     bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=true );
1713
1714
1715     // this function is called when the current cell highlight must be redrawn
1716     // and may be overridden by the user
1717     virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
1718
1719
1720     // ------ Cell text drawing functions
1721     //
1722     void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&,
1723                             int horizontalAlignment = wxLEFT,
1724                             int verticalAlignment = wxTOP,
1725                             int textOrientation = wxHORIZONTAL );
1726
1727 //      // Split a string containing newline chararcters into an array of
1728 //      // strings and return the number of lines
1729 //      //
1730 //      void StringToLines( const wxString& value, wxArrayString& lines );
1731
1732     DocDeclA(
1733         void, GetTextBoxSize( wxDC& dc, wxArrayString& lines,
1734                               long *OUTPUT, long *OUTPUT ),
1735         "GetTextBoxSize(DC dc, list lines) -> (width, height)");
1736
1737
1738     // ------
1739     // Code that does a lot of grid modification can be enclosed
1740     // between BeginBatch() and EndBatch() calls to avoid screen
1741     // flicker
1742     //
1743     void     BeginBatch();
1744     void     EndBatch();
1745     int      GetBatchCount();
1746     void     ForceRefresh();
1747
1748
1749     // ------ edit control functions
1750     //
1751     bool IsEditable();
1752     void EnableEditing( bool edit );
1753
1754     void EnableCellEditControl( bool enable = true );
1755     void DisableCellEditControl();
1756     bool CanEnableCellControl() const;
1757     bool IsCellEditControlEnabled() const;
1758     bool IsCellEditControlShown() const;
1759
1760     bool IsCurrentCellReadOnly() const;
1761
1762     void ShowCellEditControl();
1763     void HideCellEditControl();
1764     void SaveEditControlValue();
1765
1766
1767     // ------ grid location functions
1768     //  Note that all of these functions work with the logical coordinates of
1769     //  grid cells and labels so you will need to convert from device
1770     //  coordinates for mouse events etc.
1771     //
1772
1773     //void XYToCell( int x, int y, wxGridCellCoords& );
1774     %extend {
1775         wxGridCellCoords XYToCell(int x, int y) {
1776             wxGridCellCoords rv;
1777             self->XYToCell(x, y, rv);
1778             return rv;
1779         }
1780     }
1781
1782     int  YToRow( int y );
1783     int  XToCol( int x, bool clipToMinMax = false );
1784
1785     int  YToEdgeOfRow( int y );
1786     int  XToEdgeOfCol( int x );
1787
1788     wxRect CellToRect( int row, int col );
1789     // TODO: ??? wxRect CellToRect( const wxGridCellCoords& coords );
1790
1791
1792     int  GetGridCursorRow();
1793     int  GetGridCursorCol();
1794
1795     // check to see if a cell is either wholly visible (the default arg) or
1796     // at least partially visible in the grid window
1797     //
1798     bool IsVisible( int row, int col, bool wholeCellVisible = true );
1799     // TODO: ??? bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = true );
1800     void MakeCellVisible( int row, int col );
1801     // TODO: ??? void MakeCellVisible( const wxGridCellCoords& coords );
1802
1803
1804     // ------ grid cursor movement functions
1805     //
1806     void SetGridCursor( int row, int col );
1807     bool MoveCursorUp( bool expandSelection );
1808     bool MoveCursorDown( bool expandSelection );
1809     bool MoveCursorLeft( bool expandSelection );
1810     bool MoveCursorRight( bool expandSelection );
1811     bool MovePageDown();
1812     bool MovePageUp();
1813     bool MoveCursorUpBlock( bool expandSelection );
1814     bool MoveCursorDownBlock( bool expandSelection );
1815     bool MoveCursorLeftBlock( bool expandSelection );
1816     bool MoveCursorRightBlock( bool expandSelection );
1817
1818
1819     // ------ label and gridline formatting
1820     //
1821     int      GetDefaultRowLabelSize();
1822     int      GetRowLabelSize();
1823     int      GetDefaultColLabelSize();
1824     int      GetColLabelSize();
1825     wxColour GetLabelBackgroundColour();
1826     wxColour GetLabelTextColour();
1827     wxFont   GetLabelFont();
1828
1829     DocDeclA(
1830         void, GetRowLabelAlignment( int *OUTPUT, int *OUTPUT ),
1831         "GetRowLabelAlignment() -> (horiz, vert)");
1832
1833     DocDeclA(
1834         void, GetColLabelAlignment( int *OUTPUT, int *OUTPUT ),
1835         "GetColLabelAlignment() -> (horiz, vert)");
1836
1837     int      GetColLabelTextOrientation();
1838     wxString GetRowLabelValue( int row );
1839     wxString GetColLabelValue( int col );
1840     wxColour GetGridLineColour();
1841
1842     virtual wxPen GetDefaultGridLinePen();
1843     virtual wxPen GetRowGridLinePen(int row);
1844     virtual wxPen GetColGridLinePen(int col);
1845
1846
1847     wxColour GetCellHighlightColour();
1848     int      GetCellHighlightPenWidth();
1849     int      GetCellHighlightROPenWidth();
1850
1851     void     SetRowLabelSize( int width );
1852     void     SetColLabelSize( int height );
1853     void     SetLabelBackgroundColour( const wxColour& );
1854     void     SetLabelTextColour( const wxColour& );
1855     void     SetLabelFont( const wxFont& );
1856     void     SetRowLabelAlignment( int horiz, int vert );
1857     void     SetColLabelAlignment( int horiz, int vert );
1858     void     SetColLabelTextOrientation( int textOrientation );
1859     void     SetRowLabelValue( int row, const wxString& );
1860     void     SetColLabelValue( int col, const wxString& );
1861     void     SetGridLineColour( const wxColour& );
1862     void     SetCellHighlightColour( const wxColour& );
1863     void     SetCellHighlightPenWidth(int width);
1864     void     SetCellHighlightROPenWidth(int width);
1865
1866     void     EnableDragRowSize( bool enable = true );
1867     void     DisableDragRowSize();
1868     bool     CanDragRowSize();
1869     void     EnableDragColSize( bool enable = true );
1870     void     DisableDragColSize();
1871     bool     CanDragColSize();
1872     void     EnableDragColMove( bool enable = true );
1873     void     DisableDragColMove() { EnableDragColMove( false ); }
1874     bool     CanDragColMove() { return m_canDragColMove; }
1875     void     EnableDragGridSize(bool enable = true);
1876     void     DisableDragGridSize();
1877     bool     CanDragGridSize();
1878
1879     void     EnableDragCell( bool enable = true );
1880     void     DisableDragCell();
1881     bool     CanDragCell();
1882
1883     // this sets the specified attribute for all cells in this row/col
1884     void     SetAttr(int row, int col, wxGridCellAttr *attr);
1885     void     SetRowAttr(int row, wxGridCellAttr *attr);
1886     void     SetColAttr(int col, wxGridCellAttr *attr);
1887
1888     // returns the attribute we may modify in place: a new one if this cell
1889     // doesn't have any yet or the existing one if it does
1890     //
1891     // DecRef() must be called on the returned pointer, as usual
1892     wxGridCellAttr *GetOrCreateCellAttr(int row, int col) const;
1893
1894
1895     // shortcuts for setting the column parameters
1896
1897     // set the format for the data in the column: default is string
1898     void     SetColFormatBool(int col);
1899     void     SetColFormatNumber(int col);
1900     void     SetColFormatFloat(int col, int width = -1, int precision = -1);
1901     void     SetColFormatCustom(int col, const wxString& typeName);
1902
1903     void     EnableGridLines( bool enable = true );
1904     bool     GridLinesEnabled();
1905
1906     // ------ row and col formatting
1907     //
1908     int      GetDefaultRowSize();
1909     int      GetRowSize( int row );
1910     int      GetDefaultColSize();
1911     int      GetColSize( int col );
1912     wxColour GetDefaultCellBackgroundColour();
1913     wxColour GetCellBackgroundColour( int row, int col );
1914     wxColour GetDefaultCellTextColour();
1915     wxColour GetCellTextColour( int row, int col );
1916     wxFont   GetDefaultCellFont();
1917     wxFont   GetCellFont( int row, int col );
1918
1919     DocDeclA(
1920         void, GetDefaultCellAlignment( int *OUTPUT, int *OUTPUT ),
1921         "GetDefaultCellAlignment() -> (horiz, vert)");
1922
1923     DocDeclA(
1924         void, GetCellAlignment( int row, int col, int *OUTPUT, int *OUTPUT ),
1925         "GetCellAlignment(int row, int col) -> (horiz, vert)");
1926
1927     bool     GetDefaultCellOverflow();
1928     bool     GetCellOverflow( int row, int col );
1929
1930     DocDeclA(
1931         void, GetCellSize( int row, int col, int *OUTPUT, int *OUTPUT ),
1932         "GetCellSize(int row, int col) -> (num_rows, num_cols)");
1933
1934     void     SetDefaultRowSize( int height, bool resizeExistingRows = false );
1935     void     SetRowSize( int row, int height );
1936     void     SetDefaultColSize( int width, bool resizeExistingCols = false );
1937
1938     void     SetColSize( int col, int width );
1939
1940     int GetColAt( int colPos ) const;
1941     void SetColPos( int colID, int newPos );
1942     int GetColPos( int colID ) const;
1943
1944     // automatically size the column or row to fit to its contents, if
1945     // setAsMin is True, this optimal width will also be set as minimal width
1946     // for this column
1947     void     AutoSizeColumn( int col, bool setAsMin = true );
1948     void     AutoSizeRow( int row, bool setAsMin = true );
1949
1950
1951     // auto size all columns (very ineffective for big grids!)
1952     void     AutoSizeColumns( bool setAsMin = true );
1953     void     AutoSizeRows( bool setAsMin = true );
1954
1955     // auto size the grid, that is make the columns/rows of the "right" size
1956     // and also set the grid size to just fit its contents
1957     void     AutoSize();
1958
1959     // autosize row height depending on label text
1960     void     AutoSizeRowLabelSize( int row );
1961
1962     // autosize column width depending on label text
1963     void     AutoSizeColLabelSize( int col );
1964
1965
1966     // column won't be resized to be lesser width - this must be called during
1967     // the grid creation because it won't resize the column if it's already
1968     // narrower than the minimal width
1969     void     SetColMinimalWidth( int col, int width );
1970     void     SetRowMinimalHeight( int row, int width );
1971
1972     void     SetColMinimalAcceptableWidth( int width );
1973     void     SetRowMinimalAcceptableHeight( int width );
1974     int      GetColMinimalAcceptableWidth() const;
1975     int      GetRowMinimalAcceptableHeight() const;
1976
1977     void     SetDefaultCellBackgroundColour( const wxColour& );
1978     void     SetCellBackgroundColour( int row, int col, const wxColour& );
1979     void     SetDefaultCellTextColour( const wxColour& );
1980
1981     void     SetCellTextColour( int row, int col, const wxColour& );
1982     void     SetDefaultCellFont( const wxFont& );
1983     void     SetCellFont( int row, int col, const wxFont& );
1984     void     SetDefaultCellAlignment( int horiz, int vert );
1985     void     SetCellAlignment( int row, int col, int horiz, int vert );
1986     void     SetDefaultCellOverflow( bool allow );
1987     void     SetCellOverflow( int row, int col, bool allow );
1988     void     SetCellSize( int row, int col, int num_rows, int num_cols );
1989
1990     // takes ownership of the pointer
1991     void SetDefaultRenderer(wxGridCellRenderer *renderer);
1992     void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
1993     wxGridCellRenderer *GetDefaultRenderer() const;
1994     wxGridCellRenderer* GetCellRenderer(int row, int col);
1995
1996     // takes ownership of the pointer
1997     void SetDefaultEditor(wxGridCellEditor *editor);
1998     void SetCellEditor(int row, int col, wxGridCellEditor *editor);
1999     wxGridCellEditor *GetDefaultEditor() const;
2000     wxGridCellEditor* GetCellEditor(int row, int col);
2001
2002
2003
2004     // ------ cell value accessors
2005     //
2006     wxString GetCellValue( int row, int col );
2007     // TODO: ??? wxString GetCellValue( const wxGridCellCoords& coords )
2008
2009     void SetCellValue( int row, int col, const wxString& s );
2010     // TODO: ??? void SetCellValue( const wxGridCellCoords& coords, const wxString& s )
2011
2012     // returns True if the cell can't be edited
2013     bool IsReadOnly(int row, int col) const;
2014
2015     // make the cell editable/readonly
2016     void SetReadOnly(int row, int col, bool isReadOnly = true);
2017
2018     // ------ selections of blocks of cells
2019     //
2020     void SelectRow( int row, bool addToSelected = false );
2021     void SelectCol( int col, bool addToSelected = false );
2022
2023     void SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
2024                       bool addToSelected = false );
2025     // TODO: ??? void SelectBlock( const wxGridCellCoords& topLeft,
2026     // TODO: ???                   const wxGridCellCoords& bottomRight )
2027
2028     void SelectAll();
2029     bool IsSelection();
2030     void ClearSelection();
2031     bool IsInSelection( int row, int col );
2032     // TODO: ??? bool IsInSelection( const wxGridCellCoords& coords )
2033
2034     const wxGridCellCoordsArray GetSelectedCells() const;
2035     const wxGridCellCoordsArray GetSelectionBlockTopLeft() const;
2036     const wxGridCellCoordsArray GetSelectionBlockBottomRight() const;
2037     const wxArrayInt GetSelectedRows() const;
2038     const wxArrayInt GetSelectedCols() const;
2039
2040     void DeselectRow( int row );
2041     void DeselectCol( int col );
2042     void DeselectCell( int row, int col );
2043
2044
2045     // This function returns the rectangle that encloses the block of cells
2046     // limited by TopLeft and BottomRight cell in device coords and clipped
2047     //  to the client size of the grid window.
2048     //
2049     wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
2050                               const wxGridCellCoords & bottomRight );
2051
2052
2053     // Access or update the selection fore/back colours
2054     wxColour GetSelectionBackground() const;
2055     wxColour GetSelectionForeground() const;
2056
2057     void SetSelectionBackground(const wxColour& c);
2058     void SetSelectionForeground(const wxColour& c);
2059
2060
2061     // Methods for a registry for mapping data types to Renderers/Editors
2062     void RegisterDataType(const wxString& typeName,
2063                           wxGridCellRenderer* renderer,
2064                           wxGridCellEditor* editor);
2065     wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
2066     // TODO: ??? wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const
2067     wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
2068     wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
2069     wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
2070
2071     // grid may occupy more space than needed for its rows/columns, this
2072     // function allows to set how big this extra space is
2073     void SetMargins(int extraWidth, int extraHeight);
2074
2075
2076     // Accessors for component windows
2077     wxWindow* GetGridWindow();
2078     wxWindow* GetGridRowLabelWindow();
2079     wxWindow* GetGridColLabelWindow();
2080     wxWindow* GetGridCornerLabelWindow();
2081
2082     // Allow adjustment of scroll increment. The default is (15, 15).
2083     void SetScrollLineX(int x);
2084     void SetScrollLineY(int y);
2085     int GetScrollLineX() const;
2086     int GetScrollLineY() const;
2087
2088     int GetScrollX(int x) const;
2089     int GetScrollY(int y) const;
2090
2091     static wxVisualAttributes
2092     GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
2093
2094     %property(BatchCount, GetBatchCount, doc="See `GetBatchCount`");
2095     %property(CellHighlightColour, GetCellHighlightColour, SetCellHighlightColour, doc="See `GetCellHighlightColour` and `SetCellHighlightColour`");
2096     %property(CellHighlightPenWidth, GetCellHighlightPenWidth, SetCellHighlightPenWidth, doc="See `GetCellHighlightPenWidth` and `SetCellHighlightPenWidth`");
2097     %property(CellHighlightROPenWidth, GetCellHighlightROPenWidth, SetCellHighlightROPenWidth, doc="See `GetCellHighlightROPenWidth` and `SetCellHighlightROPenWidth`");
2098     %property(CellSize, GetCellSize, SetCellSize, doc="See `GetCellSize` and `SetCellSize`");
2099     %property(ColLabelAlignment, GetColLabelAlignment, SetColLabelAlignment, doc="See `GetColLabelAlignment` and `SetColLabelAlignment`");
2100     %property(ColLabelSize, GetColLabelSize, SetColLabelSize, doc="See `GetColLabelSize` and `SetColLabelSize`");
2101     %property(ColLabelTextOrientation, GetColLabelTextOrientation, SetColLabelTextOrientation, doc="See `GetColLabelTextOrientation` and `SetColLabelTextOrientation`");
2102     %property(ColMinimalAcceptableWidth, GetColMinimalAcceptableWidth, SetColMinimalAcceptableWidth, doc="See `GetColMinimalAcceptableWidth` and `SetColMinimalAcceptableWidth`");
2103     %property(DefaultCellAlignment, GetDefaultCellAlignment, SetDefaultCellAlignment, doc="See `GetDefaultCellAlignment` and `SetDefaultCellAlignment`");
2104     %property(DefaultCellBackgroundColour, GetDefaultCellBackgroundColour, SetDefaultCellBackgroundColour, doc="See `GetDefaultCellBackgroundColour` and `SetDefaultCellBackgroundColour`");
2105     %property(DefaultCellFont, GetDefaultCellFont, SetDefaultCellFont, doc="See `GetDefaultCellFont` and `SetDefaultCellFont`");
2106     %property(DefaultCellOverflow, GetDefaultCellOverflow, SetDefaultCellOverflow, doc="See `GetDefaultCellOverflow` and `SetDefaultCellOverflow`");
2107     %property(DefaultCellTextColour, GetDefaultCellTextColour, SetDefaultCellTextColour, doc="See `GetDefaultCellTextColour` and `SetDefaultCellTextColour`");
2108     %property(DefaultColLabelSize, GetDefaultColLabelSize, doc="See `GetDefaultColLabelSize`");
2109     %property(DefaultColSize, GetDefaultColSize, SetDefaultColSize, doc="See `GetDefaultColSize` and `SetDefaultColSize`");
2110     %property(DefaultEditor, GetDefaultEditor, SetDefaultEditor, doc="See `GetDefaultEditor` and `SetDefaultEditor`");
2111     %property(DefaultGridLinePen, GetDefaultGridLinePen, doc="See `GetDefaultGridLinePen`");
2112     %property(DefaultRenderer, GetDefaultRenderer, SetDefaultRenderer, doc="See `GetDefaultRenderer` and `SetDefaultRenderer`");
2113     %property(DefaultRowLabelSize, GetDefaultRowLabelSize, doc="See `GetDefaultRowLabelSize`");
2114     %property(DefaultRowSize, GetDefaultRowSize, SetDefaultRowSize, doc="See `GetDefaultRowSize` and `SetDefaultRowSize`");
2115     %property(GridColLabelWindow, GetGridColLabelWindow, doc="See `GetGridColLabelWindow`");
2116     %property(GridCornerLabelWindow, GetGridCornerLabelWindow, doc="See `GetGridCornerLabelWindow`");
2117     %property(GridCursorCol, GetGridCursorCol, doc="See `GetGridCursorCol`");
2118     %property(GridCursorRow, GetGridCursorRow, doc="See `GetGridCursorRow`");
2119     %property(GridLineColour, GetGridLineColour, SetGridLineColour, doc="See `GetGridLineColour` and `SetGridLineColour`");
2120     %property(GridRowLabelWindow, GetGridRowLabelWindow, doc="See `GetGridRowLabelWindow`");
2121     %property(GridWindow, GetGridWindow, doc="See `GetGridWindow`");
2122     %property(LabelBackgroundColour, GetLabelBackgroundColour, SetLabelBackgroundColour, doc="See `GetLabelBackgroundColour` and `SetLabelBackgroundColour`");
2123     %property(LabelFont, GetLabelFont, SetLabelFont, doc="See `GetLabelFont` and `SetLabelFont`");
2124     %property(LabelTextColour, GetLabelTextColour, SetLabelTextColour, doc="See `GetLabelTextColour` and `SetLabelTextColour`");
2125     %property(NumberCols, GetNumberCols, doc="See `GetNumberCols`");
2126     %property(NumberRows, GetNumberRows, doc="See `GetNumberRows`");
2127     %property(RowLabelAlignment, GetRowLabelAlignment, SetRowLabelAlignment, doc="See `GetRowLabelAlignment` and `SetRowLabelAlignment`");
2128     %property(RowLabelSize, GetRowLabelSize, SetRowLabelSize, doc="See `GetRowLabelSize` and `SetRowLabelSize`");
2129     %property(RowMinimalAcceptableHeight, GetRowMinimalAcceptableHeight, SetRowMinimalAcceptableHeight, doc="See `GetRowMinimalAcceptableHeight` and `SetRowMinimalAcceptableHeight`");
2130     %property(ScrollLineX, GetScrollLineX, SetScrollLineX, doc="See `GetScrollLineX` and `SetScrollLineX`");
2131     %property(ScrollLineY, GetScrollLineY, SetScrollLineY, doc="See `GetScrollLineY` and `SetScrollLineY`");
2132     %property(SelectedCells, GetSelectedCells, doc="See `GetSelectedCells`");
2133     %property(SelectedCols, GetSelectedCols, doc="See `GetSelectedCols`");
2134     %property(SelectedRows, GetSelectedRows, doc="See `GetSelectedRows`");
2135     %property(SelectionBackground, GetSelectionBackground, SetSelectionBackground, doc="See `GetSelectionBackground` and `SetSelectionBackground`");
2136     %property(SelectionBlockBottomRight, GetSelectionBlockBottomRight, doc="See `GetSelectionBlockBottomRight`");
2137     %property(SelectionBlockTopLeft, GetSelectionBlockTopLeft, doc="See `GetSelectionBlockTopLeft`");
2138     %property(SelectionForeground, GetSelectionForeground, SetSelectionForeground, doc="See `GetSelectionForeground` and `SetSelectionForeground`");
2139     %property(SelectionMode, GetSelectionMode, SetSelectionMode, doc="See `GetSelectionMode` and `SetSelectionMode`");
2140     %property(Table, GetTable, SetTable, doc="See `GetTable` and `SetTable`");
2141
2142 };
2143
2144
2145 //---------------------------------------------------------------------------
2146 //---------------------------------------------------------------------------
2147 // Grid events and stuff
2148
2149
2150
2151 class wxGridEvent : public wxNotifyEvent
2152 {
2153 public:
2154     wxGridEvent(int id, wxEventType type, wxGrid* obj,
2155                 int row=-1, int col=-1, int x=-1, int y=-1, bool sel = true,
2156                 bool control=false, bool shift=false, bool alt=false, bool meta=false);
2157
2158     virtual int GetRow();
2159     virtual int GetCol();
2160     wxPoint     GetPosition();
2161     bool        Selecting();
2162     bool        ControlDown();
2163     bool        MetaDown();
2164     bool        ShiftDown();
2165     bool        AltDown();
2166     bool        CmdDown();
2167
2168     %property(Col, GetCol, doc="See `GetCol`");
2169     %property(Position, GetPosition, doc="See `GetPosition`");
2170     %property(Row, GetRow, doc="See `GetRow`");
2171 };
2172
2173
2174 class  wxGridSizeEvent : public wxNotifyEvent
2175 {
2176 public:
2177     wxGridSizeEvent(int id, wxEventType type, wxGrid* obj,
2178                 int rowOrCol=-1, int x=-1, int y=-1,
2179                 bool control=false, bool shift=false, bool alt=false, bool meta=false);
2180
2181     int         GetRowOrCol();
2182     wxPoint     GetPosition();
2183     bool        ControlDown();
2184     bool        MetaDown();
2185     bool        ShiftDown();
2186     bool        AltDown();
2187     bool        CmdDown();
2188
2189     %property(Position, GetPosition, doc="See `GetPosition`");
2190     %property(RowOrCol, GetRowOrCol, doc="See `GetRowOrCol`");
2191 };
2192
2193
2194 class wxGridRangeSelectEvent : public wxNotifyEvent
2195 {
2196 public:
2197     wxGridRangeSelectEvent(int id, wxEventType type, wxGrid* obj,
2198                            const wxGridCellCoords& topLeft,
2199                            const wxGridCellCoords& bottomRight,
2200                            bool sel = true,
2201                            bool control=false, bool shift=false,
2202                            bool alt=false, bool meta=false);
2203
2204     wxGridCellCoords GetTopLeftCoords();
2205     wxGridCellCoords GetBottomRightCoords();
2206     int         GetTopRow();
2207     int         GetBottomRow();
2208     int         GetLeftCol();
2209     int         GetRightCol();
2210     bool        Selecting();
2211     bool        ControlDown();
2212     bool        MetaDown();
2213     bool        ShiftDown();
2214     bool        AltDown();
2215     bool        CmdDown();
2216
2217     %property(BottomRightCoords, GetBottomRightCoords, doc="See `GetBottomRightCoords`");
2218     %property(BottomRow, GetBottomRow, doc="See `GetBottomRow`");
2219     %property(LeftCol, GetLeftCol, doc="See `GetLeftCol`");
2220     %property(RightCol, GetRightCol, doc="See `GetRightCol`");
2221     %property(TopLeftCoords, GetTopLeftCoords, doc="See `GetTopLeftCoords`");
2222     %property(TopRow, GetTopRow, doc="See `GetTopRow`");
2223 };
2224
2225
2226 class wxGridEditorCreatedEvent : public wxCommandEvent {
2227 public:
2228     wxGridEditorCreatedEvent(int id, wxEventType type, wxObject* obj,
2229                              int row, int col, wxControl* ctrl);
2230
2231     int GetRow();
2232     int GetCol();
2233     wxControl* GetControl();
2234     void SetRow(int row);
2235     void SetCol(int col);
2236     void SetControl(wxControl* ctrl);
2237
2238     %property(Col, GetCol, SetCol, doc="See `GetCol` and `SetCol`");
2239     %property(Control, GetControl, SetControl, doc="See `GetControl` and `SetControl`");
2240     %property(Row, GetRow, SetRow, doc="See `GetRow` and `SetRow`");
2241 };
2242
2243
2244
2245 %constant wxEventType wxEVT_GRID_CELL_LEFT_CLICK;
2246 %constant wxEventType wxEVT_GRID_CELL_RIGHT_CLICK;
2247 %constant wxEventType wxEVT_GRID_CELL_LEFT_DCLICK;
2248 %constant wxEventType wxEVT_GRID_CELL_RIGHT_DCLICK;
2249 %constant wxEventType wxEVT_GRID_LABEL_LEFT_CLICK;
2250 %constant wxEventType wxEVT_GRID_LABEL_RIGHT_CLICK;
2251 %constant wxEventType wxEVT_GRID_LABEL_LEFT_DCLICK;
2252 %constant wxEventType wxEVT_GRID_LABEL_RIGHT_DCLICK;
2253 %constant wxEventType wxEVT_GRID_ROW_SIZE;
2254 %constant wxEventType wxEVT_GRID_COL_SIZE;
2255 %constant wxEventType wxEVT_GRID_RANGE_SELECT;
2256 %constant wxEventType wxEVT_GRID_CELL_CHANGE;
2257 %constant wxEventType wxEVT_GRID_SELECT_CELL;
2258 %constant wxEventType wxEVT_GRID_EDITOR_SHOWN;
2259 %constant wxEventType wxEVT_GRID_EDITOR_HIDDEN;
2260 %constant wxEventType wxEVT_GRID_EDITOR_CREATED;
2261 %constant wxEventType wxEVT_GRID_CELL_BEGIN_DRAG;
2262
2263
2264
2265 %pythoncode {
2266 EVT_GRID_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK )
2267 EVT_GRID_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK )
2268 EVT_GRID_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK )
2269 EVT_GRID_CELL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK )
2270 EVT_GRID_LABEL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK )
2271 EVT_GRID_LABEL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK )
2272 EVT_GRID_LABEL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK )
2273 EVT_GRID_LABEL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK )
2274 EVT_GRID_ROW_SIZE = wx.PyEventBinder( wxEVT_GRID_ROW_SIZE )
2275 EVT_GRID_COL_SIZE = wx.PyEventBinder( wxEVT_GRID_COL_SIZE )
2276 EVT_GRID_RANGE_SELECT = wx.PyEventBinder( wxEVT_GRID_RANGE_SELECT )
2277 EVT_GRID_CELL_CHANGE = wx.PyEventBinder( wxEVT_GRID_CELL_CHANGE )
2278 EVT_GRID_SELECT_CELL = wx.PyEventBinder( wxEVT_GRID_SELECT_CELL )
2279 EVT_GRID_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN )
2280 EVT_GRID_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN )
2281 EVT_GRID_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED )
2282 EVT_GRID_CELL_BEGIN_DRAG = wx.PyEventBinder( wxEVT_GRID_CELL_BEGIN_DRAG )
2283
2284
2285 %# The same as above but with the ability to specify an identifier
2286 EVT_GRID_CMD_CELL_LEFT_CLICK =     wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK,    1 )
2287 EVT_GRID_CMD_CELL_RIGHT_CLICK =    wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK,   1 )
2288 EVT_GRID_CMD_CELL_LEFT_DCLICK =    wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK,   1 )
2289 EVT_GRID_CMD_CELL_RIGHT_DCLICK =   wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK,  1 )
2290 EVT_GRID_CMD_LABEL_LEFT_CLICK =    wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK,   1 )
2291 EVT_GRID_CMD_LABEL_RIGHT_CLICK =   wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK,  1 )
2292 EVT_GRID_CMD_LABEL_LEFT_DCLICK =   wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK,  1 )
2293 EVT_GRID_CMD_LABEL_RIGHT_DCLICK =  wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK, 1 )
2294 EVT_GRID_CMD_ROW_SIZE =            wx.PyEventBinder( wxEVT_GRID_ROW_SIZE,           1 )
2295 EVT_GRID_CMD_COL_SIZE =            wx.PyEventBinder( wxEVT_GRID_COL_SIZE,           1 )
2296 EVT_GRID_CMD_RANGE_SELECT =        wx.PyEventBinder( wxEVT_GRID_RANGE_SELECT,       1 )
2297 EVT_GRID_CMD_CELL_CHANGE =         wx.PyEventBinder( wxEVT_GRID_CELL_CHANGE,        1 )
2298 EVT_GRID_CMD_SELECT_CELL =         wx.PyEventBinder( wxEVT_GRID_SELECT_CELL,        1 )
2299 EVT_GRID_CMD_EDITOR_SHOWN =        wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN,       1 )
2300 EVT_GRID_CMD_EDITOR_HIDDEN =       wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN,      1 )
2301 EVT_GRID_CMD_EDITOR_CREATED =      wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED,     1 )
2302 EVT_GRID_CMD_CELL_BEGIN_DRAG =     wx.PyEventBinder( wxEVT_GRID_CELL_BEGIN_DRAG,    1 )
2303
2304 }
2305
2306 //---------------------------------------------------------------------------
2307
2308 %init %{
2309 %}
2310
2311 //---------------------------------------------------------------------------
2312 //---------------------------------------------------------------------------
2313