#include "wx/textctrl.h"
#include "wx/combobox.h"
#include "wx/dynarray.h"
-
+#include "wx/timer.h"
// Default parameters for wxGrid
//
// prepare the DC using the given attribute: it will draw the rectangle
// with the bg colour from attr and set the text colour and font
virtual void Draw(wxGrid& grid,
+ wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rect,
int row, int col,
public:
// draw the string
virtual void Draw(wxGrid& grid,
+ wxGridCellAttr& attr,
wxDC& dc,
const wxRect& rect,
int row, int col,
bool isSelected);
};
+
+// ----------------------------------------------------------------------------
+// wxGridCellEditor: This class is responsible for providing and manipulating
+// the in-place edit controls for the grid. Instances of wxGridCellEditor
+// (actually, instances of derived classes since it is an ABC) can be
+// associated with the cell attributes for individual cells, rows, columns, or
+// even for the entire grid.
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxGridCellEditor
+{
+public:
+ wxGridCellEditor();
+ virtual ~wxGridCellEditor();
+
+ bool IsCreated() { return m_control != NULL; }
+
+ // Creates the actual edit control
+ virtual void Create(wxWindow* parent,
+ wxWindowID id,
+ wxEvtHandler* evtHandler) = 0;
+
+ // Size and position the edit control
+ virtual void SetSize(const wxRect& rect);
+
+ // Show or hide the edit control
+ virtual void Show(bool show);
+
+ // Fetch the value from the table and prepare the edit control
+ // to begin editing. Set the focus to the edit control.
+ virtual void BeginEdit(int row, int col, wxGrid* grid,
+ wxGridCellAttr* attr) = 0;
+
+ // Complete the editing of the current cell. If saveValue is
+ // true then send the new value back to the table. Returns true
+ // if the value has changed. If necessary, the control may be
+ // destroyed.
+ virtual bool EndEdit(int row, int col, bool saveValue,
+ wxGrid* grid, wxGridCellAttr* attr) = 0;
+
+ // Reset the value in the control back to its starting value
+ virtual void Reset() = 0;
+
+ // If the editor is enabled by pressing keys on the grid,
+ // this will be called to let the editor do something about
+ // that first key if desired.
+ virtual void StartingKey(wxKeyEvent& event);
+
+ // Some types of controls on some platforms may need some help
+ // with the Return key.
+ virtual void HandleReturn(wxKeyEvent& event);
+
+ // Final cleanup
+ virtual void Destroy();
+
+protected:
+ wxControl* m_control;
+};
+
+
+class WXDLLEXPORT wxGridCellTextEditor : public wxGridCellEditor
+{
+public:
+ wxGridCellTextEditor();
+
+ virtual void Create(wxWindow* parent,
+ wxWindowID id,
+ wxEvtHandler* evtHandler);
+
+ virtual void BeginEdit(int row, int col, wxGrid* grid,
+ wxGridCellAttr* attr);
+
+ virtual bool EndEdit(int row, int col, bool saveValue,
+ wxGrid* grid, wxGridCellAttr* attr);
+
+ virtual void Reset();
+ virtual void StartingKey(wxKeyEvent& event);
+ virtual void HandleReturn(wxKeyEvent& event);
+
+
+private:
+ wxString m_startValue;
+};
+
// ----------------------------------------------------------------------------
// wxGridCellAttr: this class can be used to alter the cells appearance in
// the grid by changing their colour/font/... from default. An object of this
// takes ownership of the pointer
void SetRenderer(wxGridCellRenderer *renderer)
{ delete m_renderer; m_renderer = renderer; }
+ void SetEditor(wxGridCellEditor* editor)
+ { delete m_editor; m_editor = editor; }
// accessors
bool HasTextColour() const { return m_colText.Ok(); }
bool HasBackgroundColour() const { return m_colBack.Ok(); }
bool HasFont() const { return m_font.Ok(); }
bool HasAlignment() const { return m_hAlign || m_vAlign; }
+ bool HasRenderer() const { return m_renderer != NULL; }
+ bool HasEditor() const { return m_editor != NULL; }
- const wxColour& GetTextColour() const { return m_colText; }
- const wxColour& GetBackgroundColour() const { return m_colBack; }
- const wxFont& GetFont() const { return m_font; }
- void GetAlignment(int *hAlign, int *vAlign)
- {
- if ( hAlign ) *hAlign = m_hAlign;
- if ( vAlign ) *vAlign = m_vAlign;
- }
+ const wxColour& GetTextColour() const;
+ const wxColour& GetBackgroundColour() const;
+ const wxFont& GetFont() const;
+ void GetAlignment(int *hAlign, int *vAlign) const;
+ wxGridCellRenderer *GetRenderer() const;
+ wxGridCellEditor *GetEditor() const;
- wxGridCellRenderer *GetRenderer() const { return m_renderer; }
+ void SetDefAttr(wxGridCellAttr* defAttr) { m_defGridAttr = defAttr; }
private:
// the common part of all ctors
- void Init() { m_nRef = 1; m_renderer = (wxGridCellRenderer *)NULL; }
+ void Init() {
+ m_nRef = 1;
+ m_renderer = NULL;
+ m_editor = NULL;
+ }
// the dtor is private because only DecRef() can delete us
- ~wxGridCellAttr() { delete m_renderer; }
+ ~wxGridCellAttr() { delete m_renderer; delete m_editor; }
// the ref count - when it goes to 0, we die
size_t m_nRef;
int m_hAlign,
m_vAlign;
- wxGridCellRenderer *m_renderer;
+ wxGridCellRenderer* m_renderer;
+ wxGridCellEditor* m_editor;
+ wxGridCellAttr* m_defGridAttr;
// suppress the stupid gcc warning about the class having private dtor and
// no friends
// implementation note: we separate it from wxGridTableBase because we wish to
// avoid deriving a new table class if possible, and sometimes it will be
// enough to just derive another wxGridCellAttrProvider instead
-
+//
+// the default implementation is reasonably efficient for the generic case,
+// but you might still wish to implement your own for some specific situations
+// if you have performance problems with the stock one
class WXDLLEXPORT wxGridCellAttrProvider
{
public:
// DecRef() must be called on the returned pointer
virtual wxGridCellAttr *GetAttr(int row, int col) const;
- // takes ownership of the pointer, don't call DecRef() on it
+ // all these functions take ownership of the pointer, don't call DecRef()
+ // on it
virtual void SetAttr(wxGridCellAttr *attr, int row, int col);
+ virtual void SetRowAttr(wxGridCellAttr *attr, int row);
+ virtual void SetColAttr(wxGridCellAttr *attr, int col);
private:
void InitData();
// overridden to handle attributes directly in this class.
virtual wxGridCellAttr *GetAttr( int row, int col );
- // takes ownership of the pointer
- virtual void SetAttr(wxGridCellAttr *attr, int row, int col );
+ // these functions take ownership of the pointer
+ virtual void SetAttr(wxGridCellAttr* attr, int row, int col);
+ virtual void SetRowAttr(wxGridCellAttr *attr, int row);
+ virtual void SetColAttr(wxGridCellAttr *attr, int col);
private:
wxGrid * m_view;
-// This set of classes is to provide for the use of different types of
-// cell edit controls in the grid while avoiding the wx class info
-// system in deference to wxPython
-
-class WXDLLEXPORT wxGridTextCtrl : public wxTextCtrl
-{
-public:
- wxGridTextCtrl() {}
- wxGridTextCtrl( wxWindow *,
- wxGrid *,
- bool isCellControl,
- wxWindowID id,
- const wxString& value = wxEmptyString,
- const wxPoint& pos = wxDefaultPosition,
- const wxSize& size = wxDefaultSize,
- long style = 0 );
-
- void SetStartValue( const wxString& );
- wxString GetStartValue() { return startValue; }
-
-private:
- wxGrid *m_grid;
-
- // TRUE for controls placed over cells,
- // FALSE for a control on a grid control panel
- bool m_isCellControl;
-
- wxString startValue;
-
- void OnKeyDown( wxKeyEvent& );
-
- DECLARE_DYNAMIC_CLASS( wxGridTextCtrl )
- DECLARE_EVENT_TABLE()
-};
-
// ----------------------------------------------------------------------------
// wxGrid
// ----------------------------------------------------------------------------
public:
wxGrid()
{
- m_table = (wxGridTableBase *) NULL;
- m_gridWin = (wxGridWindow *) NULL;
- m_rowLabelWin = (wxGridRowLabelWindow *) NULL;
- m_colLabelWin = (wxGridColLabelWindow *) NULL;
- m_cornerLabelWin = (wxGridCornerLabelWindow *) NULL;
- m_cellEditCtrl = (wxWindow *) NULL;
+ Create();
}
wxGrid( wxWindow *parent,
void DoEndDragResizeCol();
wxGridTableBase * GetTable() const { return m_table; }
- void SetTable( wxGridTableBase *table ) { m_table = table; }
+ bool SetTable( wxGridTableBase *table, bool takeOwnership=FALSE );
void ClearGrid();
bool InsertRows( int pos = 0, int numRows = 1, bool updateLabels=TRUE );
void DrawCellBorder( wxDC& dc, const wxGridCellCoords& );
void DrawAllGridLines( wxDC& dc, const wxRegion & reg );
void DrawCell( wxDC& dc, const wxGridCellCoords& );
+ void DrawCellHighlight( wxDC& dc );
void DrawRowLabels( wxDC& dc );
void DrawRowLabel( wxDC& dc, int row );
bool IsEditable() { return m_editable; }
void EnableEditing( bool edit );
-#if 0 // at the moment the cell edit control is always active
void EnableCellEditControl( bool enable );
-#endif
bool IsCellEditControlEnabled()
- { return (m_cellEditCtrl && m_cellEditCtrlEnabled); }
+ { return m_cellEditCtrlEnabled; }
void ShowCellEditControl();
void HideCellEditControl();
void SetColLabelValue( int col, const wxString& );
void SetGridLineColour( const wxColour& );
+ // this sets the specified attribute for all cells in this row/col
+ void SetRowAttr(int row, wxGridCellAttr *attr);
+ void SetColAttr(int col, wxGridCellAttr *attr);
+
void EnableGridLines( bool enable = TRUE );
bool GridLinesEnabled() { return m_gridLinesEnabled; }
void SetCellAlignment( int row, int col, int horiz, int vert );
// takes ownership of the pointer
- void SetDefaultRenderer(wxGridCellRenderer *renderer)
- { delete m_defaultRenderer; m_defaultRenderer = renderer; }
- wxGridCellRenderer *GetDefaultRenderer() const
- { return m_defaultRenderer; }
-
+ void SetDefaultRenderer(wxGridCellRenderer *renderer);
void SetCellRenderer(int row, int col, wxGridCellRenderer *renderer);
+ wxGridCellRenderer *GetDefaultRenderer() const;
+ wxGridCellRenderer* GetCellRenderer(int row, int col);
+
// ------ cell value accessors
//
m_selectedBottomRight );
}
+ // Access or update the selection fore/back colours
+ wxColour GetSelectionBackground() const
+ { return m_selectionBackground; }
+ wxColour GetSelectionForeground() const
+ { return m_selectionForeground; }
+
+ void SetSelectionBackground(const wxColour& c) { m_selectionBackground = c; }
+ void SetSelectionForeground(const wxColour& c) { m_selectionForeground = c; }
+
+
// ------ For compatibility with previous wxGrid only...
//
}
wxFont GetCellTextFont() const
- { return m_defaultCellFont; }
+ { return m_defaultCellAttr->GetFont(); }
wxFont GetCellTextFont(int WXUNUSED(row), int WXUNUSED(col)) const
- { return m_defaultCellFont; }
+ { return m_defaultCellAttr->GetFont(); }
void SetCellTextFont(const wxFont& fnt)
{ SetDefaultCellFont( fnt ); }
wxGridCornerLabelWindow *m_cornerLabelWin;
wxGridTableBase *m_table;
+ bool m_ownTable;
int m_left;
int m_top;
wxGridCellCoords m_selectedTopLeft;
wxGridCellCoords m_selectedBottomRight;
+ wxColour m_selectionBackground;
+ wxColour m_selectionForeground;
int m_defaultRowHeight;
wxArrayInt m_rowHeights;
int m_defaultColWidth;
wxArrayInt m_colWidths;
wxArrayInt m_colRights;
-
int m_rowLabelWidth;
int m_colLabelHeight;
wxColour m_gridLineColour;
bool m_gridLinesEnabled;
- // get the renderer for the given cell - if it has no special one, the
- // default one will be returned, never NULL
- wxGridCellRenderer *GetCellRenderer(int row, int col);
-
- wxGridCellRenderer *m_defaultRenderer;
-
- // default cell attributes
- wxFont m_defaultCellFont;
- int m_defaultCellHAlign,
- m_defaultCellVAlign;
// do we have some place to store attributes in?
bool CanHaveAttributes();
// looks for the attr in cache, if not found asks the table and caches the
// result
wxGridCellAttr *GetCellAttr(int row, int col) const;
+ wxGridCellAttr *GetCellAttr(const wxGridCellCoords& coords )
+ { return GetCellAttr( coords.GetRow(), coords.GetCol() ); }
+
+ // the default cell attr object for cells that don't have their own
+ wxGridCellAttr* m_defaultCellAttr;
+
wxGridCellCoordsArray m_cellsExposed;
wxArrayInt m_rowsExposed;
wxWindow *m_winCapture; // the window which captured the mouse
CursorMode m_cursorMode;
- int m_dragLastPos;
- int m_dragRowOrCol;
- bool m_isDragging;
+ int m_dragLastPos;
+ int m_dragRowOrCol;
+ bool m_isDragging;
+ wxPoint m_startDragPos;
+
+ bool m_waitForSlowClick;
wxGridCellCoords m_selectionStart;
wxCursor m_colResizeCursor;
bool m_editable; // applies to whole grid
- int m_editCtrlType; // for current cell
- wxWindow* m_cellEditCtrl;
bool m_cellEditCtrlEnabled;
void OnPaint( wxPaintEvent& );
void OnSize( wxSizeEvent& );
void OnKeyDown( wxKeyEvent& );
+ void OnEraseBackground( wxEraseEvent& );
void SetCurrentCell( const wxGridCellCoords& coords );
projects / wxWidgets.git / blobdiff