-// ----------------------------------------------------------------------------
-// array classes
-// ----------------------------------------------------------------------------
-
-WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridCellAttr *, wxArrayAttrs,
- class WXDLLIMPEXP_ADV);
-
-struct wxGridCellWithAttr
-{
- wxGridCellWithAttr(int row, int col, wxGridCellAttr *attr_)
- : coords(row, col), attr(attr_)
- {
- wxASSERT( attr );
- }
-
- wxGridCellWithAttr(const wxGridCellWithAttr& other)
- : coords(other.coords),
- attr(other.attr)
- {
- attr->IncRef();
- }
-
- wxGridCellWithAttr& operator=(const wxGridCellWithAttr& other)
- {
- coords = other.coords;
- if (attr != other.attr)
- {
- attr->DecRef();
- attr = other.attr;
- attr->IncRef();
- }
- return *this;
- }
-
- void ChangeAttr(wxGridCellAttr* new_attr)
- {
- if (attr != new_attr)
- {
- // "Delete" (i.e. DecRef) the old attribute.
- attr->DecRef();
- attr = new_attr;
- // Take ownership of the new attribute, i.e. no IncRef.
- }
- }
-
- ~wxGridCellWithAttr()
- {
- attr->DecRef();
- }
-
- wxGridCellCoords coords;
- wxGridCellAttr *attr;
-};
-
-WX_DECLARE_OBJARRAY_WITH_DECL(wxGridCellWithAttr, wxGridCellWithAttrArray,
- class WXDLLIMPEXP_ADV);
-
-#include "wx/arrimpl.cpp"
-
-WX_DEFINE_OBJARRAY(wxGridCellCoordsArray)
-WX_DEFINE_OBJARRAY(wxGridCellWithAttrArray)
-
-// ----------------------------------------------------------------------------
-// events
-// ----------------------------------------------------------------------------
-
-DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_CLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_CLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_LEFT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_RIGHT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_BEGIN_DRAG)
-DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_CLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_CLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_LEFT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_LABEL_RIGHT_DCLICK)
-DEFINE_EVENT_TYPE(wxEVT_GRID_ROW_SIZE)
-DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SIZE)
-DEFINE_EVENT_TYPE(wxEVT_GRID_COL_MOVE)
-DEFINE_EVENT_TYPE(wxEVT_GRID_COL_SORT)
-DEFINE_EVENT_TYPE(wxEVT_GRID_RANGE_SELECT)
-DEFINE_EVENT_TYPE(wxEVT_GRID_CELL_CHANGE)
-DEFINE_EVENT_TYPE(wxEVT_GRID_SELECT_CELL)
-DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_SHOWN)
-DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_HIDDEN)
-DEFINE_EVENT_TYPE(wxEVT_GRID_EDITOR_CREATED)
-
-// ----------------------------------------------------------------------------
-// private classes
-// ----------------------------------------------------------------------------
-
-// header column providing access to the column information stored in wxGrid
-// via wxHeaderColumn interface
-class wxGridHeaderColumn : public wxHeaderColumn
-{
-public:
- wxGridHeaderColumn(wxGrid *grid, int col)
- : m_grid(grid),
- m_col(col)
- {
- }
-
- virtual wxString GetTitle() const { return m_grid->GetColLabelValue(m_col); }
- virtual wxBitmap GetBitmap() const { return wxNullBitmap; }
- virtual int GetWidth() const { return m_grid->GetColSize(m_col); }
- virtual int GetMinWidth() const { return 0; }
- virtual wxAlignment GetAlignment() const
- {
- int horz,
- vert;
- m_grid->GetColLabelAlignment(&horz, &vert);
-
- return static_cast<wxAlignment>(horz);
- }
-
- virtual int GetFlags() const
- {
- // we can't know in advance whether we can sort by this column or not
- // with wxGrid API so suppose we can by default
- int flags = wxCOL_SORTABLE;
- if ( m_grid->CanDragColSize() )
- flags |= wxCOL_RESIZABLE;
- if ( m_grid->CanDragColMove() )
- flags |= wxCOL_REORDERABLE;
- if ( GetWidth() == 0 )
- flags |= wxCOL_HIDDEN;
-
- return flags;
- }
-
- virtual bool IsSortKey() const
- {
- return m_grid->IsSortingBy(m_col);
- }
-
- virtual bool IsSortOrderAscending() const
- {
- return m_grid->IsSortOrderAscending();
- }
-
-private:
- // these really should be const but are not because the column needs to be
- // assignable to be used in a wxVector (in STL build, in non-STL build we
- // avoid the need for this)
- wxGrid *m_grid;
- int m_col;
-};
-
-// header control retreiving column information from the grid
-class wxGridHeaderCtrl : public wxHeaderCtrl
-{
-public:
- wxGridHeaderCtrl(wxGrid *owner)
- : wxHeaderCtrl(owner,
- wxID_ANY,
- wxDefaultPosition,
- wxDefaultSize,
- wxHD_ALLOW_HIDE |
- (owner->CanDragColMove() ? wxHD_ALLOW_REORDER : 0))
- {
- }
-
-protected:
- virtual wxHeaderColumn& GetColumn(unsigned int idx)
- {
- return m_columns[idx];
- }
-
-private:
- wxGrid *GetOwner() const { return static_cast<wxGrid *>(GetParent()); }
-
- // override the base class method to update our m_columns array
- virtual void OnColumnCountChanging(unsigned int count)
- {
- const unsigned countOld = m_columns.size();
- if ( count < countOld )
- {
- // just discard the columns which don't exist any more (notice that
- // we can't use resize() here as it would require the vector
- // value_type, i.e. wxGridHeaderColumn to be default constructible,
- // which it is not)
- m_columns.erase(m_columns.begin() + count, m_columns.end());
- }
- else // new columns added
- {
- // add columns for the new elements
- for ( unsigned n = countOld; n < count; n++ )
- m_columns.push_back(wxGridHeaderColumn(GetOwner(), n));
- }
- }
-
- // override to implement column auto sizing
- virtual bool UpdateColumnWidthToFit(unsigned int idx, int widthTitle)
- {
- // TODO: currently grid doesn't support computing the column best width
- // from its contents so we just use the best label width as is
- GetOwner()->SetColSize(idx, widthTitle);
-
- return true;
- }
-
- // overridden to react to the actions using the columns popup menu
- virtual void UpdateColumnVisibility(unsigned int idx, bool show)
- {
- GetOwner()->SetColSize(idx, show ? wxGRID_AUTOSIZE : 0);
-
- // as this is done by the user we should notify the main program about
- // it
- GetOwner()->SendEvent(wxEVT_GRID_COL_SIZE, -1, idx);
- }
-
-
- // event handlers forwarding wxHeaderCtrl events to wxGrid
- void OnClick(wxHeaderCtrlEvent& event)
- {
- GetOwner()->DoColHeaderClick(event.GetColumn());
- }
-
- void OnBeginResize(wxHeaderCtrlEvent& event)
- {
- GetOwner()->DoStartResizeCol(event.GetColumn());
-
- event.Skip();
- }
-
- void OnResizing(wxHeaderCtrlEvent& event)
- {
- GetOwner()->DoUpdateResizeColWidth(event.GetWidth());
- }
-
- void OnEndResize(wxHeaderCtrlEvent& event)
- {
- GetOwner()->DoEndDragResizeCol();
-
- event.Skip();
- }
-
- void OnBeginReorder(wxHeaderCtrlEvent& event)
- {
- GetOwner()->DoStartMoveCol(event.GetColumn());
- }
-
- void OnEndReorder(wxHeaderCtrlEvent& event)
- {
- GetOwner()->DoEndMoveCol(event.GetNewOrder());
- }
-
- wxVector<wxGridHeaderColumn> m_columns;
-
- DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridHeaderCtrl)
-};
-
-BEGIN_EVENT_TABLE(wxGridHeaderCtrl, wxHeaderCtrl)
- EVT_HEADER_CLICK(wxID_ANY, wxGridHeaderCtrl::OnClick)
-
- EVT_HEADER_BEGIN_RESIZE(wxID_ANY, wxGridHeaderCtrl::OnBeginResize)
- EVT_HEADER_RESIZING(wxID_ANY, wxGridHeaderCtrl::OnResizing)
- EVT_HEADER_END_RESIZE(wxID_ANY, wxGridHeaderCtrl::OnEndResize)
-
- EVT_HEADER_BEGIN_REORDER(wxID_ANY, wxGridHeaderCtrl::OnBeginReorder)
- EVT_HEADER_END_REORDER(wxID_ANY, wxGridHeaderCtrl::OnEndReorder)
-END_EVENT_TABLE()
-
-// common base class for various grid subwindows
-class WXDLLIMPEXP_ADV wxGridSubwindow : public wxWindow
-{
-public:
- wxGridSubwindow(wxGrid *owner,
- int additionalStyle = 0,
- const wxString& name = wxPanelNameStr)
- : wxWindow(owner, wxID_ANY,
- wxDefaultPosition, wxDefaultSize,
- wxBORDER_NONE | additionalStyle,
- name)
- {
- m_owner = owner;
- }
-
- virtual bool AcceptsFocus() const { return false; }
-
- wxGrid *GetOwner() { return m_owner; }
-
-protected:
- void OnMouseCaptureLost(wxMouseCaptureLostEvent& event);
-
- wxGrid *m_owner;
-
- DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridSubwindow)
-};
-
-class WXDLLIMPEXP_ADV wxGridRowLabelWindow : public wxGridSubwindow
-{
-public:
- wxGridRowLabelWindow(wxGrid *parent)
- : wxGridSubwindow(parent)
- {
- }
-
-
-private:
- void OnPaint( wxPaintEvent& event );
- void OnMouseEvent( wxMouseEvent& event );
- void OnMouseWheel( wxMouseEvent& event );
-
- DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridRowLabelWindow)
-};
-
-
-class WXDLLIMPEXP_ADV wxGridColLabelWindow : public wxGridSubwindow
-{
-public:
- wxGridColLabelWindow(wxGrid *parent)
- : wxGridSubwindow(parent)
- {
- }
-
-
-private:
- void OnPaint( wxPaintEvent& event );
- void OnMouseEvent( wxMouseEvent& event );
- void OnMouseWheel( wxMouseEvent& event );
-
- DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridColLabelWindow)
-};
-
-
-class WXDLLIMPEXP_ADV wxGridCornerLabelWindow : public wxGridSubwindow
-{
-public:
- wxGridCornerLabelWindow(wxGrid *parent)
- : wxGridSubwindow(parent)
- {
- }
-
-private:
- void OnMouseEvent( wxMouseEvent& event );
- void OnMouseWheel( wxMouseEvent& event );
- void OnPaint( wxPaintEvent& event );
-
- DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridCornerLabelWindow)
-};
-
-class WXDLLIMPEXP_ADV wxGridWindow : public wxGridSubwindow
-{
-public:
- wxGridWindow(wxGrid *parent)
- : wxGridSubwindow(parent,
- wxWANTS_CHARS | wxCLIP_CHILDREN,
- "GridWindow")
- {
- }
-
-
- virtual void ScrollWindow( int dx, int dy, const wxRect *rect );
-
- virtual bool AcceptsFocus() const { return true; }
-
-private:
- void OnPaint( wxPaintEvent &event );
- void OnMouseWheel( wxMouseEvent& event );
- void OnMouseEvent( wxMouseEvent& event );
- void OnKeyDown( wxKeyEvent& );
- void OnKeyUp( wxKeyEvent& );
- void OnChar( wxKeyEvent& );
- void OnEraseBackground( wxEraseEvent& );
- void OnFocus( wxFocusEvent& );
-
- DECLARE_EVENT_TABLE()
- DECLARE_NO_COPY_CLASS(wxGridWindow)
-};
-
-
-class wxGridCellEditorEvtHandler : public wxEvtHandler
-{
-public:
- wxGridCellEditorEvtHandler(wxGrid* grid, wxGridCellEditor* editor)
- : m_grid(grid),
- m_editor(editor),
- m_inSetFocus(false)
- {
- }
-
- void OnKillFocus(wxFocusEvent& event);
- void OnKeyDown(wxKeyEvent& event);
- void OnChar(wxKeyEvent& event);
-
- void SetInSetFocus(bool inSetFocus) { m_inSetFocus = inSetFocus; }
-
-private:
- wxGrid *m_grid;
- wxGridCellEditor *m_editor;
-
- // Work around the fact that a focus kill event can be sent to
- // a combobox within a set focus event.
- bool m_inSetFocus;
-
- DECLARE_EVENT_TABLE()
- DECLARE_DYNAMIC_CLASS(wxGridCellEditorEvtHandler)
- DECLARE_NO_COPY_CLASS(wxGridCellEditorEvtHandler)
-};
-
-
-IMPLEMENT_ABSTRACT_CLASS(wxGridCellEditorEvtHandler, wxEvtHandler)
-
-BEGIN_EVENT_TABLE( wxGridCellEditorEvtHandler, wxEvtHandler )
- EVT_KILL_FOCUS( wxGridCellEditorEvtHandler::OnKillFocus )
- EVT_KEY_DOWN( wxGridCellEditorEvtHandler::OnKeyDown )
- EVT_CHAR( wxGridCellEditorEvtHandler::OnChar )
-END_EVENT_TABLE()
-
-
-// ----------------------------------------------------------------------------
-// the internal data representation used by wxGridCellAttrProvider
-// ----------------------------------------------------------------------------
-
-// this class stores attributes set for cells
-class WXDLLIMPEXP_ADV wxGridCellAttrData
-{
-public:
- void SetAttr(wxGridCellAttr *attr, int row, int col);
- wxGridCellAttr *GetAttr(int row, int col) const;
- void UpdateAttrRows( size_t pos, int numRows );
- void UpdateAttrCols( size_t pos, int numCols );
-
-private:
- // searches for the attr for given cell, returns wxNOT_FOUND if not found
- int FindIndex(int row, int col) const;
-
- wxGridCellWithAttrArray m_attrs;
-};
-
-// this class stores attributes set for rows or columns
-class WXDLLIMPEXP_ADV wxGridRowOrColAttrData
-{
-public:
- // empty ctor to suppress warnings
- wxGridRowOrColAttrData() {}
- ~wxGridRowOrColAttrData();
-
- void SetAttr(wxGridCellAttr *attr, int rowOrCol);
- wxGridCellAttr *GetAttr(int rowOrCol) const;
- void UpdateAttrRowsOrCols( size_t pos, int numRowsOrCols );
-
-private:
- wxArrayInt m_rowsOrCols;
- wxArrayAttrs m_attrs;
-};
-
-// NB: this is just a wrapper around 3 objects: one which stores cell
-// attributes, and 2 others for row/col ones
-class WXDLLIMPEXP_ADV wxGridCellAttrProviderData
-{
-public:
- wxGridCellAttrData m_cellAttrs;
- wxGridRowOrColAttrData m_rowAttrs,
- m_colAttrs;
-};
-
-
-// ----------------------------------------------------------------------------
-// data structures used for the data type registry
-// ----------------------------------------------------------------------------
-
-struct wxGridDataTypeInfo
-{
- wxGridDataTypeInfo(const wxString& typeName,
- wxGridCellRenderer* renderer,
- wxGridCellEditor* editor)
- : m_typeName(typeName), m_renderer(renderer), m_editor(editor)
- {}
-
- ~wxGridDataTypeInfo()
- {
- wxSafeDecRef(m_renderer);
- wxSafeDecRef(m_editor);
- }
-
- wxString m_typeName;
- wxGridCellRenderer* m_renderer;
- wxGridCellEditor* m_editor;
-
- DECLARE_NO_COPY_CLASS(wxGridDataTypeInfo)
-};
-
-
-WX_DEFINE_ARRAY_WITH_DECL_PTR(wxGridDataTypeInfo*, wxGridDataTypeInfoArray,
- class WXDLLIMPEXP_ADV);
-
-
-class WXDLLIMPEXP_ADV wxGridTypeRegistry
-{
-public:
- wxGridTypeRegistry() {}
- ~wxGridTypeRegistry();
-
- void RegisterDataType(const wxString& typeName,
- wxGridCellRenderer* renderer,
- wxGridCellEditor* editor);
-
- // find one of already registered data types
- int FindRegisteredDataType(const wxString& typeName);
-
- // try to FindRegisteredDataType(), if this fails and typeName is one of
- // standard typenames, register it and return its index
- int FindDataType(const wxString& typeName);
-
- // try to FindDataType(), if it fails see if it is not one of already
- // registered data types with some params in which case clone the
- // registered data type and set params for it
- int FindOrCloneDataType(const wxString& typeName);
-
- wxGridCellRenderer* GetRenderer(int index);
- wxGridCellEditor* GetEditor(int index);
-
-private:
- wxGridDataTypeInfoArray m_typeinfo;
-};
-
-// ----------------------------------------------------------------------------
-// operations classes abstracting the difference between operating on rows and
-// columns
-// ----------------------------------------------------------------------------
-
-// This class allows to write a function only once because by using its methods
-// it will apply to both columns and rows.
-//
-// This is an abstract interface definition, the two concrete implementations
-// below should be used when working with rows and columns respectively.
-class wxGridOperations
-{
-public:
- // Returns the operations in the other direction, i.e. wxGridRowOperations
- // if this object is a wxGridColumnOperations and vice versa.
- virtual wxGridOperations& Dual() const = 0;
-
- // Return the number of rows or columns.
- virtual int GetNumberOfLines(const wxGrid *grid) const = 0;
-
- // Return the selection mode which allows selecting rows or columns.
- virtual wxGrid::wxGridSelectionModes GetSelectionMode() const = 0;
-
- // Make a wxGridCellCoords from the given components: thisDir is row or
- // column and otherDir is column or row
- virtual wxGridCellCoords MakeCoords(int thisDir, int otherDir) const = 0;
-
- // Calculate the scrolled position of the given abscissa or ordinate.
- virtual int CalcScrolledPosition(wxGrid *grid, int pos) const = 0;
-
- // Selects the horizontal or vertical component from the given object.
- virtual int Select(const wxGridCellCoords& coords) const = 0;
- virtual int Select(const wxPoint& pt) const = 0;
- virtual int Select(const wxSize& sz) const = 0;
- virtual int Select(const wxRect& r) const = 0;
- virtual int& Select(wxRect& r) const = 0;
-
- // Returns width or height of the rectangle
- virtual int& SelectSize(wxRect& r) const = 0;
-
- // Make a wxSize such that Select() applied to it returns first component
- virtual wxSize MakeSize(int first, int second) const = 0;
-
- // Sets the row or column component of the given cell coordinates
- virtual void Set(wxGridCellCoords& coords, int line) const = 0;
-
-
- // Draws a line parallel to the row or column, i.e. horizontal or vertical:
- // pos is the horizontal or vertical position of the line and start and end
- // are the coordinates of the line extremities in the other direction
- virtual void
- DrawParallelLine(wxDC& dc, int start, int end, int pos) const = 0;
-
- // Draw a horizontal or vertical line across the given rectangle
- // (this is implemented in terms of above and uses Select() to extract
- // start and end from the given rectangle)
- void DrawParallelLineInRect(wxDC& dc, const wxRect& rect, int pos) const
- {
- const int posStart = Select(rect.GetPosition());
- DrawParallelLine(dc, posStart, posStart + Select(rect.GetSize()), pos);
- }
-
-
- // Return the index of the row or column at the given pixel coordinate.
- virtual int
- PosToLine(const wxGrid *grid, int pos, bool clip = false) const = 0;
-
- // Get the top/left position, in pixels, of the given row or column
- virtual int GetLineStartPos(const wxGrid *grid, int line) const = 0;
-
- // Get the bottom/right position, in pixels, of the given row or column
- virtual int GetLineEndPos(const wxGrid *grid, int line) const = 0;
-
- // Get the height/width of the given row/column
- virtual int GetLineSize(const wxGrid *grid, int line) const = 0;
-
- // Get wxGrid::m_rowBottoms/m_colRights array
- virtual const wxArrayInt& GetLineEnds(const wxGrid *grid) const = 0;
-
- // Get default height row height or column width
- virtual int GetDefaultLineSize(const wxGrid *grid) const = 0;
-
- // Return the minimal acceptable row height or column width
- virtual int GetMinimalAcceptableLineSize(const wxGrid *grid) const = 0;
-
- // Return the minimal row height or column width
- virtual int GetMinimalLineSize(const wxGrid *grid, int line) const = 0;
-
- // Set the row height or column width
- virtual void SetLineSize(wxGrid *grid, int line, int size) const = 0;
-
- // True if rows/columns can be resized by user
- virtual bool CanResizeLines(const wxGrid *grid) const = 0;
-
-
- // Return the index of the line at the given position
- //
- // NB: currently this is always identity for the rows as reordering is only
- // implemented for the lines
- virtual int GetLineAt(const wxGrid *grid, int line) const = 0;
-
-
- // Get the row or column label window
- virtual wxWindow *GetHeaderWindow(wxGrid *grid) const = 0;
-
- // Get the width or height of the row or column label window
- virtual int GetHeaderWindowSize(wxGrid *grid) const = 0;
-
-
- // This class is never used polymorphically but give it a virtual dtor
- // anyhow to suppress g++ complaints about it
- virtual ~wxGridOperations() { }
-};
-
-class wxGridRowOperations : public wxGridOperations
-{
-public:
- virtual wxGridOperations& Dual() const;
-
- virtual int GetNumberOfLines(const wxGrid *grid) const
- { return grid->GetNumberRows(); }
-
- virtual wxGrid::wxGridSelectionModes GetSelectionMode() const
- { return wxGrid::wxGridSelectRows; }
-
- virtual wxGridCellCoords MakeCoords(int thisDir, int otherDir) const
- { return wxGridCellCoords(thisDir, otherDir); }
-
- virtual int CalcScrolledPosition(wxGrid *grid, int pos) const
- { return grid->CalcScrolledPosition(wxPoint(pos, 0)).x; }
-
- virtual int Select(const wxGridCellCoords& c) const { return c.GetRow(); }
- virtual int Select(const wxPoint& pt) const { return pt.x; }
- virtual int Select(const wxSize& sz) const { return sz.x; }
- virtual int Select(const wxRect& r) const { return r.x; }
- virtual int& Select(wxRect& r) const { return r.x; }
- virtual int& SelectSize(wxRect& r) const { return r.width; }
- virtual wxSize MakeSize(int first, int second) const
- { return wxSize(first, second); }
- virtual void Set(wxGridCellCoords& coords, int line) const
- { coords.SetRow(line); }
-
- virtual void DrawParallelLine(wxDC& dc, int start, int end, int pos) const
- { dc.DrawLine(start, pos, end, pos); }
-
- virtual int PosToLine(const wxGrid *grid, int pos, bool clip = false) const
- { return grid->YToRow(pos, clip); }
- virtual int GetLineStartPos(const wxGrid *grid, int line) const
- { return grid->GetRowTop(line); }
- virtual int GetLineEndPos(const wxGrid *grid, int line) const
- { return grid->GetRowBottom(line); }
- virtual int GetLineSize(const wxGrid *grid, int line) const
- { return grid->GetRowHeight(line); }
- virtual const wxArrayInt& GetLineEnds(const wxGrid *grid) const
- { return grid->m_rowBottoms; }
- virtual int GetDefaultLineSize(const wxGrid *grid) const
- { return grid->GetDefaultRowSize(); }
- virtual int GetMinimalAcceptableLineSize(const wxGrid *grid) const
- { return grid->GetRowMinimalAcceptableHeight(); }
- virtual int GetMinimalLineSize(const wxGrid *grid, int line) const
- { return grid->GetRowMinimalHeight(line); }
- virtual void SetLineSize(wxGrid *grid, int line, int size) const
- { grid->SetRowSize(line, size); }
- virtual bool CanResizeLines(const wxGrid *grid) const
- { return grid->CanDragRowSize(); }
-
- virtual int GetLineAt(const wxGrid * WXUNUSED(grid), int line) const
- { return line; } // TODO: implement row reordering
-
- virtual wxWindow *GetHeaderWindow(wxGrid *grid) const
- { return grid->GetGridRowLabelWindow(); }
- virtual int GetHeaderWindowSize(wxGrid *grid) const
- { return grid->GetRowLabelSize(); }
-};
-
-class wxGridColumnOperations : public wxGridOperations
-{
-public:
- virtual wxGridOperations& Dual() const;
-
- virtual int GetNumberOfLines(const wxGrid *grid) const
- { return grid->GetNumberCols(); }
-
- virtual wxGrid::wxGridSelectionModes GetSelectionMode() const
- { return wxGrid::wxGridSelectColumns; }
-
- virtual wxGridCellCoords MakeCoords(int thisDir, int otherDir) const
- { return wxGridCellCoords(otherDir, thisDir); }
-
- virtual int CalcScrolledPosition(wxGrid *grid, int pos) const
- { return grid->CalcScrolledPosition(wxPoint(0, pos)).y; }
-
- virtual int Select(const wxGridCellCoords& c) const { return c.GetCol(); }
- virtual int Select(const wxPoint& pt) const { return pt.y; }
- virtual int Select(const wxSize& sz) const { return sz.y; }
- virtual int Select(const wxRect& r) const { return r.y; }
- virtual int& Select(wxRect& r) const { return r.y; }
- virtual int& SelectSize(wxRect& r) const { return r.height; }
- virtual wxSize MakeSize(int first, int second) const
- { return wxSize(second, first); }
- virtual void Set(wxGridCellCoords& coords, int line) const
- { coords.SetCol(line); }
-
- virtual void DrawParallelLine(wxDC& dc, int start, int end, int pos) const
- { dc.DrawLine(pos, start, pos, end); }
-
- virtual int PosToLine(const wxGrid *grid, int pos, bool clip = false) const
- { return grid->XToCol(pos, clip); }
- virtual int GetLineStartPos(const wxGrid *grid, int line) const
- { return grid->GetColLeft(line); }
- virtual int GetLineEndPos(const wxGrid *grid, int line) const
- { return grid->GetColRight(line); }
- virtual int GetLineSize(const wxGrid *grid, int line) const
- { return grid->GetColWidth(line); }
- virtual const wxArrayInt& GetLineEnds(const wxGrid *grid) const
- { return grid->m_colRights; }
- virtual int GetDefaultLineSize(const wxGrid *grid) const
- { return grid->GetDefaultColSize(); }
- virtual int GetMinimalAcceptableLineSize(const wxGrid *grid) const
- { return grid->GetColMinimalAcceptableWidth(); }
- virtual int GetMinimalLineSize(const wxGrid *grid, int line) const
- { return grid->GetColMinimalWidth(line); }
- virtual void SetLineSize(wxGrid *grid, int line, int size) const
- { grid->SetColSize(line, size); }
- virtual bool CanResizeLines(const wxGrid *grid) const
- { return grid->CanDragColSize(); }
-
- virtual int GetLineAt(const wxGrid *grid, int line) const
- { return grid->GetColAt(line); }
-
- virtual wxWindow *GetHeaderWindow(wxGrid *grid) const
- { return grid->GetGridColLabelWindow(); }
- virtual int GetHeaderWindowSize(wxGrid *grid) const
- { return grid->GetColLabelSize(); }
-};
-
-wxGridOperations& wxGridRowOperations::Dual() const
-{
- static wxGridColumnOperations s_colOper;
-
- return s_colOper;
-}
-
-wxGridOperations& wxGridColumnOperations::Dual() const
-{
- static wxGridRowOperations s_rowOper;
-
- return s_rowOper;
-}
-
-// This class abstracts the difference between operations going forward
-// (down/right) and backward (up/left) and allows to use the same code for
-// functions which differ only in the direction of grid traversal
-//
-// Like wxGridOperations it's an ABC with two concrete subclasses below. Unlike
-// it, this is a normal object and not just a function dispatch table and has a
-// non-default ctor.
-//
-// Note: the explanation of this discrepancy is the existence of (very useful)
-// Dual() method in wxGridOperations which forces us to make wxGridOperations a
-// function dispatcher only.
-class wxGridDirectionOperations
-{
-public:
- // The oper parameter to ctor selects whether we work with rows or columns
- wxGridDirectionOperations(wxGrid *grid, const wxGridOperations& oper)
- : m_grid(grid),
- m_oper(oper)
- {
- }
-
- // Check if the component of this point in our direction is at the
- // boundary, i.e. is the first/last row/column
- virtual bool IsAtBoundary(const wxGridCellCoords& coords) const = 0;
-
- // Increment the component of this point in our direction
- virtual void Advance(wxGridCellCoords& coords) const = 0;
-
- // Find the line at the given distance, in pixels, away from this one
- // (this uses clipping, i.e. anything after the last line is counted as the
- // last one and anything before the first one as 0)
- virtual int MoveByPixelDistance(int line, int distance) const = 0;
-
- // This class is never used polymorphically but give it a virtual dtor
- // anyhow to suppress g++ complaints about it
- virtual ~wxGridDirectionOperations() { }
-
-protected:
- wxGrid * const m_grid;
- const wxGridOperations& m_oper;
-};
-
-class wxGridBackwardOperations : public wxGridDirectionOperations
-{
-public:
- wxGridBackwardOperations(wxGrid *grid, const wxGridOperations& oper)
- : wxGridDirectionOperations(grid, oper)
- {
- }
-
- virtual bool IsAtBoundary(const wxGridCellCoords& coords) const
- {
- wxASSERT_MSG( m_oper.Select(coords) >= 0, "invalid row/column" );
-
- return m_oper.Select(coords) == 0;
- }
-
- virtual void Advance(wxGridCellCoords& coords) const
- {
- wxASSERT( !IsAtBoundary(coords) );
-
- m_oper.Set(coords, m_oper.Select(coords) - 1);
- }
-
- virtual int MoveByPixelDistance(int line, int distance) const
- {
- int pos = m_oper.GetLineStartPos(m_grid, line);
- return m_oper.PosToLine(m_grid, pos - distance + 1, true);
- }
-};
-
-class wxGridForwardOperations : public wxGridDirectionOperations
-{
-public:
- wxGridForwardOperations(wxGrid *grid, const wxGridOperations& oper)
- : wxGridDirectionOperations(grid, oper),
- m_numLines(oper.GetNumberOfLines(grid))
- {
- }
-
- virtual bool IsAtBoundary(const wxGridCellCoords& coords) const
- {
- wxASSERT_MSG( m_oper.Select(coords) < m_numLines, "invalid row/column" );
-
- return m_oper.Select(coords) == m_numLines - 1;
- }
-
- virtual void Advance(wxGridCellCoords& coords) const
- {
- wxASSERT( !IsAtBoundary(coords) );
-
- m_oper.Set(coords, m_oper.Select(coords) + 1);
- }
-
- virtual int MoveByPixelDistance(int line, int distance) const
- {
- int pos = m_oper.GetLineStartPos(m_grid, line);
- return m_oper.PosToLine(m_grid, pos + distance, true);
- }
-
-private:
- const int m_numLines;
-};
-
-// ----------------------------------------------------------------------------
-// globals
-// ----------------------------------------------------------------------------
-
-//#define DEBUG_ATTR_CACHE
-#ifdef DEBUG_ATTR_CACHE
- static size_t gs_nAttrCacheHits = 0;
- static size_t gs_nAttrCacheMisses = 0;
-#endif
-
-// ----------------------------------------------------------------------------
-// constants
-// ----------------------------------------------------------------------------
-
-wxGridCellCoords wxGridNoCellCoords( -1, -1 );
-wxRect wxGridNoCellRect( -1, -1, -1, -1 );
-
-namespace
-{
-
-// scroll line size
-const size_t GRID_SCROLL_LINE_X = 15;
-const size_t GRID_SCROLL_LINE_Y = GRID_SCROLL_LINE_X;
-
-// the size of hash tables used a bit everywhere (the max number of elements
-// in these hash tables is the number of rows/columns)
-const int GRID_HASH_SIZE = 100;
-
-// the minimal distance in pixels the mouse needs to move to start a drag
-// operation
-const int DRAG_SENSITIVITY = 3;
-
-} // anonymous namespace
-
-// ----------------------------------------------------------------------------
-// private helpers
-// ----------------------------------------------------------------------------
-
-namespace
-{
-
-// ensure that first is less or equal to second, swapping the values if
-// necessary
-void EnsureFirstLessThanSecond(int& first, int& second)
-{
- if ( first > second )
- wxSwap(first, second);
-}
-
-} // anonymous namespace
-
-// ============================================================================
-// implementation
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// wxGridCellEditor
-// ----------------------------------------------------------------------------
-
-wxGridCellEditor::wxGridCellEditor()
-{
- m_control = NULL;
- m_attr = NULL;
-}
-
-wxGridCellEditor::~wxGridCellEditor()
-{
- Destroy();
-}
-
-void wxGridCellEditor::Create(wxWindow* WXUNUSED(parent),
- wxWindowID WXUNUSED(id),
- wxEvtHandler* evtHandler)
-{
- if ( evtHandler )
- m_control->PushEventHandler(evtHandler);
-}
-
-void wxGridCellEditor::PaintBackground(const wxRect& rectCell,
- wxGridCellAttr *attr)
-{
- // erase the background because we might not fill the cell
- wxClientDC dc(m_control->GetParent());
- wxGridWindow* gridWindow = wxDynamicCast(m_control->GetParent(), wxGridWindow);
- if (gridWindow)
- gridWindow->GetOwner()->PrepareDC(dc);
-
- dc.SetPen(*wxTRANSPARENT_PEN);
- dc.SetBrush(wxBrush(attr->GetBackgroundColour()));
- dc.DrawRectangle(rectCell);
-
- // redraw the control we just painted over
- m_control->Refresh();
-}
-
-void wxGridCellEditor::Destroy()
-{
- if (m_control)
- {
- m_control->PopEventHandler( true /* delete it*/ );
-
- m_control->Destroy();
- m_control = NULL;
- }
-}
-
-void wxGridCellEditor::Show(bool show, wxGridCellAttr *attr)
-{
- wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
-
- m_control->Show(show);
-
- if ( show )
- {
- // set the colours/fonts if we have any
- if ( attr )
- {
- m_colFgOld = m_control->GetForegroundColour();
- m_control->SetForegroundColour(attr->GetTextColour());
-
- m_colBgOld = m_control->GetBackgroundColour();
- m_control->SetBackgroundColour(attr->GetBackgroundColour());
-
-// Workaround for GTK+1 font setting problem on some platforms
-#if !defined(__WXGTK__) || defined(__WXGTK20__)
- m_fontOld = m_control->GetFont();
- m_control->SetFont(attr->GetFont());
-#endif
-
- // can't do anything more in the base class version, the other
- // attributes may only be used by the derived classes
- }
- }
- else
- {
- // restore the standard colours fonts
- if ( m_colFgOld.Ok() )
- {
- m_control->SetForegroundColour(m_colFgOld);
- m_colFgOld = wxNullColour;
- }
-
- if ( m_colBgOld.Ok() )
- {
- m_control->SetBackgroundColour(m_colBgOld);
- m_colBgOld = wxNullColour;
- }
-
-// Workaround for GTK+1 font setting problem on some platforms
-#if !defined(__WXGTK__) || defined(__WXGTK20__)
- if ( m_fontOld.Ok() )
- {
- m_control->SetFont(m_fontOld);
- m_fontOld = wxNullFont;
- }
-#endif
- }
-}
-
-void wxGridCellEditor::SetSize(const wxRect& rect)
-{
- wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
-
- m_control->SetSize(rect, wxSIZE_ALLOW_MINUS_ONE);
-}
-
-void wxGridCellEditor::HandleReturn(wxKeyEvent& event)
-{
- event.Skip();
-}
-
-bool wxGridCellEditor::IsAcceptedKey(wxKeyEvent& event)
-{
- bool ctrl = event.ControlDown();
- bool alt = event.AltDown();
-
-#ifdef __WXMAC__
- // On the Mac the Alt key is more like shift and is used for entry of
- // valid characters, so check for Ctrl and Meta instead.
- alt = event.MetaDown();
-#endif
-
- // Assume it's not a valid char if ctrl or alt is down, but if both are
- // down then it may be because of an AltGr key combination, so let them
- // through in that case.
- if ((ctrl || alt) && !(ctrl && alt))
- return false;
-
-#if wxUSE_UNICODE
- // if the unicode key code is not really a unicode character (it may
- // be a function key or etc., the platforms appear to always give us a
- // small value in this case) then fallback to the ASCII key code but
- // don't do anything for function keys or etc.
- if ( event.GetUnicodeKey() > 127 && event.GetKeyCode() > 127 )
- return false;
-#else
- if ( event.GetKeyCode() > 255 )
- return false;
-#endif
-
- return true;
-}
-
-void wxGridCellEditor::StartingKey(wxKeyEvent& event)
-{
- event.Skip();
-}
-
-void wxGridCellEditor::StartingClick()
-{
-}
-
-#if wxUSE_TEXTCTRL
-
-// ----------------------------------------------------------------------------
-// wxGridCellTextEditor
-// ----------------------------------------------------------------------------
-
-wxGridCellTextEditor::wxGridCellTextEditor()
-{
- m_maxChars = 0;
-}
-
-void wxGridCellTextEditor::Create(wxWindow* parent,
- wxWindowID id,
- wxEvtHandler* evtHandler)
-{
- DoCreate(parent, id, evtHandler);
-}
-
-void wxGridCellTextEditor::DoCreate(wxWindow* parent,
- wxWindowID id,
- wxEvtHandler* evtHandler,
- long style)
-{
- style |= wxTE_PROCESS_ENTER | wxTE_PROCESS_TAB | wxNO_BORDER;
-
- m_control = new wxTextCtrl(parent, id, wxEmptyString,
- wxDefaultPosition, wxDefaultSize,
- style);
-
- // set max length allowed in the textctrl, if the parameter was set
- if ( m_maxChars != 0 )
- {
- Text()->SetMaxLength(m_maxChars);
- }
-
- wxGridCellEditor::Create(parent, id, evtHandler);
-}
-
-void wxGridCellTextEditor::PaintBackground(const wxRect& WXUNUSED(rectCell),
- wxGridCellAttr * WXUNUSED(attr))
-{
- // as we fill the entire client area,
- // don't do anything here to minimize flicker
-}
-
-void wxGridCellTextEditor::SetSize(const wxRect& rectOrig)
-{
- wxRect rect(rectOrig);
-
- // Make the edit control large enough to allow for internal margins
- //
- // TODO: remove this if the text ctrl sizing is improved esp. for unix
- //
-#if defined(__WXGTK__)
- if (rect.x != 0)
- {
- rect.x += 1;
- rect.y += 1;
- rect.width -= 1;
- rect.height -= 1;
- }
-#elif defined(__WXMSW__)
- if ( rect.x == 0 )
- rect.x += 2;
- else
- rect.x += 3;
-
- if ( rect.y == 0 )
- rect.y += 2;
- else
- rect.y += 3;
-
- rect.width -= 2;
- rect.height -= 2;
-#else
- int extra_x = ( rect.x > 2 ) ? 2 : 1;
- int extra_y = ( rect.y > 2 ) ? 2 : 1;
-
- #if defined(__WXMOTIF__)
- extra_x *= 2;
- extra_y *= 2;
- #endif
-
- rect.SetLeft( wxMax(0, rect.x - extra_x) );
- rect.SetTop( wxMax(0, rect.y - extra_y) );
- rect.SetRight( rect.GetRight() + 2 * extra_x );
- rect.SetBottom( rect.GetBottom() + 2 * extra_y );
-#endif
-
- wxGridCellEditor::SetSize(rect);
-}
-
-void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid* grid)
-{
- wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
-
- m_startValue = grid->GetTable()->GetValue(row, col);
-
- DoBeginEdit(m_startValue);
-}
-
-void wxGridCellTextEditor::DoBeginEdit(const wxString& startValue)
-{
- Text()->SetValue(startValue);
- Text()->SetInsertionPointEnd();
- Text()->SetSelection(-1, -1);
- Text()->SetFocus();
-}
-
-bool wxGridCellTextEditor::EndEdit(int row, int col, wxGrid* grid)
-{
- wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
-
- bool changed = false;
- wxString value = Text()->GetValue();
- if (value != m_startValue)
- changed = true;
-
- if (changed)
- grid->GetTable()->SetValue(row, col, value);
-
- m_startValue = wxEmptyString;
-
- // No point in setting the text of the hidden control
- //Text()->SetValue(m_startValue);
-
- return changed;
-}
-
-void wxGridCellTextEditor::Reset()
-{
- wxASSERT_MSG(m_control, wxT("The wxGridCellEditor must be created first!"));
-
- DoReset(m_startValue);
-}
-
-void wxGridCellTextEditor::DoReset(const wxString& startValue)
-{
- Text()->SetValue(startValue);
- Text()->SetInsertionPointEnd();
-}
-
-bool wxGridCellTextEditor::IsAcceptedKey(wxKeyEvent& event)
-{
- return wxGridCellEditor::IsAcceptedKey(event);
-}
-
-void wxGridCellTextEditor::StartingKey(wxKeyEvent& event)
-{
- // Since this is now happening in the EVT_CHAR event EmulateKeyPress is no
- // longer an appropriate way to get the character into the text control.
- // Do it ourselves instead. We know that if we get this far that we have
- // a valid character, so not a whole lot of testing needs to be done.
-
- wxTextCtrl* tc = Text();
- wxChar ch;
- long pos;
-
-#if wxUSE_UNICODE
- ch = event.GetUnicodeKey();
- if (ch <= 127)
- ch = (wxChar)event.GetKeyCode();
-#else
- ch = (wxChar)event.GetKeyCode();
-#endif
-
- switch (ch)
- {
- case WXK_DELETE:
- // delete the character at the cursor
- pos = tc->GetInsertionPoint();
- if (pos < tc->GetLastPosition())
- tc->Remove(pos, pos + 1);
- break;
-
- case WXK_BACK:
- // delete the character before the cursor
- pos = tc->GetInsertionPoint();
- if (pos > 0)
- tc->Remove(pos - 1, pos);
- break;
-
- default:
- tc->WriteText(ch);
- break;
- }
-}
-
-void wxGridCellTextEditor::HandleReturn( wxKeyEvent&
- WXUNUSED_GTK(WXUNUSED_MOTIF(event)) )
-{
-#if defined(__WXMOTIF__) || defined(__WXGTK__)
- // wxMotif needs a little extra help...
- size_t pos = (size_t)( Text()->GetInsertionPoint() );
- wxString s( Text()->GetValue() );
- s = s.Left(pos) + wxT("\n") + s.Mid(pos);
- Text()->SetValue(s);
- Text()->SetInsertionPoint( pos );
-#else
- // the other ports can handle a Return key press
- //
- event.Skip();
-#endif
-}
-
-void wxGridCellTextEditor::SetParameters(const wxString& params)
-{
- if ( !params )
- {
- // reset to default
- m_maxChars = 0;
- }
- else
- {
- long tmp;
- if ( params.ToLong(&tmp) )
- {
- m_maxChars = (size_t)tmp;
- }
- else
- {
- wxLogDebug( _T("Invalid wxGridCellTextEditor parameter string '%s' ignored"), params.c_str() );
- }
- }
-}
-
-// return the value in the text control
-wxString wxGridCellTextEditor::GetValue() const
-{
- return Text()->GetValue();
-}
-
-// ----------------------------------------------------------------------------
-// wxGridCellNumberEditor
-// ----------------------------------------------------------------------------
-
-wxGridCellNumberEditor::wxGridCellNumberEditor(int min, int max)
-{
- m_min = min;
- m_max = max;
-}
-
-void wxGridCellNumberEditor::Create(wxWindow* parent,
- wxWindowID id,
- wxEvtHandler* evtHandler)
-{
-#if wxUSE_SPINCTRL
- if ( HasRange() )
- {
- // create a spin ctrl
- m_control = new wxSpinCtrl(parent, wxID_ANY, wxEmptyString,
- wxDefaultPosition, wxDefaultSize,
- wxSP_ARROW_KEYS,
- m_min, m_max);
-
- wxGridCellEditor::Create(parent, id, evtHandler);
- }
- else
-#endif
- {
- // just a text control
- wxGridCellTextEditor::Create(parent, id, evtHandler);
-
-#if wxUSE_VALIDATORS
- Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
-#endif
- }
-}
-
-void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid* grid)
-{
- // first get the value
- wxGridTableBase *table = grid->GetTable();
- if ( table->CanGetValueAs(row, col, wxGRID_VALUE_NUMBER) )
- {
- m_valueOld = table->GetValueAsLong(row, col);
- }
- else
- {
- m_valueOld = 0;
- wxString sValue = table->GetValue(row, col);
- if (! sValue.ToLong(&m_valueOld) && ! sValue.empty())
- {
- wxFAIL_MSG( _T("this cell doesn't have numeric value") );
- return;
- }
- }
-
-#if wxUSE_SPINCTRL
- if ( HasRange() )
- {
- Spin()->SetValue((int)m_valueOld);
- Spin()->SetFocus();
- }
- else
-#endif
- {
- DoBeginEdit(GetString());
- }
-}
-
-bool wxGridCellNumberEditor::EndEdit(int row, int col,
- wxGrid* grid)
-{
- long value = 0;
- wxString text;
-
-#if wxUSE_SPINCTRL
- if ( HasRange() )
- {
- value = Spin()->GetValue();
- if ( value == m_valueOld )
- return false;
-
- text.Printf(wxT("%ld"), value);
- }
- else // using unconstrained input
-#endif // wxUSE_SPINCTRL
- {
- const wxString textOld(grid->GetCellValue(row, col));
- text = Text()->GetValue();
- if ( text.empty() )
- {
- if ( textOld.empty() )
- return false;
- }
- else // non-empty text now (maybe 0)
- {
- if ( !text.ToLong(&value) )
- return false;
-
- // if value == m_valueOld == 0 but old text was "" and new one is
- // "0" something still did change
- if ( value == m_valueOld && (value || !textOld.empty()) )
- return false;
- }
- }
-
- wxGridTableBase * const table = grid->GetTable();
- if ( table->CanSetValueAs(row, col, wxGRID_VALUE_NUMBER) )
- table->SetValueAsLong(row, col, value);
- else
- table->SetValue(row, col, text);
-
- return true;
-}
-
-void wxGridCellNumberEditor::Reset()
-{
-#if wxUSE_SPINCTRL
- if ( HasRange() )
- {
- Spin()->SetValue((int)m_valueOld);
- }
- else
-#endif
- {
- DoReset(GetString());
- }
-}
-
-bool wxGridCellNumberEditor::IsAcceptedKey(wxKeyEvent& event)
-{
- if ( wxGridCellEditor::IsAcceptedKey(event) )
- {
- int keycode = event.GetKeyCode();
- if ( (keycode < 128) &&
- (wxIsdigit(keycode) || keycode == '+' || keycode == '-'))
- {
- return true;
- }
- }
-
- return false;
-}
-
-void wxGridCellNumberEditor::StartingKey(wxKeyEvent& event)
-{
- int keycode = event.GetKeyCode();
- if ( !HasRange() )
- {
- if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-')
- {
- wxGridCellTextEditor::StartingKey(event);
-
- // skip Skip() below
- return;
- }
- }
-#if wxUSE_SPINCTRL
- else
- {
- if ( wxIsdigit(keycode) )
- {
- wxSpinCtrl* spin = (wxSpinCtrl*)m_control;
- spin->SetValue(keycode - '0');
- spin->SetSelection(1,1);
- return;
- }
- }
-#endif
-
- event.Skip();
-}
-
-void wxGridCellNumberEditor::SetParameters(const wxString& params)
-{
- if ( !params )
- {
- // reset to default
- m_min =
- m_max = -1;
- }
- else
- {
- long tmp;
- if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
- {
- m_min = (int)tmp;
-
- if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
- {
- m_max = (int)tmp;
-
- // skip the error message below
- return;
- }
- }
-
- wxLogDebug(_T("Invalid wxGridCellNumberEditor parameter string '%s' ignored"), params.c_str());
- }
-}
-
-// return the value in the spin control if it is there (the text control otherwise)
-wxString wxGridCellNumberEditor::GetValue() const
-{
- wxString s;
-
-#if wxUSE_SPINCTRL
- if ( HasRange() )
- {
- long value = Spin()->GetValue();
- s.Printf(wxT("%ld"), value);
- }
- else
-#endif
- {
- s = Text()->GetValue();
- }
-
- return s;
-}
-
-// ----------------------------------------------------------------------------
-// wxGridCellFloatEditor
-// ----------------------------------------------------------------------------
-
-wxGridCellFloatEditor::wxGridCellFloatEditor(int width, int precision)
-{
- m_width = width;
- m_precision = precision;
-}
-
-void wxGridCellFloatEditor::Create(wxWindow* parent,
- wxWindowID id,
- wxEvtHandler* evtHandler)
-{
- wxGridCellTextEditor::Create(parent, id, evtHandler);
-
-#if wxUSE_VALIDATORS
- Text()->SetValidator(wxTextValidator(wxFILTER_NUMERIC));
-#endif
-}
-
-void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid* grid)
-{
- // first get the value
- wxGridTableBase * const table = grid->GetTable();
- if ( table->CanGetValueAs(row, col, wxGRID_VALUE_FLOAT) )
- {
- m_valueOld = table->GetValueAsDouble(row, col);
- }
- else
- {
- m_valueOld = 0.0;
-
- const wxString value = table->GetValue(row, col);
- if ( !value.empty() )
- {
- if ( !value.ToDouble(&m_valueOld) )
- {
- wxFAIL_MSG( _T("this cell doesn't have float value") );
- return;
- }
- }
- }
-
- DoBeginEdit(GetString());
-}
-
-bool wxGridCellFloatEditor::EndEdit(int row, int col, wxGrid* grid)
-{
- const wxString text(Text()->GetValue()),
- textOld(grid->GetCellValue(row, col));
-
- double value;
- if ( !text.empty() )
- {
- if ( !text.ToDouble(&value) )
- return false;
- }
- else // new value is empty string
- {
- if ( textOld.empty() )
- return false; // nothing changed
-
- value = 0.;
- }
-
- // the test for empty strings ensures that we don't skip the value setting
- // when "" is replaced by "0" or vice versa as "" numeric value is also 0.
- if ( wxIsSameDouble(value, m_valueOld) && !text.empty() && !textOld.empty() )
- return false; // nothing changed
-
- wxGridTableBase * const table = grid->GetTable();
-
- if ( table->CanSetValueAs(row, col, wxGRID_VALUE_FLOAT) )
- table->SetValueAsDouble(row, col, value);
- else
- table->SetValue(row, col, text);
-
- return true;
-}
-
-void wxGridCellFloatEditor::Reset()
-{
- DoReset(GetString());
-}
-
-void wxGridCellFloatEditor::StartingKey(wxKeyEvent& event)
-{
- int keycode = event.GetKeyCode();
- char tmpbuf[2];
- tmpbuf[0] = (char) keycode;
- tmpbuf[1] = '\0';
- wxString strbuf(tmpbuf, *wxConvCurrent);
-
-#if wxUSE_INTL
- bool is_decimal_point = ( strbuf ==
- wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER) );
-#else
- bool is_decimal_point = ( strbuf == _T(".") );
-#endif
-
- if ( wxIsdigit(keycode) || keycode == '+' || keycode == '-'
- || is_decimal_point )
- {
- wxGridCellTextEditor::StartingKey(event);
-
- // skip Skip() below
- return;
- }
-
- event.Skip();
-}
-
-void wxGridCellFloatEditor::SetParameters(const wxString& params)
-{
- if ( !params )
- {
- // reset to default
- m_width =
- m_precision = -1;
- }
- else
- {
- long tmp;
- if ( params.BeforeFirst(_T(',')).ToLong(&tmp) )
- {
- m_width = (int)tmp;
-
- if ( params.AfterFirst(_T(',')).ToLong(&tmp) )
- {
- m_precision = (int)tmp;
-
- // skip the error message below
- return;
- }
- }
-
- wxLogDebug(_T("Invalid wxGridCellFloatEditor parameter string '%s' ignored"), params.c_str());
- }
-}
-
-wxString wxGridCellFloatEditor::GetString() const
-{
- wxString fmt;
- if ( m_precision == -1 && m_width != -1)
- {
- // default precision
- fmt.Printf(_T("%%%d.f"), m_width);
- }
- else if ( m_precision != -1 && m_width == -1)
- {
- // default width
- fmt.Printf(_T("%%.%df"), m_precision);
- }
- else if ( m_precision != -1 && m_width != -1 )
- {
- fmt.Printf(_T("%%%d.%df"), m_width, m_precision);
- }
- else
- {
- // default width/precision
- fmt = _T("%f");
- }
-
- return wxString::Format(fmt, m_valueOld);
-}
-
-bool wxGridCellFloatEditor::IsAcceptedKey(wxKeyEvent& event)
-{
- if ( wxGridCellEditor::IsAcceptedKey(event) )
- {
- const int keycode = event.GetKeyCode();
- if ( isascii(keycode) )
- {
- char tmpbuf[2];
- tmpbuf[0] = (char) keycode;
- tmpbuf[1] = '\0';
- wxString strbuf(tmpbuf, *wxConvCurrent);
-
-#if wxUSE_INTL
- const wxString decimalPoint =
- wxLocale::GetInfo(wxLOCALE_DECIMAL_POINT, wxLOCALE_CAT_NUMBER);
-#else
- const wxString decimalPoint(_T('.'));
-#endif
-
- // accept digits, 'e' as in '1e+6', also '-', '+', and '.'
- if ( wxIsdigit(keycode) ||
- tolower(keycode) == 'e' ||
- keycode == decimalPoint ||
- keycode == '+' ||
- keycode == '-' )
- {
- return true;
- }
- }
- }
-
- return false;
-}
-
-#endif // wxUSE_TEXTCTRL
-
-#if wxUSE_CHECKBOX
-
-// ----------------------------------------------------------------------------
-// wxGridCellBoolEditor
-// ----------------------------------------------------------------------------
-
-// the default values for GetValue()
-wxString wxGridCellBoolEditor::ms_stringValues[2] = { _T(""), _T("1") };
-
-void wxGridCellBoolEditor::Create(wxWindow* parent,
- wxWindowID id,
- wxEvtHandler* evtHandler)
-{
- m_control = new wxCheckBox(parent, id, wxEmptyString,
- wxDefaultPosition, wxDefaultSize,
- wxNO_BORDER);
-
- wxGridCellEditor::Create(parent, id, evtHandler);
-}
-
-void wxGridCellBoolEditor::SetSize(const wxRect& r)
-{
- bool resize = false;
- wxSize size = m_control->GetSize();
- wxCoord minSize = wxMin(r.width, r.height);
-
- // check if the checkbox is not too big/small for this cell
- wxSize sizeBest = m_control->GetBestSize();
- if ( !(size == sizeBest) )
- {
- // reset to default size if it had been made smaller
- size = sizeBest;
-
- resize = true;
- }
-
- if ( size.x >= minSize || size.y >= minSize )
- {
- // leave 1 pixel margin
- size.x = size.y = minSize - 2;
-
- resize = true;
- }
-
- if ( resize )
- {
- m_control->SetSize(size);
- }
-
- // position it in the centre of the rectangle (TODO: support alignment?)
-
-#if defined(__WXGTK__) || defined (__WXMOTIF__)
- // the checkbox without label still has some space to the right in wxGTK,
- // so shift it to the right
- size.x -= 8;
-#elif defined(__WXMSW__)
- // here too, but in other way
- size.x += 1;
- size.y -= 2;
-#endif
-
- int hAlign = wxALIGN_CENTRE;
- int vAlign = wxALIGN_CENTRE;
- if (GetCellAttr())
- GetCellAttr()->GetAlignment(& hAlign, & vAlign);
-
- int x = 0, y = 0;
- if (hAlign == wxALIGN_LEFT)
- {
- x = r.x + 2;
-
-#ifdef __WXMSW__
- x += 2;
-#endif
-
- y = r.y + r.height / 2 - size.y / 2;
- }
- else if (hAlign == wxALIGN_RIGHT)
- {
- x = r.x + r.width - size.x - 2;
- y = r.y + r.height / 2 - size.y / 2;
- }
- else if (hAlign == wxALIGN_CENTRE)
- {
- x = r.x + r.width / 2 - size.x / 2;
- y = r.y + r.height / 2 - size.y / 2;
- }
-
- m_control->Move(x, y);
-}
-
-void wxGridCellBoolEditor::Show(bool show, wxGridCellAttr *attr)
-{
- m_control->Show(show);
-
- if ( show )
- {
- wxColour colBg = attr ? attr->GetBackgroundColour() : *wxLIGHT_GREY;
- CBox()->SetBackgroundColour(colBg);
- }
-}
-
-void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid* grid)
-{
- wxASSERT_MSG(m_control,
- wxT("The wxGridCellEditor must be created first!"));
-
- if (grid->GetTable()->CanGetValueAs(row, col, wxGRID_VALUE_BOOL))
- {
- m_startValue = grid->GetTable()->GetValueAsBool(row, col);
- }
- else
- {
- wxString cellval( grid->GetTable()->GetValue(row, col) );
-
- if ( cellval == ms_stringValues[false] )
- m_startValue = false;
- else if ( cellval == ms_stringValues[true] )
- m_startValue = true;
- else
- {
- // do not try to be smart here and convert it to true or false
- // because we'll still overwrite it with something different and
- // this risks to be very surprising for the user code, let them
- // know about it
- wxFAIL_MSG( _T("invalid value for a cell with bool editor!") );
- }
- }
-
- CBox()->SetValue(m_startValue);
- CBox()->SetFocus();
-}
-
-bool wxGridCellBoolEditor::EndEdit(int row, int col,
- wxGrid* grid)
-{
- wxASSERT_MSG(m_control,
- wxT("The wxGridCellEditor must be created first!"));
-
- bool changed = false;
- bool value = CBox()->GetValue();
- if ( value != m_startValue )
- changed = true;
-
- if ( changed )
- {
- wxGridTableBase * const table = grid->GetTable();
- if ( table->CanGetValueAs(row, col, wxGRID_VALUE_BOOL) )
- table->SetValueAsBool(row, col, value);
- else
- table->SetValue(row, col, GetValue());
- }
-
- return changed;
-}
-
-void wxGridCellBoolEditor::Reset()
-{
- wxASSERT_MSG(m_control,
- wxT("The wxGridCellEditor must be created first!"));
-
- CBox()->SetValue(m_startValue);
-}
-
-void wxGridCellBoolEditor::StartingClick()
-{
- CBox()->SetValue(!CBox()->GetValue());
-}
-
-bool wxGridCellBoolEditor::IsAcceptedKey(wxKeyEvent& event)
-{
- if ( wxGridCellEditor::IsAcceptedKey(event) )
- {
- int keycode = event.GetKeyCode();
- switch ( keycode )
- {
- case WXK_SPACE:
- case '+':
- case '-':
- return true;
- }
- }
-
- return false;
-}
-
-void wxGridCellBoolEditor::StartingKey(wxKeyEvent& event)
-{
- int keycode = event.GetKeyCode();
- switch ( keycode )
- {
- case WXK_SPACE:
- CBox()->SetValue(!CBox()->GetValue());
- break;
-
- case '+':
- CBox()->SetValue(true);
- break;
-
- case '-':
- CBox()->SetValue(false);
- break;
- }
-}
-
-wxString wxGridCellBoolEditor::GetValue() const
-{
- return ms_stringValues[CBox()->GetValue()];
-}
-
-/* static */ void
-wxGridCellBoolEditor::UseStringValues(const wxString& valueTrue,
- const wxString& valueFalse)
-{
- ms_stringValues[false] = valueFalse;
- ms_stringValues[true] = valueTrue;
-}
-
-/* static */ bool
-wxGridCellBoolEditor::IsTrueValue(const wxString& value)
-{
- return value == ms_stringValues[true];
-}
-
-#endif // wxUSE_CHECKBOX
-
-#if wxUSE_COMBOBOX
-
-// ----------------------------------------------------------------------------
-// wxGridCellChoiceEditor
-// ----------------------------------------------------------------------------
-
-wxGridCellChoiceEditor::wxGridCellChoiceEditor(const wxArrayString& choices,
- bool allowOthers)
- : m_choices(choices),
- m_allowOthers(allowOthers) { }
-
-wxGridCellChoiceEditor::wxGridCellChoiceEditor(size_t count,
- const wxString choices[],
- bool allowOthers)
- : m_allowOthers(allowOthers)
-{
- if ( count )
- {
- m_choices.Alloc(count);
- for ( size_t n = 0; n < count; n++ )
- {
- m_choices.Add(choices[n]);
- }
- }
-}
-
-wxGridCellEditor *wxGridCellChoiceEditor::Clone() const
-{
- wxGridCellChoiceEditor *editor = new wxGridCellChoiceEditor;
- editor->m_allowOthers = m_allowOthers;
- editor->m_choices = m_choices;
-
- return editor;
-}
-
-void wxGridCellChoiceEditor::Create(wxWindow* parent,
- wxWindowID id,
- wxEvtHandler* evtHandler)
-{
- int style = wxTE_PROCESS_ENTER |
- wxTE_PROCESS_TAB |
- wxBORDER_NONE;
-
- if ( !m_allowOthers )
- style |= wxCB_READONLY;
- m_control = new wxComboBox(parent, id, wxEmptyString,
- wxDefaultPosition, wxDefaultSize,
- m_choices,
- style);
-
- wxGridCellEditor::Create(parent, id, evtHandler);
-}
-
-void wxGridCellChoiceEditor::PaintBackground(const wxRect& rectCell,
- wxGridCellAttr * attr)
-{
- // as we fill the entire client area, don't do anything here to minimize
- // flicker
-
- // TODO: It doesn't actually fill the client area since the height of a
- // combo always defaults to the standard. Until someone has time to
- // figure out the right rectangle to paint, just do it the normal way.
- wxGridCellEditor::PaintBackground(rectCell, attr);
-}
-
-void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid* grid)
-{
- wxASSERT_MSG(m_control,
- wxT("The wxGridCellEditor must be created first!"));
-
- wxGridCellEditorEvtHandler* evtHandler = NULL;
- if (m_control)
- evtHandler = wxDynamicCast(m_control->GetEventHandler(), wxGridCellEditorEvtHandler);
-
- // Don't immediately end if we get a kill focus event within BeginEdit
- if (evtHandler)
- evtHandler->SetInSetFocus(true);
-
- m_startValue = grid->GetTable()->GetValue(row, col);
-
- Reset(); // this updates combo box to correspond to m_startValue
-
- Combo()->SetFocus();
-
- if (evtHandler)
- {
- // When dropping down the menu, a kill focus event
- // happens after this point, so we can't reset the flag yet.
-#if !defined(__WXGTK20__)
- evtHandler->SetInSetFocus(false);
-#endif
- }
-}
-
-bool wxGridCellChoiceEditor::EndEdit(int row, int col,
- wxGrid* grid)
-{
- wxString value = Combo()->GetValue();
- if ( value == m_startValue )
- return false;
-
- grid->GetTable()->SetValue(row, col, value);
-
- return true;
-}
-
-void wxGridCellChoiceEditor::Reset()
-{
- if (m_allowOthers)
- {
- Combo()->SetValue(m_startValue);
- Combo()->SetInsertionPointEnd();
- }
- else // the combobox is read-only
- {
- // find the right position, or default to the first if not found
- int pos = Combo()->FindString(m_startValue);
- if (pos == wxNOT_FOUND)
- pos = 0;
- Combo()->SetSelection(pos);
- }
-}
-
-void wxGridCellChoiceEditor::SetParameters(const wxString& params)
-{
- if ( !params )
- {
- // what can we do?
- return;
- }
projects / wxWidgets.git / blobdiff