| 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._setCallbackInfo(self, PyGridCellRenderer);self._setOORInfo(self)" |
| 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._setCallbackInfo(self, PyGridCellEditor);self._setOORInfo(self)" |
| 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 "self._setCallbackInfo(self, 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._setCallbackInfo(self, PyGridTableBase);self._setOORInfo(self)" |
| 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 | |