9416aa89ca
text in the demo for more details of what this means, but in a nutshell methods such as wxWindow.GetParent or FindWindowById will now return a shadow object of the proper type if it can. By "proper type" I mean that if the wxWindow pointer returned from FindWindowById really points to a wxButton then the Python object constructed will be of a wxButtonPtr class instead of wxWindowPtr as before. This should reduce or eliminiate the need for wxPyTypeCast. (Woo Hoo!) The objects returned are still not the original Python object, but that is the next step. (Although it will probably only work on Python 2.1 and beyond because it will use weak references.) A few other minor tweaks and fixes and additions for things found while doing the OOR stuff. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@10197 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1779 lines
66 KiB
OpenEdge ABL
1779 lines
66 KiB
OpenEdge ABL
/////////////////////////////////////////////////////////////////////////////
|
|
// Name: grid.i
|
|
// Purpose: SWIG definitions for the new wxGrid and related classes
|
|
//
|
|
// Author: Robin Dunn
|
|
//
|
|
// Created: 17-March-2000
|
|
// RCS-ID: $Id$
|
|
// Copyright: (c) 2000 by Total Control Software
|
|
// Licence: wxWindows license
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
%module grid
|
|
|
|
#ifndef OLD_GRID
|
|
|
|
%{
|
|
#include "export.h"
|
|
#include <wx/grid.h>
|
|
%}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
%include typemaps.i
|
|
%include my_typemaps.i
|
|
|
|
// Import some definitions of other classes, etc.
|
|
%import _defs.i
|
|
%import misc.i
|
|
%import gdi.i
|
|
%import windows.i
|
|
%import controls.i
|
|
%import events.i
|
|
|
|
%pragma(python) code = "import wx"
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
// Macros, similar to what's in helpers.h, to aid in the creation of
|
|
// virtual methods that are able to make callbacks to Python. Many of these
|
|
// are specific to wxGrid and so are kept here to reduce the mess in helpers.h
|
|
// a bit.
|
|
|
|
|
|
%{
|
|
#define PYCALLBACK_GCA_INTINTKIND(PCLASS, CBNAME) \
|
|
wxGridCellAttr* CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
|
|
wxGridCellAttr* rval = NULL; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* ro; \
|
|
wxGridCellAttr* ptr; \
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(iii)", a, b, c)); \
|
|
if (ro) { \
|
|
if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellAttr_p")) \
|
|
rval = ptr; \
|
|
Py_DECREF(ro); \
|
|
} \
|
|
} \
|
|
else \
|
|
rval = PCLASS::CBNAME(a, b, c); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
wxGridCellAttr *base_##CBNAME(int a, int b, wxGridCellAttr::wxAttrKind c) { \
|
|
return PCLASS::CBNAME(a, b, c); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__GCAINTINT(PCLASS, CBNAME) \
|
|
void CBNAME(wxGridCellAttr *attr, int a, int b) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oii)", obj, a, b)); \
|
|
Py_DECREF(obj); \
|
|
} \
|
|
else \
|
|
PCLASS::CBNAME(attr, a, b); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(wxGridCellAttr *attr, int a, int b) { \
|
|
PCLASS::CBNAME(attr, a, b); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__GCAINT(PCLASS, CBNAME) \
|
|
void CBNAME(wxGridCellAttr *attr, int val) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* obj = wxPyConstructObject((void*)attr, "wxGridCellAttr", 0);\
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", obj, val)); \
|
|
Py_DECREF(obj); \
|
|
} \
|
|
else \
|
|
PCLASS::CBNAME(attr, val); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(wxGridCellAttr *attr, int val) { \
|
|
PCLASS::CBNAME(attr, val); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_INT__pure(CBNAME) \
|
|
int CBNAME() { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
int rval = 0; \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_BOOL_INTINT_pure(CBNAME) \
|
|
bool CBNAME(int a, int b) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
bool rval = 0; \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)",a,b)); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_STRING_INTINT_pure(CBNAME) \
|
|
wxString CBNAME(int a, int b) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
wxString rval; \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* ro; \
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
|
|
if (ro) { \
|
|
PyObject* str = PyObject_Str(ro); \
|
|
rval = PyString_AsString(str); \
|
|
Py_DECREF(ro); Py_DECREF(str); \
|
|
} \
|
|
} \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__INTINTSTRING_pure(CBNAME) \
|
|
void CBNAME(int a, int b, const wxString& c) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",a,b,c.c_str())); \
|
|
wxPySaveThread(doSave); \
|
|
}
|
|
|
|
|
|
#define PYCALLBACK_STRING_INTINT(PCLASS, CBNAME) \
|
|
wxString CBNAME(int a, int b) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
wxString rval; \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* ro; \
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
|
|
if (ro) { \
|
|
PyObject* str = PyObject_Str(ro); \
|
|
rval = PyString_AsString(str); \
|
|
Py_DECREF(ro); Py_DECREF(str); \
|
|
} \
|
|
} else \
|
|
rval = PCLASS::CBNAME(a, b); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
wxString base_##CBNAME(int a, int b) { \
|
|
return PCLASS::CBNAME(a, b); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_BOOL_INTINTSTRING(PCLASS, CBNAME) \
|
|
bool CBNAME(int a, int b, const wxString& c) { \
|
|
bool rval; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)", a,b,c.c_str())); \
|
|
else \
|
|
rval = PCLASS::CBNAME(a,b,c); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
bool base_##CBNAME(int a, int b, const wxString& c) { \
|
|
return PCLASS::CBNAME(a,b,c); \
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PYCALLBACK_LONG_INTINT(PCLASS, CBNAME) \
|
|
long CBNAME(int a, int b) { \
|
|
long rval; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
|
|
else \
|
|
rval = PCLASS::CBNAME(a,b); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
long base_##CBNAME(int a, int b) { \
|
|
return PCLASS::CBNAME(a,b); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_BOOL_INTINT(PCLASS, CBNAME) \
|
|
bool CBNAME(int a, int b) { \
|
|
bool rval; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
|
|
else \
|
|
rval = PCLASS::CBNAME(a,b); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
bool base_##CBNAME(int a, int b) { \
|
|
return PCLASS::CBNAME(a,b); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_DOUBLE_INTINT(PCLASS, CBNAME) \
|
|
double CBNAME(int a, int b) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
double rval; \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* ro; \
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",a,b)); \
|
|
if (ro) { \
|
|
PyObject* str = PyObject_Str(ro); \
|
|
rval = PyFloat_AsDouble(str); \
|
|
Py_DECREF(ro); Py_DECREF(str); \
|
|
} \
|
|
} else \
|
|
rval = PCLASS::CBNAME(a, b); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
double base_##CBNAME(int a, int b) { \
|
|
return PCLASS::CBNAME(a, b); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__(PCLASS, CBNAME) \
|
|
void CBNAME() { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
|
|
else \
|
|
PCLASS::CBNAME(); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME() { \
|
|
PCLASS::CBNAME(); \
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PYCALLBACK_BOOL_SIZETSIZET(PCLASS, CBNAME) \
|
|
bool CBNAME(size_t a, size_t b) { \
|
|
bool rval; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
|
|
else \
|
|
rval = PCLASS::CBNAME(a,b); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
bool base_##CBNAME(size_t a, size_t b) { \
|
|
return PCLASS::CBNAME(a,b); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_BOOL_SIZET(PCLASS, CBNAME) \
|
|
bool CBNAME(size_t a) { \
|
|
bool rval; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(i)", a)); \
|
|
else \
|
|
rval = PCLASS::CBNAME(a); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
bool base_##CBNAME(size_t a) { \
|
|
return PCLASS::CBNAME(a); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK_STRING_INT(PCLASS, CBNAME) \
|
|
wxString CBNAME(int a) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
wxString rval; \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) { \
|
|
PyObject* ro; \
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(i)",a)); \
|
|
if (ro) { \
|
|
PyObject* str = PyObject_Str(ro); \
|
|
rval = PyString_AsString(str); \
|
|
Py_DECREF(ro); Py_DECREF(str); \
|
|
} \
|
|
} else \
|
|
rval = PCLASS::CBNAME(a); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
wxString base_##CBNAME(int a) { \
|
|
return PCLASS::CBNAME(a); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__INTSTRING(PCLASS, CBNAME) \
|
|
void CBNAME(int a, const wxString& c) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(is)", a,c.c_str())); \
|
|
else \
|
|
PCLASS::CBNAME(a,c); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(int a, const wxString& c) { \
|
|
PCLASS::CBNAME(a,c); \
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PYCALLBACK_BOOL_(PCLASS, CBNAME) \
|
|
bool CBNAME() { \
|
|
bool rval; \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("()")); \
|
|
else \
|
|
rval = PCLASS::CBNAME(); \
|
|
wxPySaveThread(doSave); \
|
|
return rval; \
|
|
} \
|
|
bool base_##CBNAME() { \
|
|
return PCLASS::CBNAME(); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__SIZETINT(PCLASS, CBNAME) \
|
|
void CBNAME(size_t a, int b) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(ii)", a,b)); \
|
|
else \
|
|
PCLASS::CBNAME(a,b); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(size_t a, int b) { \
|
|
PCLASS::CBNAME(a,b); \
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PYCALLBACK__INTINTLONG(PCLASS, CBNAME) \
|
|
void CBNAME(int a, int b, long c) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
|
|
else \
|
|
PCLASS::CBNAME(a,b,c); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(int a, int b, long c) { \
|
|
PCLASS::CBNAME(a,b,c); \
|
|
}
|
|
|
|
|
|
|
|
|
|
#define PYCALLBACK__INTINTDOUBLE(PCLASS, CBNAME) \
|
|
void CBNAME(int a, int b, double c) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iif)", a,b,c)); \
|
|
else \
|
|
PCLASS::CBNAME(a,b,c); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(int a, int b, double c) { \
|
|
PCLASS::CBNAME(a,b,c); \
|
|
}
|
|
|
|
|
|
|
|
#define PYCALLBACK__INTINTBOOL(PCLASS, CBNAME) \
|
|
void CBNAME(int a, int b, bool c) { \
|
|
bool doSave = wxPyRestoreThread(); \
|
|
if (wxPyCBH_findCallback(m_myInst, #CBNAME)) \
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", a,b,c)); \
|
|
else \
|
|
PCLASS::CBNAME(a,b,c); \
|
|
wxPySaveThread(doSave); \
|
|
} \
|
|
void base_##CBNAME(int a, int b, bool c) { \
|
|
PCLASS::CBNAME(a,b,c); \
|
|
}
|
|
|
|
|
|
|
|
|
|
%}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
class wxGridCellCoords;
|
|
class wxGridCellAttr;
|
|
|
|
|
|
|
|
#define wxGRID_VALUE_STRING "string"
|
|
#define wxGRID_VALUE_BOOL "bool"
|
|
#define wxGRID_VALUE_NUMBER "long"
|
|
#define wxGRID_VALUE_FLOAT "double"
|
|
#define wxGRID_VALUE_CHOICE "choice"
|
|
#define wxGRID_VALUE_TEXT "string"
|
|
#define wxGRID_VALUE_LONG "long"
|
|
|
|
%readonly
|
|
wxGridCellCoords wxGridNoCellCoords;
|
|
wxRect wxGridNoCellRect;
|
|
%readwrite
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// wxGridCellRenderer is an ABC, and several derived classes are available.
|
|
// Classes implemented in Python should be derived from wxPyGridCellRenderer.
|
|
|
|
|
|
class wxGridCellRenderer
|
|
{
|
|
public:
|
|
void SetParameters(const wxString& params);
|
|
void IncRef();
|
|
void DecRef();
|
|
|
|
virtual void Draw(wxGrid& grid,
|
|
wxGridCellAttr& attr,
|
|
wxDC& dc,
|
|
const wxRect& rect,
|
|
int row, int col,
|
|
bool isSelected) = 0;
|
|
virtual wxSize GetBestSize(wxGrid& grid,
|
|
wxGridCellAttr& attr,
|
|
wxDC& dc,
|
|
int row, int col) = 0;
|
|
virtual wxGridCellRenderer *Clone() const = 0;
|
|
};
|
|
|
|
|
|
// The C++ version of wxPyGridCellRenderer
|
|
%{
|
|
class wxPyGridCellRenderer : public wxGridCellRenderer
|
|
{
|
|
public:
|
|
wxPyGridCellRenderer() : wxGridCellRenderer() {};
|
|
|
|
// Implement Python callback aware virtual methods
|
|
void Draw(wxGrid& grid, wxGridCellAttr& attr,
|
|
wxDC& dc, const wxRect& rect,
|
|
int row, int col, bool isSelected) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "Draw")) {
|
|
wxPyCBH_callCallback(m_myInst,
|
|
Py_BuildValue("(OOOOiii)",
|
|
wxPyConstructObject((void*)&grid, "wxGrid", 0),
|
|
wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
|
|
wxPyConstructObject((void*)&dc, "wxDC", 0),
|
|
wxPyConstructObject((void*)&rect, "wxRect", 0),
|
|
row, col, isSelected));
|
|
}
|
|
wxPySaveThread(doSave);
|
|
}
|
|
|
|
wxSize GetBestSize(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
|
|
int row, int col) {
|
|
wxSize rval;
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "GetBestSize")) {
|
|
PyObject* ro;
|
|
wxSize* ptr;
|
|
ro = wxPyCBH_callCallbackObj(m_myInst,
|
|
Py_BuildValue("(OOOii)",
|
|
wxPyConstructObject((void*)&grid, "wxGrid", 0),
|
|
wxPyConstructObject((void*)&attr, "wxGridCellAttr", 0),
|
|
wxPyConstructObject((void*)&dc, "wxDC", 0),
|
|
row, col));
|
|
if (ro) {
|
|
if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxSize_p"))
|
|
rval = *ptr;
|
|
Py_DECREF(ro);
|
|
}
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rval;
|
|
}
|
|
|
|
|
|
wxGridCellRenderer *Clone() const {
|
|
wxGridCellRenderer* rval = NULL;
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "Clone")) {
|
|
PyObject* ro;
|
|
wxGridCellRenderer* ptr;
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
|
|
if (ro) {
|
|
if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellRenderer_p"))
|
|
rval = ptr;
|
|
Py_DECREF(ro);
|
|
}
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rval;
|
|
}
|
|
|
|
DEC_PYCALLBACK__STRING(SetParameters);
|
|
|
|
PYPRIVATE;
|
|
};
|
|
|
|
IMP_PYCALLBACK__STRING( wxPyGridCellRenderer, wxGridCellRenderer, SetParameters);
|
|
|
|
%}
|
|
|
|
|
|
// Let SWIG know about it so it can create the Python version
|
|
class wxPyGridCellRenderer : public wxGridCellRenderer {
|
|
public:
|
|
wxPyGridCellRenderer();
|
|
void _setSelf(PyObject* self, PyObject* _class);
|
|
%pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridCellRenderer)"
|
|
|
|
void base_SetParameters(const wxString& params);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Predefined Renderers
|
|
|
|
class wxGridCellStringRenderer : public wxGridCellRenderer
|
|
{
|
|
public:
|
|
wxGridCellStringRenderer();
|
|
};
|
|
|
|
|
|
class wxGridCellNumberRenderer : public wxGridCellStringRenderer
|
|
{
|
|
public:
|
|
wxGridCellNumberRenderer();
|
|
};
|
|
|
|
|
|
class wxGridCellFloatRenderer : public wxGridCellStringRenderer
|
|
{
|
|
public:
|
|
wxGridCellFloatRenderer(int width = -1, int precision = -1);
|
|
|
|
int GetWidth() const;
|
|
void SetWidth(int width);
|
|
int GetPrecision() const;
|
|
void SetPrecision(int precision);
|
|
};
|
|
|
|
|
|
class wxGridCellBoolRenderer : public wxGridCellRenderer
|
|
{
|
|
public:
|
|
wxGridCellBoolRenderer();
|
|
};
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// wxGridCellEditor is an ABC, and several derived classes are available.
|
|
// Classes implemented in Python should be derived from wxPyGridCellEditor.
|
|
|
|
class wxGridCellEditor
|
|
{
|
|
public:
|
|
bool IsCreated();
|
|
wxControl* GetControl();
|
|
void SetControl(wxControl* control);
|
|
|
|
void SetParameters(const wxString& params);
|
|
void IncRef();
|
|
void DecRef();
|
|
|
|
virtual void Create(wxWindow* parent,
|
|
wxWindowID id,
|
|
wxEvtHandler* evtHandler) = 0;
|
|
virtual void BeginEdit(int row, int col, wxGrid* grid) = 0;
|
|
virtual bool EndEdit(int row, int col, wxGrid* grid) = 0;
|
|
virtual void Reset() = 0;
|
|
virtual wxGridCellEditor *Clone() const = 0;
|
|
|
|
virtual void SetSize(const wxRect& rect);
|
|
virtual void Show(bool show, wxGridCellAttr *attr = NULL);
|
|
virtual void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
|
|
virtual bool IsAcceptedKey(wxKeyEvent& event);
|
|
virtual void StartingKey(wxKeyEvent& event);
|
|
virtual void StartingClick();
|
|
virtual void HandleReturn(wxKeyEvent& event);
|
|
virtual void Destroy();
|
|
|
|
};
|
|
|
|
|
|
// The C++ version of wxPyGridCellEditor
|
|
%{
|
|
class wxPyGridCellEditor : public wxGridCellEditor
|
|
{
|
|
public:
|
|
wxPyGridCellEditor() : wxGridCellEditor() {}
|
|
|
|
void Create(wxWindow* parent, wxWindowID id, wxEvtHandler* evtHandler) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "Create")) {
|
|
wxPyCBH_callCallback(m_myInst,
|
|
Py_BuildValue("(OiO)",
|
|
wxPyConstructObject((void*)parent, "wxWindow", 0),
|
|
id,
|
|
wxPyConstructObject((void*)evtHandler, "wxEvtHandler", 0)));
|
|
}
|
|
wxPySaveThread(doSave);
|
|
}
|
|
|
|
|
|
void BeginEdit(int row, int col, wxGrid* grid) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "BeginEdit")) {
|
|
wxPyCBH_callCallback(m_myInst,
|
|
Py_BuildValue("(iiO)", row, col,
|
|
wxPyConstructObject((void*)grid, "wxGrid", 0)));
|
|
}
|
|
wxPySaveThread(doSave);
|
|
}
|
|
|
|
|
|
bool EndEdit(int row, int col, wxGrid* grid) {
|
|
bool rv = FALSE;
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "EndEdit")) {
|
|
rv = wxPyCBH_callCallback(m_myInst,
|
|
Py_BuildValue("(iiO)", row, col,
|
|
wxPyConstructObject((void*)grid, "wxGrid", 0)));
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rv;
|
|
}
|
|
|
|
|
|
wxGridCellEditor*Clone() const {
|
|
wxGridCellEditor* rval = NULL;
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "Clone")) {
|
|
PyObject* ro;
|
|
wxGridCellEditor* ptr;
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
|
|
if (ro) {
|
|
if (!SWIG_GetPtrObj(ro, (void **)&ptr, "_wxGridCellEditor_p"))
|
|
rval = ptr;
|
|
Py_DECREF(ro);
|
|
}
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rval;
|
|
}
|
|
|
|
|
|
void Show(bool show, wxGridCellAttr *attr) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "Show"))
|
|
wxPyCBH_callCallback(m_myInst,
|
|
Py_BuildValue("(iO)", show,
|
|
wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
|
|
else
|
|
wxGridCellEditor::Show(show, attr);
|
|
wxPySaveThread(doSave);
|
|
}
|
|
void base_Show(bool show, wxGridCellAttr *attr) {
|
|
wxGridCellEditor::Show(show, attr);
|
|
}
|
|
|
|
|
|
void PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "PaintBackground"))
|
|
wxPyCBH_callCallback(m_myInst,
|
|
Py_BuildValue("(OO)",
|
|
wxPyConstructObject((void*)&rectCell, "wxRect", 0),
|
|
wxPyConstructObject((void*)attr, "wxGridCellAttr", 0)));
|
|
else
|
|
wxGridCellEditor::PaintBackground(rectCell, attr);
|
|
wxPySaveThread(doSave);
|
|
}
|
|
void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr) {
|
|
wxGridCellEditor::PaintBackground(rectCell, attr);
|
|
}
|
|
|
|
|
|
DEC_PYCALLBACK___pure(Reset);
|
|
DEC_PYCALLBACK__constany(SetSize, wxRect);
|
|
DEC_PYCALLBACK_bool_any(IsAcceptedKey, wxKeyEvent);
|
|
DEC_PYCALLBACK__any(StartingKey, wxKeyEvent);
|
|
DEC_PYCALLBACK__any(HandleReturn, wxKeyEvent);
|
|
DEC_PYCALLBACK__(StartingClick);
|
|
DEC_PYCALLBACK__(Destroy);
|
|
DEC_PYCALLBACK__STRING(SetParameters);
|
|
|
|
PYPRIVATE;
|
|
};
|
|
|
|
|
|
IMP_PYCALLBACK__STRING( wxPyGridCellEditor, wxGridCellEditor, SetParameters);
|
|
IMP_PYCALLBACK___pure(wxPyGridCellEditor, wxGridCellEditor, Reset);
|
|
IMP_PYCALLBACK__constany(wxPyGridCellEditor, wxGridCellEditor, SetSize, wxRect);
|
|
IMP_PYCALLBACK_bool_any(wxPyGridCellEditor, wxGridCellEditor, IsAcceptedKey, wxKeyEvent);
|
|
IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, StartingKey, wxKeyEvent);
|
|
IMP_PYCALLBACK__any(wxPyGridCellEditor, wxGridCellEditor, HandleReturn, wxKeyEvent);
|
|
IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, StartingClick);
|
|
IMP_PYCALLBACK__(wxPyGridCellEditor, wxGridCellEditor, Destroy);
|
|
|
|
%}
|
|
|
|
|
|
// Let SWIG know about it so it can create the Python version
|
|
class wxPyGridCellEditor : public wxGridCellEditor {
|
|
public:
|
|
wxPyGridCellEditor();
|
|
void _setSelf(PyObject* self, PyObject* _class);
|
|
%pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridCellEditor)"
|
|
|
|
void base_SetSize(const wxRect& rect);
|
|
void base_Show(bool show, wxGridCellAttr *attr = NULL);
|
|
void base_PaintBackground(const wxRect& rectCell, wxGridCellAttr *attr);
|
|
void base_IsAcceptedKey(wxKeyEvent& event);
|
|
void base_StartingKey(wxKeyEvent& event);
|
|
void base_StartingClick();
|
|
void base_HandleReturn(wxKeyEvent& event);
|
|
void base_Destroy();
|
|
void base_SetParameters(const wxString& params);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Predefined Editors
|
|
|
|
class wxGridCellTextEditor : public wxGridCellEditor
|
|
{
|
|
public:
|
|
wxGridCellTextEditor();
|
|
};
|
|
|
|
|
|
class wxGridCellNumberEditor : public wxGridCellTextEditor
|
|
{
|
|
public:
|
|
wxGridCellNumberEditor(int min = -1, int max = -1);
|
|
};
|
|
|
|
|
|
class wxGridCellFloatEditor : public wxGridCellTextEditor
|
|
{
|
|
public:
|
|
wxGridCellFloatEditor();
|
|
};
|
|
|
|
|
|
class wxGridCellBoolEditor : public wxGridCellEditor
|
|
{
|
|
public:
|
|
wxGridCellBoolEditor();
|
|
};
|
|
|
|
class wxGridCellChoiceEditor : public wxGridCellEditor
|
|
{
|
|
public:
|
|
wxGridCellChoiceEditor(int LCOUNT = 0,
|
|
const wxString* choices = NULL,
|
|
bool allowOthers = FALSE);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
class wxGridCellAttr
|
|
{
|
|
public:
|
|
enum wxAttrKind
|
|
{
|
|
Any,
|
|
Default,
|
|
Cell,
|
|
Row,
|
|
Col,
|
|
Merged
|
|
};
|
|
|
|
wxGridCellAttr();
|
|
|
|
wxGridCellAttr *Clone() const;
|
|
void MergeWith(wxGridCellAttr *mergefrom);
|
|
void IncRef();
|
|
void DecRef();
|
|
void SetTextColour(const wxColour& colText);
|
|
void SetBackgroundColour(const wxColour& colBack);
|
|
void SetFont(const wxFont& font);
|
|
void SetAlignment(int hAlign, int vAlign);
|
|
void SetReadOnly(bool isReadOnly = TRUE);
|
|
|
|
void SetRenderer(wxGridCellRenderer *renderer);
|
|
void SetEditor(wxGridCellEditor* editor);
|
|
void SetKind(wxAttrKind kind);
|
|
|
|
bool HasTextColour() const;
|
|
bool HasBackgroundColour() const;
|
|
bool HasFont() const;
|
|
bool HasAlignment() const;
|
|
bool HasRenderer() const;
|
|
bool HasEditor() const;
|
|
bool HasReadWriteMode() const;
|
|
|
|
const wxColour& GetTextColour() const;
|
|
const wxColour& GetBackgroundColour() const;
|
|
const wxFont& GetFont() const;
|
|
void GetAlignment(int *OUTPUT, int *OUTPUT) const;
|
|
wxGridCellRenderer *GetRenderer(wxGrid* grid, int row, int col) const;
|
|
wxGridCellEditor *GetEditor(wxGrid* grid, int row, int col) const;
|
|
|
|
bool IsReadOnly() const;
|
|
void SetDefAttr(wxGridCellAttr* defAttr);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
class wxGridCellAttrProvider
|
|
{
|
|
public:
|
|
wxGridCellAttrProvider();
|
|
// ???? virtual ~wxGridCellAttrProvider();
|
|
|
|
wxGridCellAttr *GetAttr(int row, int col,
|
|
wxGridCellAttr::wxAttrKind kind) const;
|
|
void SetAttr(wxGridCellAttr *attr, int row, int col);
|
|
void SetRowAttr(wxGridCellAttr *attr, int row);
|
|
void SetColAttr(wxGridCellAttr *attr, int col);
|
|
|
|
void UpdateAttrRows( size_t pos, int numRows );
|
|
void UpdateAttrCols( size_t pos, int numCols );
|
|
|
|
};
|
|
|
|
|
|
// A Python-aware version
|
|
%{
|
|
class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
|
|
{
|
|
public:
|
|
wxPyGridCellAttrProvider() : wxGridCellAttrProvider() {};
|
|
|
|
PYCALLBACK_GCA_INTINTKIND(wxGridCellAttrProvider, GetAttr);
|
|
PYCALLBACK__GCAINTINT(wxGridCellAttrProvider, SetAttr);
|
|
PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetRowAttr);
|
|
PYCALLBACK__GCAINT(wxGridCellAttrProvider, SetColAttr);
|
|
|
|
PYPRIVATE;
|
|
};
|
|
%}
|
|
|
|
|
|
// The python-aware version get's SWIGified
|
|
class wxPyGridCellAttrProvider : public wxGridCellAttrProvider
|
|
{
|
|
public:
|
|
wxPyGridCellAttrProvider();
|
|
void _setSelf(PyObject* self, PyObject* _class);
|
|
%pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridCellAttrProvider)"
|
|
|
|
wxGridCellAttr *base_GetAttr(int row, int col,
|
|
wxGridCellAttr::wxAttrKind kind);
|
|
void base_SetAttr(wxGridCellAttr *attr, int row, int col);
|
|
void base_SetRowAttr(wxGridCellAttr *attr, int row);
|
|
void base_SetColAttr(wxGridCellAttr *attr, int col);
|
|
};
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Grid Table Base class and Python aware version
|
|
|
|
|
|
|
|
class wxGridTableBase : public wxObject
|
|
{
|
|
public:
|
|
// wxGridTableBase(); This is an ABC
|
|
//~wxGridTableBase();
|
|
|
|
void SetAttrProvider(wxGridCellAttrProvider *attrProvider);
|
|
wxGridCellAttrProvider *GetAttrProvider() const;
|
|
void SetView( wxGrid *grid );
|
|
wxGrid * GetView() const;
|
|
|
|
|
|
// pure virtuals
|
|
virtual int GetNumberRows() = 0;
|
|
virtual int GetNumberCols() = 0;
|
|
virtual bool IsEmptyCell( int row, int col ) = 0;
|
|
virtual wxString GetValue( int row, int col ) = 0;
|
|
virtual void SetValue( int row, int col, const wxString& value ) = 0;
|
|
|
|
// virtuals overridable in wxPyGridTableBase
|
|
virtual wxString GetTypeName( int row, int col );
|
|
virtual bool CanGetValueAs( int row, int col, const wxString& typeName );
|
|
virtual bool CanSetValueAs( int row, int col, const wxString& typeName );
|
|
virtual long GetValueAsLong( int row, int col );
|
|
virtual double GetValueAsDouble( int row, int col );
|
|
virtual bool GetValueAsBool( int row, int col );
|
|
virtual void SetValueAsLong( int row, int col, long value );
|
|
virtual void SetValueAsDouble( int row, int col, double value );
|
|
virtual void SetValueAsBool( int row, int col, bool value );
|
|
|
|
//virtual void* GetValueAsCustom( int row, int col, const wxString& typeName );
|
|
//virtual void SetValueAsCustom( int row, int col, const wxString& typeName, void* value );
|
|
|
|
|
|
virtual void Clear();
|
|
virtual bool InsertRows( size_t pos = 0, size_t numRows = 1 );
|
|
virtual bool AppendRows( size_t numRows = 1 );
|
|
virtual bool DeleteRows( size_t pos = 0, size_t numRows = 1 );
|
|
virtual bool InsertCols( size_t pos = 0, size_t numCols = 1 );
|
|
virtual bool AppendCols( size_t numCols = 1 );
|
|
virtual bool DeleteCols( size_t pos = 0, size_t numCols = 1 );
|
|
|
|
virtual wxString GetRowLabelValue( int row );
|
|
virtual wxString GetColLabelValue( int col );
|
|
virtual void SetRowLabelValue( int row, const wxString& value );
|
|
virtual void SetColLabelValue( int col, const wxString& value );
|
|
|
|
virtual bool CanHaveAttributes();
|
|
|
|
virtual wxGridCellAttr *GetAttr( int row, int col,
|
|
wxGridCellAttr::wxAttrKind kind);
|
|
virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
|
|
virtual void SetRowAttr(wxGridCellAttr *attr, int row);
|
|
virtual void SetColAttr(wxGridCellAttr *attr, int col);
|
|
|
|
};
|
|
|
|
|
|
|
|
// Python-aware version
|
|
%{
|
|
class wxPyGridTableBase : public wxGridTableBase
|
|
{
|
|
public:
|
|
wxPyGridTableBase() : wxGridTableBase() {}
|
|
|
|
PYCALLBACK_INT__pure(GetNumberRows);
|
|
PYCALLBACK_INT__pure(GetNumberCols);
|
|
PYCALLBACK_BOOL_INTINT_pure(IsEmptyCell);
|
|
PYCALLBACK_STRING_INTINT(wxGridTableBase, GetTypeName);
|
|
PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanGetValueAs);
|
|
PYCALLBACK_BOOL_INTINTSTRING(wxGridTableBase, CanSetValueAs);
|
|
PYCALLBACK__(wxGridTableBase, Clear);
|
|
PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertRows);
|
|
PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteRows);
|
|
PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, InsertCols);
|
|
PYCALLBACK_BOOL_SIZETSIZET(wxGridTableBase, DeleteCols);
|
|
PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendRows);
|
|
PYCALLBACK_BOOL_SIZET(wxGridTableBase, AppendCols);
|
|
PYCALLBACK_STRING_INT(wxGridTableBase, GetRowLabelValue);
|
|
PYCALLBACK_STRING_INT(wxGridTableBase, GetColLabelValue);
|
|
PYCALLBACK__INTSTRING(wxGridTableBase, SetRowLabelValue);
|
|
PYCALLBACK__INTSTRING(wxGridTableBase, SetColLabelValue);
|
|
PYCALLBACK_BOOL_(wxGridTableBase, CanHaveAttributes);
|
|
PYCALLBACK_GCA_INTINTKIND(wxGridTableBase, GetAttr);
|
|
PYCALLBACK__GCAINTINT(wxGridTableBase, SetAttr);
|
|
PYCALLBACK__GCAINT(wxGridTableBase, SetRowAttr);
|
|
PYCALLBACK__GCAINT(wxGridTableBase, SetColAttr);
|
|
|
|
|
|
wxString GetValue(int row, int col) {
|
|
bool doSave = wxPyRestoreThread();
|
|
wxString rval;
|
|
if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
|
|
PyObject* ro;
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)",row,col));
|
|
if (ro) {
|
|
PyObject* str = PyObject_Str(ro);
|
|
rval = PyString_AsString(str);
|
|
Py_DECREF(ro);
|
|
Py_DECREF(str);
|
|
}
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rval;
|
|
}
|
|
|
|
void SetValue(int row, int col, const wxString& val) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "SetValue"))
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iis)",row,col,val.c_str()));
|
|
wxPySaveThread(doSave);
|
|
}
|
|
|
|
|
|
// Map the Get/Set methods for the standard non-string types to
|
|
// the GetValue and SetValue python methods.
|
|
long GetValueAsLong( int row, int col ) {
|
|
long rval = 0;
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
|
|
PyObject* ro;
|
|
PyObject* num;
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
|
|
if (ro && PyNumber_Check(ro)) {
|
|
num = PyNumber_Int(ro);
|
|
if (num) {
|
|
rval = PyInt_AsLong(num);
|
|
Py_DECREF(num);
|
|
}
|
|
Py_DECREF(ro);
|
|
}
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rval;
|
|
}
|
|
|
|
double GetValueAsDouble( int row, int col ) {
|
|
double rval = 0.0;
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "GetValue")) {
|
|
PyObject* ro;
|
|
PyObject* num;
|
|
ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(ii)", row, col));
|
|
if (ro && PyNumber_Check(ro)) {
|
|
num = PyNumber_Float(ro);
|
|
if (num) {
|
|
rval = PyFloat_AsDouble(num);
|
|
Py_DECREF(num);
|
|
}
|
|
Py_DECREF(ro);
|
|
}
|
|
}
|
|
wxPySaveThread(doSave);
|
|
return rval;
|
|
}
|
|
|
|
bool GetValueAsBool( int row, int col ) {
|
|
return (bool)GetValueAsLong(row, col);
|
|
}
|
|
|
|
void SetValueAsLong( int row, int col, long value ) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iii)", row, col, value));
|
|
}
|
|
wxPySaveThread(doSave);
|
|
}
|
|
|
|
void SetValueAsDouble( int row, int col, double value ) {
|
|
bool doSave = wxPyRestoreThread();
|
|
if (wxPyCBH_findCallback(m_myInst, "SetValue")) {
|
|
wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iid)", row, col, value));
|
|
}
|
|
wxPySaveThread(doSave);
|
|
}
|
|
|
|
void SetValueAsBool( int row, int col, bool value ) {
|
|
SetValueAsLong( row, col, (long)value );
|
|
}
|
|
|
|
|
|
PYPRIVATE;
|
|
};
|
|
%}
|
|
|
|
|
|
// The python-aware version get's SWIGified
|
|
class wxPyGridTableBase : public wxGridTableBase
|
|
{
|
|
public:
|
|
wxPyGridTableBase();
|
|
void _setSelf(PyObject* self, PyObject* _class);
|
|
%pragma(python) addtomethod = "__init__:self._setSelf(self, wxPyGridTableBase)"
|
|
|
|
%addmethods { void Destroy() { delete self; } }
|
|
|
|
wxString base_GetTypeName( int row, int col );
|
|
bool base_CanGetValueAs( int row, int col, const wxString& typeName );
|
|
bool base_CanSetValueAs( int row, int col, const wxString& typeName );
|
|
void base_Clear();
|
|
bool base_InsertRows( size_t pos = 0, size_t numRows = 1 );
|
|
bool base_AppendRows( size_t numRows = 1 );
|
|
bool base_DeleteRows( size_t pos = 0, size_t numRows = 1 );
|
|
bool base_InsertCols( size_t pos = 0, size_t numCols = 1 );
|
|
bool base_AppendCols( size_t numCols = 1 );
|
|
bool base_DeleteCols( size_t pos = 0, size_t numCols = 1 );
|
|
wxString base_GetRowLabelValue( int row );
|
|
wxString base_GetColLabelValue( int col );
|
|
void base_SetRowLabelValue( int row, const wxString& value );
|
|
void base_SetColLabelValue( int col, const wxString& value );
|
|
bool base_CanHaveAttributes();
|
|
wxGridCellAttr *base_GetAttr( int row, int col,
|
|
wxGridCellAttr::wxAttrKind kind );
|
|
void base_SetAttr(wxGridCellAttr* attr, int row, int col);
|
|
void base_SetRowAttr(wxGridCellAttr *attr, int row);
|
|
void base_SetColAttr(wxGridCellAttr *attr, int col);
|
|
};
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Predefined Tables
|
|
|
|
class wxGridStringTable : public wxGridTableBase
|
|
{
|
|
public:
|
|
wxGridStringTable( int numRows=0, int numCols=0 );
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
// The Table can pass messages to the grid to tell it to update itself if
|
|
// something has changed.
|
|
|
|
enum wxGridTableRequest
|
|
{
|
|
wxGRIDTABLE_REQUEST_VIEW_GET_VALUES = 2000,
|
|
wxGRIDTABLE_REQUEST_VIEW_SEND_VALUES,
|
|
wxGRIDTABLE_NOTIFY_ROWS_INSERTED,
|
|
wxGRIDTABLE_NOTIFY_ROWS_APPENDED,
|
|
wxGRIDTABLE_NOTIFY_ROWS_DELETED,
|
|
wxGRIDTABLE_NOTIFY_COLS_INSERTED,
|
|
wxGRIDTABLE_NOTIFY_COLS_APPENDED,
|
|
wxGRIDTABLE_NOTIFY_COLS_DELETED
|
|
};
|
|
|
|
|
|
class wxGridTableMessage
|
|
{
|
|
public:
|
|
wxGridTableMessage( wxGridTableBase *table, int id,
|
|
int comInt1 = -1,
|
|
int comInt2 = -1 );
|
|
~wxGridTableMessage();
|
|
|
|
void SetTableObject( wxGridTableBase *table );
|
|
wxGridTableBase * GetTableObject() const;
|
|
void SetId( int id );
|
|
int GetId();
|
|
void SetCommandInt( int comInt1 );
|
|
int GetCommandInt();
|
|
void SetCommandInt2( int comInt2 );
|
|
int GetCommandInt2();
|
|
};
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
class wxGridCellCoords
|
|
{
|
|
public:
|
|
wxGridCellCoords( int r=-1, int c=-1 );
|
|
~wxGridCellCoords();
|
|
|
|
int GetRow() const { return m_row; }
|
|
void SetRow( int n ) { m_row = n; }
|
|
int GetCol() const { return m_col; }
|
|
void SetCol( int n ) { m_col = n; }
|
|
void Set( int row, int col ) { m_row = row; m_col = col; }
|
|
|
|
%addmethods {
|
|
PyObject* asTuple() {
|
|
PyObject* tup = PyTuple_New(2);
|
|
PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
|
|
PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
|
|
return tup;
|
|
}
|
|
|
|
int __cmp__( const wxGridCellCoords& other ) {
|
|
return *self != other;
|
|
}
|
|
}
|
|
%pragma(python) addtoclass = "def __str__(self): return str(self.asTuple())"
|
|
%pragma(python) addtoclass = "def __repr__(self): return str(self.asTuple())"
|
|
};
|
|
|
|
// Typemap to allow conversion of sequence objects to wxGridCellCoords...
|
|
%typemap(python,in) wxGridCellCoords& (wxGridCellCoords temp) {
|
|
$target = &temp;
|
|
if (! wxGridCellCoords_helper($source, &$target))
|
|
return NULL;
|
|
}
|
|
|
|
// ...and here is the associated helper.
|
|
%{
|
|
bool wxGridCellCoords_helper(PyObject* source, wxGridCellCoords** obj) {
|
|
|
|
// If source is an object instance then it may already be the right type
|
|
if (PyInstance_Check(source)) {
|
|
wxGridCellCoords* ptr;
|
|
if (SWIG_GetPtrObj(source, (void **)&ptr, "_wxGridCellCoords_p"))
|
|
goto error;
|
|
*obj = ptr;
|
|
return TRUE;
|
|
}
|
|
// otherwise a 2-tuple of integers is expected
|
|
else if (PySequence_Check(source) && PyObject_Length(source) == 2) {
|
|
PyObject* o1 = PySequence_GetItem(source, 0);
|
|
PyObject* o2 = PySequence_GetItem(source, 1);
|
|
**obj = wxGridCellCoords(PyInt_AsLong(o1), PyInt_AsLong(o2));
|
|
return TRUE;
|
|
}
|
|
|
|
error:
|
|
PyErr_SetString(PyExc_TypeError, "Expected a 2-tuple of integers or a wxGridCellCoords object.");
|
|
return FALSE;
|
|
}
|
|
%}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
// The grid itself
|
|
|
|
|
|
// Fool SWIG into treating this enum as an int
|
|
typedef int WXGRIDSELECTIONMODES;
|
|
|
|
// but let the C++ code know what it really is.
|
|
%{
|
|
typedef wxGrid::wxGridSelectionModes WXGRIDSELECTIONMODES;
|
|
%}
|
|
|
|
|
|
|
|
class wxGrid : public wxScrolledWindow
|
|
{
|
|
public:
|
|
wxGrid( wxWindow *parent,
|
|
wxWindowID id,
|
|
const wxPoint& pos = wxDefaultPosition,
|
|
const wxSize& size = wxDefaultSize,
|
|
long style = wxWANTS_CHARS,
|
|
const char* name = wxPanelNameStr );
|
|
|
|
//~wxGrid();
|
|
|
|
enum wxGridSelectionModes {wxGridSelectCells,
|
|
wxGridSelectRows,
|
|
wxGridSelectColumns};
|
|
|
|
bool CreateGrid( int numRows, int numCols,
|
|
WXGRIDSELECTIONMODES selmode = wxGrid::wxGridSelectCells );
|
|
void SetSelectionMode(WXGRIDSELECTIONMODES selmode);
|
|
|
|
|
|
// ------ grid dimensions
|
|
//
|
|
int GetNumberRows();
|
|
int GetNumberCols();
|
|
|
|
|
|
|
|
#ifdef NOTNEEDED // ????
|
|
// ------ display update functions
|
|
//
|
|
void CalcRowLabelsExposed( wxRegion& reg );
|
|
void CalcColLabelsExposed( wxRegion& reg );
|
|
void CalcCellsExposed( wxRegion& reg );
|
|
|
|
// ------ event handlers
|
|
//
|
|
void ProcessRowLabelMouseEvent( wxMouseEvent& event );
|
|
void ProcessColLabelMouseEvent( wxMouseEvent& event );
|
|
void ProcessCornerLabelMouseEvent( wxMouseEvent& event );
|
|
void ProcessGridCellMouseEvent( wxMouseEvent& event );
|
|
void DoEndDragResizeRow();
|
|
void DoEndDragResizeCol();
|
|
#endif
|
|
|
|
bool ProcessTableMessage( wxGridTableMessage& );
|
|
|
|
|
|
wxGridTableBase * GetTable() const;
|
|
bool SetTable( wxGridTableBase *table, bool takeOwnership=FALSE,
|
|
WXGRIDSELECTIONMODES selmode =
|
|
wxGrid::wxGridSelectCells );
|
|
|
|
void ClearGrid();
|
|
bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels=TRUE );
|
|
bool AppendRows( int numRows = 1, bool updateLabels=TRUE );
|
|
bool DeleteRows( int pos = 0, int numRows = 1, bool updateLabels=TRUE );
|
|
bool InsertCols( int pos = 0, int numCols = 1, bool updateLabels=TRUE );
|
|
bool AppendCols( int numCols = 1, bool updateLabels=TRUE );
|
|
bool DeleteCols( int pos = 0, int numCols = 1, bool updateLabels=TRUE );
|
|
|
|
#ifdef NOTNEEDED // ????
|
|
void DrawGridCellArea( wxDC& dc );
|
|
void DrawGridSpace( wxDC& dc );
|
|
void DrawCellBorder( wxDC& dc, const wxGridCellCoords& );
|
|
void DrawAllGridLines( wxDC& dc, const wxRegion & reg );
|
|
void DrawCell( wxDC& dc, const wxGridCellCoords& );
|
|
void DrawHighlight(wxDC& dc);
|
|
#endif
|
|
|
|
// this function is called when the current cell highlight must be redrawn
|
|
// and may be overridden by the user
|
|
virtual void DrawCellHighlight( wxDC& dc, const wxGridCellAttr *attr );
|
|
|
|
#ifdef NOTNEEDED // ????
|
|
void DrawRowLabels( wxDC& dc );
|
|
void DrawRowLabel( wxDC& dc, int row );
|
|
|
|
void DrawColLabels( wxDC& dc );
|
|
void DrawColLabel( wxDC& dc, int col );
|
|
#endif
|
|
|
|
// ------ Cell text drawing functions
|
|
//
|
|
void DrawTextRectangle( wxDC& dc, const wxString&, const wxRect&,
|
|
int horizontalAlignment = wxLEFT,
|
|
int verticalAlignment = wxTOP );
|
|
|
|
// Split a string containing newline chararcters into an array of
|
|
// strings and return the number of lines
|
|
//
|
|
void StringToLines( const wxString& value, wxArrayString& lines );
|
|
|
|
void GetTextBoxSize( wxDC& dc,
|
|
wxArrayString& lines,
|
|
long *OUTPUT, long *OUTPUT );
|
|
|
|
|
|
// ------
|
|
// Code that does a lot of grid modification can be enclosed
|
|
// between BeginBatch() and EndBatch() calls to avoid screen
|
|
// flicker
|
|
//
|
|
void BeginBatch();
|
|
void EndBatch();
|
|
int GetBatchCount();
|
|
|
|
|
|
// ------ edit control functions
|
|
//
|
|
bool IsEditable() { return m_editable; }
|
|
void EnableEditing( bool edit );
|
|
|
|
void EnableCellEditControl( bool enable = TRUE );
|
|
void DisableCellEditControl();
|
|
bool CanEnableCellControl() const;
|
|
bool IsCellEditControlEnabled() const;
|
|
bool IsCellEditControlShown() const;
|
|
|
|
bool IsCurrentCellReadOnly() const;
|
|
|
|
void ShowCellEditControl();
|
|
void HideCellEditControl();
|
|
void SaveEditControlValue();
|
|
|
|
|
|
// ------ grid location functions
|
|
// Note that all of these functions work with the logical coordinates of
|
|
// grid cells and labels so you will need to convert from device
|
|
// coordinates for mouse events etc.
|
|
//
|
|
|
|
//void XYToCell( int x, int y, wxGridCellCoords& );
|
|
%addmethods {
|
|
%new wxGridCellCoords* XYToCell(int x, int y) {
|
|
wxGridCellCoords rv;
|
|
self->XYToCell(x, y, rv);
|
|
return new wxGridCellCoords(rv);
|
|
}
|
|
}
|
|
|
|
int YToRow( int y );
|
|
int XToCol( int x );
|
|
|
|
int YToEdgeOfRow( int y );
|
|
int XToEdgeOfCol( int x );
|
|
|
|
wxRect CellToRect( int row, int col );
|
|
// TODO: ??? wxRect CellToRect( const wxGridCellCoords& coords );
|
|
|
|
|
|
int GetGridCursorRow();
|
|
int GetGridCursorCol();
|
|
|
|
// check to see if a cell is either wholly visible (the default arg) or
|
|
// at least partially visible in the grid window
|
|
//
|
|
bool IsVisible( int row, int col, bool wholeCellVisible = TRUE );
|
|
// TODO: ??? bool IsVisible( const wxGridCellCoords& coords, bool wholeCellVisible = TRUE );
|
|
void MakeCellVisible( int row, int col );
|
|
// TODO: ??? void MakeCellVisible( const wxGridCellCoords& coords );
|
|
|
|
|
|
// ------ grid cursor movement functions
|
|
//
|
|
void SetGridCursor( int row, int col );
|
|
bool MoveCursorUp( bool expandSelection );
|
|
bool MoveCursorDown( bool expandSelection );
|
|
bool MoveCursorLeft( bool expandSelection );
|
|
bool MoveCursorRight( bool expandSelection );
|
|
bool MovePageDown();
|
|
bool MovePageUp();
|
|
bool MoveCursorUpBlock( bool expandSelection );
|
|
bool MoveCursorDownBlock( bool expandSelection );
|
|
bool MoveCursorLeftBlock( bool expandSelection );
|
|
bool MoveCursorRightBlock( bool expandSelection );
|
|
|
|
|
|
// ------ label and gridline formatting
|
|
//
|
|
int GetDefaultRowLabelSize();
|
|
int GetRowLabelSize();
|
|
int GetDefaultColLabelSize();
|
|
int GetColLabelSize();
|
|
wxColour GetLabelBackgroundColour();
|
|
wxColour GetLabelTextColour();
|
|
wxFont GetLabelFont();
|
|
void GetRowLabelAlignment( int *OUTPUT, int *OUTPUT );
|
|
void GetColLabelAlignment( int *OUTPUT, int *OUTPUT );
|
|
wxString GetRowLabelValue( int row );
|
|
wxString GetColLabelValue( int col );
|
|
wxColour GetGridLineColour();
|
|
wxColour GetCellHighlightColour();
|
|
int GetCellHighlightPenWidth();
|
|
int GetCellHighlightROPenWidth();
|
|
|
|
void SetRowLabelSize( int width );
|
|
void SetColLabelSize( int height );
|
|
void SetLabelBackgroundColour( const wxColour& );
|
|
void SetLabelTextColour( const wxColour& );
|
|
void SetLabelFont( const wxFont& );
|
|
void SetRowLabelAlignment( int horiz, int vert );
|
|
void SetColLabelAlignment( int horiz, int vert );
|
|
void SetRowLabelValue( int row, const wxString& );
|
|
void SetColLabelValue( int col, const wxString& );
|
|
void SetGridLineColour( const wxColour& );
|
|
void SetCellHighlightColour( const wxColour& );
|
|
void SetCellHighlightPenWidth(int width);
|
|
void SetCellHighlightROPenWidth(int width);
|
|
|
|
void EnableDragRowSize( bool enable = TRUE );
|
|
void DisableDragRowSize();
|
|
bool CanDragRowSize();
|
|
void EnableDragColSize( bool enable = TRUE );
|
|
void DisableDragColSize();
|
|
bool CanDragColSize();
|
|
void EnableDragGridSize(bool enable = TRUE);
|
|
void DisableDragGridSize();
|
|
bool CanDragGridSize();
|
|
|
|
// this sets the specified attribute for all cells in this row/col
|
|
void SetRowAttr(int row, wxGridCellAttr *attr);
|
|
void SetColAttr(int col, wxGridCellAttr *attr);
|
|
|
|
// shortcuts for setting the column parameters
|
|
|
|
// set the format for the data in the column: default is string
|
|
void SetColFormatBool(int col);
|
|
void SetColFormatNumber(int col);
|
|
void SetColFormatFloat(int col, int width = -1, int precision = -1);
|
|
void SetColFormatCustom(int col, const wxString& typeName);
|
|
|
|
void EnableGridLines( bool enable = TRUE );
|
|
bool GridLinesEnabled();
|
|
|
|
// ------ row and col formatting
|
|
//
|
|
int GetDefaultRowSize();
|
|
int GetRowSize( int row );
|
|
int GetDefaultColSize();
|
|
int GetColSize( int col );
|
|
wxColour GetDefaultCellBackgroundColour();
|
|
wxColour GetCellBackgroundColour( int row, int col );
|
|
wxColour GetDefaultCellTextColour();
|
|
wxColour GetCellTextColour( int row, int col );
|
|
wxFont GetDefaultCellFont();
|
|
wxFont GetCellFont( int row, int col );
|
|
void GetDefaultCellAlignment( int *horiz, int *vert );
|
|
void GetCellAlignment( int row, int col, int *horiz, int *vert );
|
|
|
|
void SetDefaultRowSize( int height, bool resizeExistingRows = FALSE );
|
|
void SetRowSize( int row, int height );
|
|
void SetDefaultColSize( int width, bool resizeExistingCols = FALSE );
|
|
|
|
void SetColSize( int col, int width );
|
|
|
|
// automatically size the column or row to fit to its contents, if
|
|
// setAsMin is TRUE, this optimal width will also be set as minimal width
|
|
// for this column
|
|
void AutoSizeColumn( int col, bool setAsMin = TRUE );
|
|
void AutoSizeRow( int row, bool setAsMin = TRUE );
|
|
|
|
|
|
// auto size all columns (very ineffective for big grids!)
|
|
void AutoSizeColumns( bool setAsMin = TRUE );
|
|
void AutoSizeRows( bool setAsMin = TRUE );
|
|
|
|
// auto size the grid, that is make the columns/rows of the "right" size
|
|
// and also set the grid size to just fit its contents
|
|
void AutoSize();
|
|
|
|
// column won't be resized to be lesser width - this must be called during
|
|
// the grid creation because it won't resize the column if it's already
|
|
// narrower than the minimal width
|
|
void SetColMinimalWidth( int col, int width );
|
|
void SetRowMinimalHeight( int row, int width );
|
|
|
|
void SetDefaultCellBackgroundColour( const wxColour& );
|
|
void SetCellBackgroundColour( int row, int col, const wxColour& );
|
|
void SetDefaultCellTextColour( const wxColour& );
|
|
|
|
void SetCellTextColour( int row, int col, const wxColour& );
|
|
void SetDefaultCellFont( const wxFont& );
|
|
void SetCellFont( int row, int col, const wxFont& );
|
|
void SetDefaultCellAlignment( int horiz, int vert );
|
|
void SetCellAlignment( int row, int col, int horiz, int vert );
|
|
|
|
// takes ownership of the pointer
|
|
void SetDefaultRenderer(wxGridCellRenderer *renderer);
|
|
void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
|
|
wxGridCellRenderer *GetDefaultRenderer() const;
|
|
wxGridCellRenderer* GetCellRenderer(int row, int col);
|
|
|
|
// takes ownership of the pointer
|
|
void SetDefaultEditor(wxGridCellEditor *editor);
|
|
void SetCellEditor(int row, int col, wxGridCellEditor *editor);
|
|
wxGridCellEditor *GetDefaultEditor() const;
|
|
wxGridCellEditor* GetCellEditor(int row, int col);
|
|
|
|
|
|
|
|
// ------ cell value accessors
|
|
//
|
|
wxString GetCellValue( int row, int col );
|
|
// TODO: ??? wxString GetCellValue( const wxGridCellCoords& coords )
|
|
|
|
void SetCellValue( int row, int col, const wxString& s );
|
|
// TODO: ??? void SetCellValue( const wxGridCellCoords& coords, const wxString& s )
|
|
|
|
// returns TRUE if the cell can't be edited
|
|
bool IsReadOnly(int row, int col) const;
|
|
|
|
// make the cell editable/readonly
|
|
void SetReadOnly(int row, int col, bool isReadOnly = TRUE);
|
|
|
|
// ------ selections of blocks of cells
|
|
//
|
|
void SelectRow( int row, bool addToSelected = FALSE );
|
|
void SelectCol( int col, bool addToSelected = FALSE );
|
|
|
|
void SelectBlock( int topRow, int leftCol, int bottomRow, int rightCol,
|
|
bool addToSelected = FALSE );
|
|
// TODO: ??? void SelectBlock( const wxGridCellCoords& topLeft,
|
|
// TODO: ??? const wxGridCellCoords& bottomRight )
|
|
|
|
void SelectAll();
|
|
bool IsSelection();
|
|
void ClearSelection();
|
|
bool IsInSelection( int row, int col );
|
|
// TODO: ??? bool IsInSelection( const wxGridCellCoords& coords )
|
|
|
|
|
|
// This function returns the rectangle that encloses the block of cells
|
|
// limited by TopLeft and BottomRight cell in device coords and clipped
|
|
// to the client size of the grid window.
|
|
//
|
|
wxRect BlockToDeviceRect( const wxGridCellCoords & topLeft,
|
|
const wxGridCellCoords & bottomRight );
|
|
|
|
|
|
// Access or update the selection fore/back colours
|
|
wxColour GetSelectionBackground() const;
|
|
wxColour GetSelectionForeground() const;
|
|
|
|
void SetSelectionBackground(const wxColour& c);
|
|
void SetSelectionForeground(const wxColour& c);
|
|
|
|
|
|
// Methods for a registry for mapping data types to Renderers/Editors
|
|
void RegisterDataType(const wxString& typeName,
|
|
wxGridCellRenderer* renderer,
|
|
wxGridCellEditor* editor);
|
|
wxGridCellEditor* GetDefaultEditorForCell(int row, int col) const;
|
|
// TODO: ??? wxGridCellEditor* GetDefaultEditorForCell(const wxGridCellCoords& c) const
|
|
wxGridCellRenderer* GetDefaultRendererForCell(int row, int col) const;
|
|
wxGridCellEditor* GetDefaultEditorForType(const wxString& typeName) const;
|
|
wxGridCellRenderer* GetDefaultRendererForType(const wxString& typeName) const;
|
|
|
|
// grid may occupy more space than needed for its rows/columns, this
|
|
// function allows to set how big this extra space is
|
|
void SetMargins(int extraWidth, int extraHeight);
|
|
|
|
|
|
// Accessors for component windows
|
|
wxWindow* GetGridWindow();
|
|
wxWindow* GetGridRowLabelWindow();
|
|
wxWindow* GetGridColLabelWindow();
|
|
wxWindow* GetGridCornerLabelWindow();
|
|
|
|
|
|
};
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
// Grid events and stuff
|
|
|
|
|
|
|
|
class wxGridEvent : public wxNotifyEvent
|
|
{
|
|
public:
|
|
wxGridEvent(int id, wxEventType type, wxGrid* obj,
|
|
int row=-1, int col=-1, int x=-1, int y=-1, bool sel = TRUE,
|
|
bool control=FALSE, bool shift=FALSE, bool alt=FALSE, bool meta=FALSE);
|
|
|
|
virtual int GetRow();
|
|
virtual int GetCol();
|
|
wxPoint GetPosition();
|
|
bool Selecting();
|
|
bool ControlDown();
|
|
bool MetaDown();
|
|
bool ShiftDown();
|
|
bool AltDown();
|
|
|
|
};
|
|
|
|
|
|
class wxGridSizeEvent : public wxNotifyEvent
|
|
{
|
|
public:
|
|
wxGridSizeEvent(int id, wxEventType type, wxGrid* obj,
|
|
int rowOrCol=-1, int x=-1, int y=-1,
|
|
bool control=FALSE, bool shift=FALSE, bool alt=FALSE, bool meta=FALSE);
|
|
|
|
int GetRowOrCol();
|
|
wxPoint GetPosition();
|
|
bool ControlDown();
|
|
bool MetaDown();
|
|
bool ShiftDown();
|
|
bool AltDown();
|
|
|
|
};
|
|
|
|
|
|
class wxGridRangeSelectEvent : public wxNotifyEvent
|
|
{
|
|
public:
|
|
wxGridRangeSelectEvent(int id, wxEventType type, wxGrid* obj,
|
|
const wxGridCellCoords& topLeft,
|
|
const wxGridCellCoords& bottomRight,
|
|
bool sel = TRUE,
|
|
bool control=FALSE, bool shift=FALSE,
|
|
bool alt=FALSE, bool meta=FALSE);
|
|
|
|
wxGridCellCoords GetTopLeftCoords();
|
|
wxGridCellCoords GetBottomRightCoords();
|
|
int GetTopRow();
|
|
int GetBottomRow();
|
|
int GetLeftCol();
|
|
int GetRightCol();
|
|
bool Selecting();
|
|
bool ControlDown();
|
|
bool MetaDown();
|
|
bool ShiftDown();
|
|
bool AltDown();
|
|
};
|
|
|
|
enum {
|
|
wxEVT_GRID_CELL_LEFT_CLICK,
|
|
wxEVT_GRID_CELL_RIGHT_CLICK,
|
|
wxEVT_GRID_CELL_LEFT_DCLICK,
|
|
wxEVT_GRID_CELL_RIGHT_DCLICK,
|
|
wxEVT_GRID_LABEL_LEFT_CLICK,
|
|
wxEVT_GRID_LABEL_RIGHT_CLICK,
|
|
wxEVT_GRID_LABEL_LEFT_DCLICK,
|
|
wxEVT_GRID_LABEL_RIGHT_DCLICK,
|
|
wxEVT_GRID_ROW_SIZE,
|
|
wxEVT_GRID_COL_SIZE,
|
|
wxEVT_GRID_RANGE_SELECT,
|
|
wxEVT_GRID_CELL_CHANGE,
|
|
wxEVT_GRID_SELECT_CELL,
|
|
wxEVT_GRID_EDITOR_SHOWN,
|
|
wxEVT_GRID_EDITOR_HIDDEN,
|
|
};
|
|
|
|
|
|
|
|
%pragma(python) code = "
|
|
def EVT_GRID_CELL_LEFT_CLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_CELL_LEFT_CLICK, fn)
|
|
|
|
def EVT_GRID_CELL_RIGHT_CLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_CELL_RIGHT_CLICK, fn)
|
|
|
|
def EVT_GRID_CELL_LEFT_DCLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_CELL_LEFT_DCLICK, fn)
|
|
|
|
def EVT_GRID_CELL_RIGHT_DCLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_CELL_RIGHT_DCLICK, fn)
|
|
|
|
def EVT_GRID_LABEL_LEFT_CLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_LABEL_LEFT_CLICK, fn)
|
|
|
|
def EVT_GRID_LABEL_RIGHT_CLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_LABEL_RIGHT_CLICK, fn)
|
|
|
|
def EVT_GRID_LABEL_LEFT_DCLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_LABEL_LEFT_DCLICK, fn)
|
|
|
|
def EVT_GRID_LABEL_RIGHT_DCLICK(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_LABEL_RIGHT_DCLICK, fn)
|
|
|
|
def EVT_GRID_ROW_SIZE(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_ROW_SIZE, fn)
|
|
|
|
def EVT_GRID_COL_SIZE(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_COL_SIZE, fn)
|
|
|
|
def EVT_GRID_RANGE_SELECT(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_RANGE_SELECT, fn)
|
|
|
|
def EVT_GRID_CELL_CHANGE(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_CELL_CHANGE, fn)
|
|
|
|
def EVT_GRID_SELECT_CELL(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_SELECT_CELL, fn)
|
|
|
|
def EVT_GRID_EDITOR_SHOWN(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_EDITOR_SHOWN, fn)
|
|
|
|
def EVT_GRID_EDITOR_HIDDEN(win, fn):
|
|
win.Connect(-1, -1, wxEVT_GRID_EDITOR_HIDDEN, fn)
|
|
|
|
"
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
%init %{
|
|
wxClassInfo::CleanUpClasses();
|
|
wxClassInfo::InitializeClasses();
|
|
%}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
%pragma(python) include="_gridextras.py";
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
#endif
|