]> git.saurik.com Git - wxWidgets.git/blame_incremental - wxPython/src/grid.i
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Add wxPyTabArt
[wxWidgets.git] / wxPython / src / grid.i
... / ...
CommitLineData
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
38MAKE_CONST_WXSTRING_NOSWIG(EmptyString);
39MAKE_CONST_WXSTRING_NOSWIG(GridNameStr);
40MAKE_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) \
55PyObject* 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
80wxPyMake_TEMPLATE(wxGridCellRenderer)
81wxPyMake_TEMPLATE(wxGridCellEditor)
82wxPyMake_TEMPLATE(wxGridCellAttr)
83wxPyMake_TEMPLATE(wxGridCellAttrProvider)
84wxPyMake_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
444class wxGridCellCoords;
445class 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;
459const wxGridCellCoords wxGridNoCellCoords;
460const 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
477enum {
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
499class wxGridCellWorker
500{
501public:
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
524class wxGridCellRenderer : public wxGridCellWorker
525{
526public:
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%{
546class wxPyGridCellRenderer : public wxGridCellRenderer
547{
548public:
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
638IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
639
640%}
641
642
643// Let SWIG know about it so it can create the Python version
644class wxPyGridCellRenderer : public wxGridCellRenderer {
645public:
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
658class wxGridCellStringRenderer : public wxGridCellRenderer
659{
660public:
661 %pythonAppend wxGridCellStringRenderer "self._setOORInfo(self)"
662 wxGridCellStringRenderer();
663};
664
665
666class wxGridCellNumberRenderer : public wxGridCellStringRenderer
667{
668public:
669 %pythonAppend wxGridCellNumberRenderer "self._setOORInfo(self)"
670 wxGridCellNumberRenderer();
671};
672
673
674class wxGridCellFloatRenderer : public wxGridCellStringRenderer
675{
676public:
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
690class wxGridCellBoolRenderer : public wxGridCellRenderer
691{
692public:
693 %pythonAppend wxGridCellBoolRenderer "self._setOORInfo(self)"
694 wxGridCellBoolRenderer();
695};
696
697
698class wxGridCellDateTimeRenderer : public wxGridCellStringRenderer
699{
700public:
701 %pythonAppend wxGridCellDateTimeRenderer "self._setOORInfo(self)"
702 wxGridCellDateTimeRenderer(wxString outformat = wxPyDefaultDateTimeFormat,
703 wxString informat = wxPyDefaultDateTimeFormat);
704};
705
706
707class wxGridCellEnumRenderer : public wxGridCellStringRenderer
708{
709public:
710 %pythonAppend wxGridCellEnumRenderer "self._setOORInfo(self)"
711 wxGridCellEnumRenderer( const wxString& choices = wxPyEmptyString );
712};
713
714
715class wxGridCellAutoWrapStringRenderer : public wxGridCellStringRenderer
716{
717public:
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
727class wxGridCellEditor : public wxGridCellWorker
728{
729public:
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%{
763class wxPyGridCellEditor : public wxGridCellEditor
764{
765public:
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
870IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
871IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
872IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
873IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
874IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
875IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
876IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
877IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
878IMP_PYCALLBACK_STRING__constpure(wxPyGridCellEditor, wxGridCellEditor, GetValue);
879
880%}
881
882
883// Let SWIG know about it so it can create the Python version
884class wxPyGridCellEditor : public wxGridCellEditor {
885public:
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
915class wxGridCellTextEditor : public wxGridCellEditor
916{
917public:
918 %pythonAppend wxGridCellTextEditor "self._setOORInfo(self)"
919 wxGridCellTextEditor();
920 virtual wxString GetValue();
921
922 %property(Value, GetValue, doc="See `GetValue`");
923};
924
925
926class wxGridCellNumberEditor : public wxGridCellTextEditor
927{
928public:
929 %pythonAppend wxGridCellNumberEditor "self._setOORInfo(self)"
930 wxGridCellNumberEditor(int min = -1, int max = -1);
931};
932
933
934class wxGridCellFloatEditor : public wxGridCellTextEditor
935{
936public:
937 %pythonAppend wxGridCellFloatEditor "self._setOORInfo(self)"
938 wxGridCellFloatEditor(int width = -1, int precision = -1);
939};
940
941
942MAKE_CONST_WXSTRING2(OneString, _T("1"));
943class wxGridCellBoolEditor : public wxGridCellEditor
944{
945public:
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
960class wxGridCellChoiceEditor : public wxGridCellEditor
961{
962public:
963 %pythonAppend wxGridCellChoiceEditor "self._setOORInfo(self)"
964 wxGridCellChoiceEditor(int choices = 0,
965 const wxString* choices_array = NULL,
966 bool allowOthers = false);
967};
968
969
970class wxGridCellEnumEditor : public wxGridCellChoiceEditor
971{
972public:
973 %pythonAppend wxGridCellEnumEditor "self._setOORInfo(self)"
974 wxGridCellEnumEditor( const wxString& choices = wxPyEmptyString );
975};
976
977
978class wxGridCellAutoWrapStringEditor : public wxGridCellTextEditor
979{
980public:
981 %pythonAppend wxGridCellAutoWrapStringEditor "self._setOORInfo(self)"
982 wxGridCellAutoWrapStringEditor();
983};
984
985
986
987//---------------------------------------------------------------------------
988
989
990class wxGridCellAttr
991{
992public:
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
1079class wxGridCellAttrProvider
1080{
1081public:
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%{
1107class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
1108{
1109public:
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
1123class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
1124{
1125public:
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
1147class wxGridTableBase : public wxObject
1148{
1149public:
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%{
1219class wxPyGridTableBase : public wxGridTableBase
1220{
1221public:
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
1352class wxPyGridTableBase : public wxGridTableBase
1353{
1354public:
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
1408class wxGridStringTable : public wxGridTableBase
1409{
1410public:
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
1419enum 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
1432class wxGridTableMessage
1433{
1434public:
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%{
1471bool 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
1507bool 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%{
1535PyObject* 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
1555class wxGridCellCoords
1556{
1557public:
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
1626typedef int WXGRIDSELECTIONMODES;
1627
1628// but let the C++ code know what it really is.
1629%{
1630typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
1631%}
1632
1633
1634
1635MustHaveApp(wxGrid);
1636
1637class wxGrid : public wxScrolledWindow
1638{
1639public:
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
2151class wxGridEvent : public wxNotifyEvent
2152{
2153public:
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
2174class wxGridSizeEvent : public wxNotifyEvent
2175{
2176public:
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
2194class wxGridRangeSelectEvent : public wxNotifyEvent
2195{
2196public:
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
2226class wxGridEditorCreatedEvent : public wxCommandEvent {
2227public:
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 {
2266EVT_GRID_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK )
2267EVT_GRID_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK )
2268EVT_GRID_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK )
2269EVT_GRID_CELL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK )
2270EVT_GRID_LABEL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK )
2271EVT_GRID_LABEL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK )
2272EVT_GRID_LABEL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK )
2273EVT_GRID_LABEL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK )
2274EVT_GRID_ROW_SIZE = wx.PyEventBinder( wxEVT_GRID_ROW_SIZE )
2275EVT_GRID_COL_SIZE = wx.PyEventBinder( wxEVT_GRID_COL_SIZE )
2276EVT_GRID_RANGE_SELECT = wx.PyEventBinder( wxEVT_GRID_RANGE_SELECT )
2277EVT_GRID_CELL_CHANGE = wx.PyEventBinder( wxEVT_GRID_CELL_CHANGE )
2278EVT_GRID_SELECT_CELL = wx.PyEventBinder( wxEVT_GRID_SELECT_CELL )
2279EVT_GRID_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN )
2280EVT_GRID_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN )
2281EVT_GRID_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED )
2282EVT_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
2286EVT_GRID_CMD_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK, 1 )
2287EVT_GRID_CMD_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK, 1 )
2288EVT_GRID_CMD_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK, 1 )
2289EVT_GRID_CMD_CELL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK, 1 )
2290EVT_GRID_CMD_LABEL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK, 1 )
2291EVT_GRID_CMD_LABEL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK, 1 )
2292EVT_GRID_CMD_LABEL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK, 1 )
2293EVT_GRID_CMD_LABEL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK, 1 )
2294EVT_GRID_CMD_ROW_SIZE = wx.PyEventBinder( wxEVT_GRID_ROW_SIZE, 1 )
2295EVT_GRID_CMD_COL_SIZE = wx.PyEventBinder( wxEVT_GRID_COL_SIZE, 1 )
2296EVT_GRID_CMD_RANGE_SELECT = wx.PyEventBinder( wxEVT_GRID_RANGE_SELECT, 1 )
2297EVT_GRID_CMD_CELL_CHANGE = wx.PyEventBinder( wxEVT_GRID_CELL_CHANGE, 1 )
2298EVT_GRID_CMD_SELECT_CELL = wx.PyEventBinder( wxEVT_GRID_SELECT_CELL, 1 )
2299EVT_GRID_CMD_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN, 1 )
2300EVT_GRID_CMD_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN, 1 )
2301EVT_GRID_CMD_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED, 1 )
2302EVT_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
wxWidgets (Impactor)