diff options
Diffstat (limited to 'wx+/grid.cpp')
| -rw-r--r-- | wx+/grid.cpp | 2052 |
1 files changed, 2052 insertions, 0 deletions
diff --git a/wx+/grid.cpp b/wx+/grid.cpp new file mode 100644 index 00000000..bfb08eb1 --- /dev/null +++ b/wx+/grid.cpp @@ -0,0 +1,2052 @@ +// ************************************************************************** +// * This file is part of the FreeFileSync project. It is distributed under * +// * GNU General Public License: http://www.gnu.org/licenses/gpl.html * +// * Copyright (C) ZenJu (zhnmju123 AT gmx DOT de) - All Rights Reserved * +// ************************************************************************** + +#include "grid.h" +#include <cassert> +#include <ctime> +#include <set> +#include <wx/dcbuffer.h> //for macro: wxALWAYS_NATIVE_DOUBLE_BUFFER +#include <wx/settings.h> +#include <wx/listbox.h> +#include <wx/tooltip.h> +#include <wx/timer.h> +#include <wx/utils.h> +#include <zen/string_tools.h> +#include <zen/scope_guard.h> +#include "format_unit.h" + +#ifdef FFS_LINUX +#include <gtk/gtk.h> +#endif + + +using namespace zen; + +wxColor zen::getColorSelectionGradientFrom() { return wxColor(137, 172, 255); } //blue: H:158 S:255 V:196 +wxColor zen::getColorSelectionGradientTo () { return wxColor(225, 234, 255); } // H:158 S:255 V:240 + +void zen::clearArea(wxDC& dc, const wxRect& rect, const wxColor& col) +{ + wxDCPenChanger dummy (dc, col); + wxDCBrushChanger dummy2(dc, col); + dc.DrawRectangle(rect); +} + +namespace +{ +//------------ Grid Constants ------------------------------------------------------------------------------------ +const double MOUSE_DRAG_ACCELERATION = 1.5; //unit: [rows / (pixel * sec)] -> same value as Explorer! +const int DEFAULT_ROW_HEIGHT = 20; +const int DEFAULT_COL_LABEL_HEIGHT = 25; +const int COLUMN_BORDER_LEFT = 4; //for left-aligned text +const int COLUMN_LABEL_BORDER = COLUMN_BORDER_LEFT; +const int COLUMN_MOVE_DELAY = 5; //unit: [pixel] (from Explorer) +const int COLUMN_MIN_WIDTH = 40; //only honored when resizing manually! +const int ROW_LABEL_BORDER = 3; +const int COLUMN_RESIZE_TOLERANCE = 6; //unit [pixel] + +const wxColor COLOR_SELECTION_GRADIENT_NO_FOCUS_FROM = wxColour(192, 192, 192); //light grey wxSystemSettings::GetColour(wxSYS_COLOUR_BTNSHADOW); +const wxColor COLOR_SELECTION_GRADIENT_NO_FOCUS_TO = wxColour(228, 228, 228); + +const wxColor COLOR_LABEL_GRADIENT_FROM = wxColour(200, 200, 200); //light grey +const wxColor COLOR_LABEL_GRADIENT_TO = *wxWHITE; + +const wxColor COLOR_LABEL_GRADIENT_FROM_FOCUS = getColorSelectionGradientFrom(); +const wxColor COLOR_LABEL_GRADIENT_TO_FOCUS = COLOR_LABEL_GRADIENT_TO; + +//wxColor getColorRowLabel () { return wxPanel::GetClassDefaultAttributes ().colBg; } // +wxColor getColorMainWinBackground() { return wxListBox::GetClassDefaultAttributes().colBg; } //cannot be initialized statically on wxGTK! + +const wxColor colorGridLine = wxColour(192, 192, 192); //light grey +//---------------------------------------------------------------------------------------------------------------- + + +//a fix for a poor wxWidgets implementation (wxAutoBufferedPaintDC skips one pixel on left side when RTL layout is active) +#ifndef wxALWAYS_NATIVE_DOUBLE_BUFFER +#error we need this one! +#endif + +#if wxALWAYS_NATIVE_DOUBLE_BUFFER +struct BufferedPaintDC : public wxPaintDC { BufferedPaintDC(wxWindow& wnd, std::unique_ptr<wxBitmap>& buffer) : wxPaintDC(&wnd) {} }; + +#else +class BufferedPaintDC : public wxMemoryDC +{ +public: + BufferedPaintDC(wxWindow& wnd, std::unique_ptr<wxBitmap>& buffer) : buffer_(buffer), paintDc(&wnd) + { + const wxSize clientSize = wnd.GetClientSize(); + if (!buffer_ || clientSize != wxSize(buffer->GetWidth(), buffer->GetHeight())) + buffer.reset(new wxBitmap(clientSize.GetWidth(), clientSize.GetHeight())); + + SelectObject(*buffer); + + if (paintDc.IsOk()) + SetLayoutDirection(paintDc.GetLayoutDirection()); + } + + ~BufferedPaintDC() + { + paintDc.SetLayoutDirection(wxLayout_LeftToRight); //workaround bug in wxDC::Blit() + SetLayoutDirection(wxLayout_LeftToRight); // + + const wxPoint origin = GetDeviceOrigin(); + paintDc.Blit(0, 0, buffer_->GetWidth(), buffer_->GetHeight(), this, -origin.x, -origin.y); + } + +private: + std::unique_ptr<wxBitmap>& buffer_; + wxPaintDC paintDc; +}; +#endif + + +//another fix for yet another poor wxWidgets implementation (wxDCClipper does *not* stack) +hash_map<wxDC*, wxRect> clippingAreas; + +class DcClipper +{ +public: + DcClipper(wxDC& dc, const wxRect& r) : dc_(dc) + { + auto iter = clippingAreas.find(&dc); + if (iter != clippingAreas.end()) + { + oldRect.reset(new wxRect(iter->second)); + + wxRect tmp = r; + tmp.Intersect(*oldRect); //better safe than sorry + dc_.SetClippingRegion(tmp); // + iter->second = tmp; + } + else + { + dc_.SetClippingRegion(r); + clippingAreas.insert(std::make_pair(&dc_, r)); + } + } + + ~DcClipper() + { + dc_.DestroyClippingRegion(); + if (oldRect.get() != NULL) + { + dc_.SetClippingRegion(*oldRect); + clippingAreas[&dc_] = *oldRect; + } + else + clippingAreas.erase(&dc_); + } + +private: + std::unique_ptr<wxRect> oldRect; + wxDC& dc_; +}; +} + +//---------------------------------------------------------------------------------------------------------------- +const wxEventType zen::EVENT_GRID_MOUSE_LEFT_DOUBLE = wxNewEventType(); +const wxEventType zen::EVENT_GRID_COL_LABEL_MOUSE_LEFT = wxNewEventType(); +const wxEventType zen::EVENT_GRID_COL_LABEL_MOUSE_RIGHT = wxNewEventType(); +const wxEventType zen::EVENT_GRID_COL_RESIZE = wxNewEventType(); +const wxEventType zen::EVENT_GRID_MOUSE_LEFT_DOWN = wxNewEventType(); +const wxEventType zen::EVENT_GRID_MOUSE_LEFT_UP = wxNewEventType(); +const wxEventType zen::EVENT_GRID_MOUSE_RIGHT_DOWN = wxNewEventType(); +const wxEventType zen::EVENT_GRID_MOUSE_RIGHT_UP = wxNewEventType(); +const wxEventType zen::EVENT_GRID_SELECT_RANGE = wxNewEventType(); +//---------------------------------------------------------------------------------------------------------------- + +void GridData::renderRowBackgound(wxDC& dc, const wxRect& rect, int row, bool enabled, bool selected, bool hasFocus) +{ + drawCellBackground(dc, rect, enabled, selected, hasFocus, getColorMainWinBackground()); +} + + +void GridData::renderCell(Grid& grid, wxDC& dc, const wxRect& rect, int row, ColumnType colType) +{ + wxRect rectTmp = drawCellBorder(dc, rect); + + rectTmp.x += COLUMN_BORDER_LEFT; + rectTmp.width -= COLUMN_BORDER_LEFT; + drawCellText(dc, rectTmp, getValue(row, colType), grid.IsEnabled()); +} + + +size_t GridData::getBestSize(wxDC& dc, int row, ColumnType colType) +{ + return dc.GetTextExtent(getValue(row, colType)).GetWidth() + 2 * COLUMN_BORDER_LEFT; //some border on left and right side +} + + +wxRect GridData::drawCellBorder(wxDC& dc, const wxRect& rect) //returns remaining rectangle +{ + wxDCPenChanger dummy2(dc, wxPen(colorGridLine, 1, wxSOLID)); + dc.DrawLine(rect.GetBottomLeft(), rect.GetBottomRight()); + dc.DrawLine(rect.GetBottomRight(), rect.GetTopRight() + wxPoint(0, -1)); + + return wxRect(rect.GetTopLeft(), wxSize(rect.width - 1, rect.height - 1)); +} + + +void GridData::drawCellBackground(wxDC& dc, const wxRect& rect, bool enabled, bool selected, bool hasFocus, const wxColor& backgroundColor) +{ + if (enabled) + { + if (selected) + { + if (hasFocus) + dc.GradientFillLinear(rect, getColorSelectionGradientFrom(), getColorSelectionGradientTo(), wxEAST); + else + dc.GradientFillLinear(rect, COLOR_SELECTION_GRADIENT_NO_FOCUS_FROM, COLOR_SELECTION_GRADIENT_NO_FOCUS_TO, wxEAST); + } + else + clearArea(dc, rect, backgroundColor); + } + else + clearArea(dc, rect, wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); +} + + +void GridData::drawCellText(wxDC& dc, const wxRect& rect, const wxString& text, bool enabled, int alignment) +{ + wxDCTextColourChanger dummy(dc, enabled ? dc.GetTextForeground() : wxSystemSettings::GetColour(wxSYS_COLOUR_GRAYTEXT)); + + DcClipper clip(dc, rect); //wxDC::DrawLabel doesn't care about width, WTF? + dc.DrawLabel(text, rect, alignment); +} + + +void GridData::renderColumnLabel(Grid& grid, wxDC& dc, const wxRect& rect, ColumnType colType, bool highlighted) +{ + wxRect rectTmp = drawColumnLabelBorder(dc, rect); + drawColumnLabelBackground(dc, rectTmp, highlighted); + + rectTmp.x += COLUMN_BORDER_LEFT; + rectTmp.width -= COLUMN_BORDER_LEFT; + drawColumnLabelText(dc, rectTmp, getColumnLabel(colType)); +} + + +wxRect GridData::drawColumnLabelBorder(wxDC& dc, const wxRect& rect) //returns remaining rectangle +{ + //draw white line + { + wxDCPenChanger dummy(dc, *wxWHITE_PEN); + dc.DrawLine(rect.GetTopLeft(), rect.GetBottomLeft()); + } + + //draw border (with gradient) + { + wxDCPenChanger dummy(dc, wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID)); + dc.GradientFillLinear(wxRect(rect.GetTopRight(), rect.GetBottomRight()), dc.GetPen().GetColour(), COLOR_LABEL_GRADIENT_TO, wxNORTH); + dc.DrawLine(rect.GetBottomLeft(), rect.GetBottomRight() + wxPoint(1, 0)); + } + + return wxRect(rect.x + 1, rect.y, rect.width - 2, rect.height - 1); //we really don't like wxRect::Deflate, do we? +} + + +void GridData::drawColumnLabelBackground(wxDC& dc, const wxRect& rect, bool highlighted) +{ + if (highlighted) + dc.GradientFillLinear(rect, COLOR_LABEL_GRADIENT_FROM_FOCUS, COLOR_LABEL_GRADIENT_TO_FOCUS, wxNORTH); + else //regular background gradient + dc.GradientFillLinear(rect, COLOR_LABEL_GRADIENT_FROM, COLOR_LABEL_GRADIENT_TO, wxNORTH); //clear overlapping cells +} + + +void GridData::drawColumnLabelText(wxDC& dc, const wxRect& rect, const wxString& text) +{ + DcClipper clip(dc, rect); //wxDC::DrawLabel doesn't care about witdh, WTF? + dc.DrawLabel(text, rect, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL); +} + +//---------------------------------------------------------------------------------------------------------------- + +/* + SubWindow + /|\ + | + ----------------------------------- + | | | | +CornerWin RowLabelWin ColLabelWin MainWin + +*/ + +class Grid::SubWindow : public wxWindow +{ +public: + SubWindow(Grid& parent) : + wxWindow(&parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS | wxBORDER_NONE, wxPanelNameStr), + parent_(parent) + { + Connect(wxEVT_PAINT, wxPaintEventHandler(SubWindow::onPaintEvent), NULL, this); + Connect(wxEVT_SIZE, wxEventHandler(SubWindow::onSizeEvent), NULL, this); + //http://wiki.wxwidgets.org/Flicker-Free_Drawing + Connect(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(SubWindow::onEraseBackGround), NULL, this); + + //SetDoubleBuffered(true); slow as hell! + +#if wxCHECK_VERSION(2, 9, 1) + SetBackgroundStyle(wxBG_STYLE_PAINT); +#else + SetBackgroundStyle(wxBG_STYLE_CUSTOM); +#endif + + Connect(wxEVT_SET_FOCUS, wxFocusEventHandler(SubWindow::onFocus), NULL, this); + Connect(wxEVT_KILL_FOCUS, wxFocusEventHandler(SubWindow::onFocus), NULL, this); + + Connect(wxEVT_LEFT_DOWN, wxMouseEventHandler(SubWindow::onMouseLeftDown ), NULL, this); + Connect(wxEVT_LEFT_UP, wxMouseEventHandler(SubWindow::onMouseLeftUp ), NULL, this); + Connect(wxEVT_LEFT_DCLICK, wxMouseEventHandler(SubWindow::onMouseLeftDouble), NULL, this); + Connect(wxEVT_RIGHT_DOWN, wxMouseEventHandler(SubWindow::onMouseRightDown ), NULL, this); + Connect(wxEVT_RIGHT_UP, wxMouseEventHandler(SubWindow::onMouseRightUp ), NULL, this); + Connect(wxEVT_MOTION, wxMouseEventHandler(SubWindow::onMouseMovement ), NULL, this); + Connect(wxEVT_LEAVE_WINDOW, wxMouseEventHandler(SubWindow::onLeaveWindow ), NULL, this); + Connect(wxEVT_MOUSE_CAPTURE_LOST, wxMouseCaptureLostEventHandler(SubWindow::onMouseCaptureLost), NULL, this); + + Connect(wxEVT_CHAR, wxKeyEventHandler(SubWindow::onChar ), NULL, this); + Connect(wxEVT_KEY_UP, wxKeyEventHandler(SubWindow::onKeyUp ), NULL, this); + Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(SubWindow::onKeyDown), NULL, this); + } + + Grid& refParent() { return parent_; } + const Grid& refParent() const { return parent_; } + + template <class T> + bool sendEventNow(T& event) //return "true" if a suitable event handler function was found and executed, and the function did not call wxEvent::Skip. + { + if (wxEvtHandler* evtHandler = parent_.GetEventHandler()) + return evtHandler->ProcessEvent(event); + return false; + } + +protected: + void setToolTip(const wxString& text) //proper fix for wxWindow + { + wxToolTip* tt = GetToolTip(); + + const wxString oldText = tt ? tt->GetTip() : wxString(); + if (text != oldText) + { + if (text.IsEmpty()) + SetToolTip(NULL); //wxGTK doesn't allow wxToolTip with empty text! + else + { + //wxWidgets bug: tooltip multiline property is defined by first tooltip text containing newlines or not (same is true for maximum width) + if (!tt) + SetToolTip(new wxToolTip(wxT("a b\n\ + a b"))); //ugly, but is working (on Windows) + tt = GetToolTip(); //should be bound by now + if (tt) + tt->SetTip(text); + } + } + } + +private: + virtual void render(wxDC& dc, const wxRect& rect) = 0; + + virtual void onFocus(wxFocusEvent& event) { event.Skip(); } + + virtual void onMouseLeftDown (wxMouseEvent& event) { event.Skip(); } + virtual void onMouseLeftUp (wxMouseEvent& event) { event.Skip(); } + virtual void onMouseLeftDouble(wxMouseEvent& event) { event.Skip(); } + virtual void onMouseRightDown (wxMouseEvent& event) { event.Skip(); } + virtual void onMouseRightUp (wxMouseEvent& event) { event.Skip(); } + virtual void onMouseMovement (wxMouseEvent& event) { event.Skip(); } + virtual void onLeaveWindow (wxMouseEvent& event) { event.Skip(); } + virtual void onMouseCaptureLost(wxMouseCaptureLostEvent& event) { event.Skip(); } + + virtual void onChar (wxKeyEvent& event) { event.Skip(); } + virtual void onKeyUp (wxKeyEvent& event) { event.Skip(); } + virtual void onKeyDown(wxKeyEvent& event) { event.Skip(); } + + void onPaintEvent(wxPaintEvent& evt) + { + //wxAutoBufferedPaintDC dc(this); -> this one happily fucks up for RTL layout by not drawing the first column (x = 0)! + BufferedPaintDC dc(*this, buffer); + + assert(GetSize() == GetClientSize()); + + const wxRegion& updateReg = GetUpdateRegion(); + for (wxRegionIterator iter = updateReg; iter; ++iter) + render(dc, iter.GetRect()); + } + + void onSizeEvent(wxEvent& evt) + { + Refresh(); + evt.Skip(); + } + + void onEraseBackGround(wxEraseEvent& evt) {} + + Grid& parent_; + std::unique_ptr<wxBitmap> buffer; +}; + +//---------------------------------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------------------------------- + +class Grid::CornerWin : public SubWindow +{ +public: + CornerWin(Grid& parent) : SubWindow(parent) {} + +private: + virtual bool AcceptsFocus() const { return false; } + + virtual void render(wxDC& dc, const wxRect& rect) + { + const wxRect& clientRect = GetClientRect(); + + dc.GradientFillLinear(clientRect, COLOR_LABEL_GRADIENT_FROM, COLOR_LABEL_GRADIENT_TO, wxNORTH); + + dc.SetPen(wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID)); + + { + wxDCPenChanger dummy(dc, COLOR_LABEL_GRADIENT_TO); + dc.DrawLine(clientRect.GetTopLeft(), clientRect.GetTopRight()); + } + + dc.GradientFillLinear(wxRect(clientRect.GetBottomLeft (), clientRect.GetTopLeft ()), dc.GetPen().GetColour(), COLOR_LABEL_GRADIENT_TO, wxNORTH); + dc.GradientFillLinear(wxRect(clientRect.GetBottomRight(), clientRect.GetTopRight()), dc.GetPen().GetColour(), COLOR_LABEL_GRADIENT_TO, wxNORTH); + + dc.DrawLine(clientRect.GetBottomLeft(), clientRect.GetBottomRight()); + + wxRect rectShrinked = clientRect; + rectShrinked.Deflate(1); + dc.SetPen(*wxWHITE_PEN); + + //dc.DrawLine(clientRect.GetTopLeft(), clientRect.GetTopRight() + wxPoint(1, 0)); + dc.DrawLine(rectShrinked.GetTopLeft(), rectShrinked.GetBottomLeft() + wxPoint(0, 1)); + } +}; + +//---------------------------------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------------------------------- + +class Grid::RowLabelWin : public SubWindow +{ +public: + RowLabelWin(Grid& parent) : + SubWindow(parent), + rowHeight(DEFAULT_ROW_HEIGHT) {} + + int getBestWidth(int rowFrom, int rowTo) + { + wxClientDC dc(this); + + int bestWidth = 0; + for (int i = rowFrom; i <= rowTo; ++i) + bestWidth = std::max(bestWidth, dc.GetTextExtent(formatRow(i)).GetWidth() + 2 * ROW_LABEL_BORDER); + return bestWidth; + } + + int getLogicalHeight() const { return refParent().getRowCount() * rowHeight; } + + int getRowAtPos(int posY) const //returns < 0 if row not found + { + if (posY >= 0 && rowHeight > 0) + { + const int row = posY / rowHeight; + if (row < static_cast<int>(refParent().getRowCount())) + return row; + } + return -1; + } + + int getRowHeight() const { return rowHeight; } + void setRowHeight(int height) { rowHeight = height; } + + wxRect getRowLabelArea(int row) const //returns empty rect if row not found + { + return wxRect(wxPoint(0, rowHeight * row), + wxSize(GetClientSize().GetWidth(), rowHeight)); + } + + std::pair<int, int> getRowsOnClient(const wxRect& clientRect) const //returns range [begin, end) + { + const int yFrom = refParent().CalcUnscrolledPosition(clientRect.GetTopLeft ()).y; + const int yTo = refParent().CalcUnscrolledPosition(clientRect.GetBottomRight()).y; + + const int rowBegin = std::max(yFrom / rowHeight, 0); + const int rowEnd = std::min((yTo / rowHeight) + 1, static_cast<int>(refParent().getRowCount())); + + return std::make_pair(rowBegin, rowEnd); + } + +private: + static wxString formatRow(int row) { return toStringSep(row + 1); } //convert number to std::wstring including thousands separator + + virtual bool AcceptsFocus() const { return false; } + + virtual void render(wxDC& dc, const wxRect& rect) + { + if (IsEnabled()) + clearArea(dc, rect, getColorMainWinBackground()); + else + clearArea(dc, rect, wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); + + wxFont labelFont = GetFont(); + labelFont.SetWeight(wxFONTWEIGHT_BOLD); + dc.SetFont(labelFont); + dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT)); + + const std::pair<int, int> rowRange = getRowsOnClient(rect); //returns range [begin, end) + + for (int row = rowRange.first; row < rowRange.second; ++row) + { + wxRect singleLabelArea = getRowLabelArea(row); + if (singleLabelArea.GetHeight() > 0) + { + singleLabelArea.y = refParent().CalcScrolledPosition(singleLabelArea.GetTopLeft()).y; + drawRowLabel(dc, singleLabelArea, row); + } + } + } + + void drawRowLabel(wxDC& dc, const wxRect& rect, int row) + { + //clearArea(dc, rect, getColorRowLabel()); + dc.GradientFillLinear(rect, COLOR_LABEL_GRADIENT_FROM, COLOR_LABEL_GRADIENT_TO, wxWEST); //clear overlapping cells + + //label text + wxRect textRect = rect; + textRect.Deflate(1); + { + DcClipper clip(dc, textRect); //wxDC::DrawLabel doesn't care about with, WTF? + dc.DrawLabel(formatRow(row), textRect, wxALIGN_CENTRE); + } + + //border lines + { + wxDCPenChanger dummy(dc, *wxWHITE_PEN); + dc.DrawLine(rect.GetTopLeft(), rect.GetTopRight()); + } + { + wxDCPenChanger dummy(dc, wxPen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW), 1, wxSOLID)); + dc.DrawLine(rect.GetTopLeft(), rect.GetBottomLeft()); + dc.DrawLine(rect.GetBottomLeft(), rect.GetBottomRight()); + dc.DrawLine(rect.GetBottomRight(), rect.GetTopRight() + wxPoint(0, -1)); + } + } + + virtual void onMouseLeftDown(wxMouseEvent& event) { refParent().redirectRowLabelEvent(event); } + virtual void onMouseMovement(wxMouseEvent& event) { refParent().redirectRowLabelEvent(event); } + virtual void onMouseLeftUp (wxMouseEvent& event) { refParent().redirectRowLabelEvent(event); } + + int rowHeight; +}; + + +namespace +{ +class ColumnResizing +{ +public: + ColumnResizing(wxWindow& wnd, int col, size_t compPos, int startWidth, int clientPosX) : + wnd_(wnd), + col_(col), + compPos_(compPos), + startWidth_(startWidth), + clientPosX_(clientPosX) { wnd_.CaptureMouse(); } + ~ColumnResizing() { if (wnd_.HasCapture()) wnd_.ReleaseMouse(); } + + int getColumn () const { return col_; } + size_t getComponentPos() const { return compPos_; } + int getStartWidth () const { return startWidth_; } + int getStartPosX () const { return clientPosX_; } + +private: + wxWindow& wnd_; + const int col_; + const size_t compPos_; + const int startWidth_; + const int clientPosX_; +}; + + +class ColumnMove +{ +public: + ColumnMove(wxWindow& wnd, int colFrom, size_t compPos, int clientPosX) : + wnd_(wnd), + colFrom_(colFrom), + compPos_(compPos), + colTo_(colFrom), + clientPosX_(clientPosX), + singleClick_(true) { wnd_.CaptureMouse(); } + ~ColumnMove() { if (wnd_.HasCapture()) wnd_.ReleaseMouse(); } + + int getColumnFrom() const { return colFrom_; } + int& refColumnTo() { return colTo_; } + size_t getComponentPos() const { return compPos_; } + int getStartPosX () const { return clientPosX_; } + + bool isRealMove() const { return !singleClick_; } + bool setRealMove() { return singleClick_ = false; } + +private: + wxWindow& wnd_; + const int colFrom_; + const size_t compPos_; + int colTo_; + const int clientPosX_; + bool singleClick_; +}; +} + +//---------------------------------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------------------------------- + +class Grid::ColLabelWin : public SubWindow +{ +public: + ColLabelWin(Grid& parent) : SubWindow(parent), highlight(-1, 0) {} + +private: + virtual bool AcceptsFocus() const { return false; } + + virtual void render(wxDC& dc, const wxRect& rect) + { + if (IsEnabled()) + clearArea(dc, rect, getColorMainWinBackground()); + else + clearArea(dc, rect, wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); + + wxFont labelFont = GetFont(); + labelFont.SetWeight(wxFONTWEIGHT_BOLD); + dc.SetFont(labelFont); + dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT)); + + const int colLabelHeight = refParent().colLabelHeight; + + wxPoint labelAreaTL(refParent().CalcScrolledPosition(wxPoint(0, 0)).x, 0); //client coordinates + + std::vector<std::vector<VisibleColumn>> compAbsWidths = refParent().getAbsoluteWidths(); //resolve negative/stretched widths + for (auto iterComp = compAbsWidths.begin(); iterComp != compAbsWidths.end(); ++iterComp) + for (auto iterCol = iterComp->begin(); iterCol != iterComp->end(); ++iterCol) + { + const size_t col = iterCol - iterComp->begin(); + const int width = iterCol->width_; //don't use unsigned for calculations! + + if (labelAreaTL.x > rect.GetRight()) + return; //done + if (labelAreaTL.x + width > rect.x) + drawColumnLabel(dc, wxRect(labelAreaTL, wxSize(width, colLabelHeight)), col, iterCol->type_, iterComp - compAbsWidths.begin()); + labelAreaTL.x += width; + } + } + + void drawColumnLabel(wxDC& dc, const wxRect& rect, int col, ColumnType colType, size_t compPos) + { + if (auto dataView = refParent().getDataProvider(compPos)) + { + const bool isHighlighted = activeResizing ? col == activeResizing->getColumn () && compPos == activeResizing->getComponentPos() : //highlight column on mouse-over + activeMove ? col == activeMove ->getColumnFrom() && compPos == activeMove ->getComponentPos() : + /**/ col == highlight.first && compPos == highlight.second; + + DcClipper clip(dc, rect); + dataView->renderColumnLabel(refParent(), dc, rect, colType, isHighlighted); + + //draw move target location + if (refParent().columnMoveAllowed(compPos)) + if (activeMove && activeMove->isRealMove() && activeMove->getComponentPos() == compPos) + { + if (col + 1 == activeMove->refColumnTo()) //handle pos 1, 2, .. up to "at end" position + dc.GradientFillLinear(wxRect(rect.GetTopRight(), rect.GetBottomRight() + wxPoint(-2, 0)), *wxBLUE, COLOR_LABEL_GRADIENT_TO, wxNORTH); + else if (col == activeMove->refColumnTo() && col == 0) //pos 0 + dc.GradientFillLinear(wxRect(rect.GetTopLeft(), rect.GetBottomLeft() + wxPoint(2, 0)), *wxBLUE, COLOR_LABEL_GRADIENT_TO, wxNORTH); + } + } + } + + virtual void onMouseLeftDown(wxMouseEvent& event) + { + if (FindFocus() != &refParent().getMainWin()) + refParent().getMainWin().SetFocus(); + + activeResizing.reset(); + activeMove.reset(); + + if (Opt<ColAction> action = refParent().clientPosToColumnAction(event.GetPosition())) + { + if (action->wantResize) + { + if (event.LeftDClick()) //auto-size visible range on double-click + { + const int bestWidth = refParent().getBestColumnSize(action->col, action->compPos); //return -1 on error + if (bestWidth >= 0) + refParent().setColWidth(action->col, action->compPos, std::max(COLUMN_MIN_WIDTH, bestWidth)); + } + else + { + if (Opt<size_t> colWidth = refParent().getAbsoluteWidth(action->col, action->compPos)) + activeResizing.reset(new ColumnResizing(*this, action->col, action->compPos, *colWidth, event.GetPosition().x)); + } + } + else //a move or single click + activeMove.reset(new ColumnMove(*this, action->col, action->compPos, event.GetPosition().x)); + } + event.Skip(); + } + + virtual void onMouseLeftUp(wxMouseEvent& event) + { + activeResizing.reset(); //nothing else to do, actual work done by onMouseMovement() + + if (activeMove) + { + const size_t compPos = activeMove->getComponentPos(); + if (activeMove->isRealMove()) + { + if (refParent().columnMoveAllowed(compPos)) + { + const int colFrom = activeMove->getColumnFrom(); + int colTo = activeMove->refColumnTo(); + + if (colTo > colFrom) //simulate "colFrom" deletion + --colTo; + + refParent().moveColumn(colFrom, colTo, compPos); + } + } + else //notify single label click + { + const Opt<ColumnType> colType = refParent().colToType(activeMove->getColumnFrom(), compPos); + if (colType) + { + GridClickEvent clickEvent(EVENT_GRID_COL_LABEL_MOUSE_LEFT, event, -1, *colType, compPos); + sendEventNow(clickEvent); + } + } + activeMove.reset(); + } + + refParent().updateWindowSizes(); //looks strange if done during onMouseMovement() + refParent().Refresh(); + event.Skip(); + } + + virtual void onMouseCaptureLost(wxMouseCaptureLostEvent& event) + { + activeResizing.reset(); + activeMove.reset(); + Refresh(); + //event.Skip(); -> we DID handle it! + } + + virtual void onMouseLeftDouble(wxMouseEvent& event) + { + const Opt<ColAction> action = refParent().clientPosToColumnAction(event.GetPosition()); + if (action && action->wantResize) + { + //auto-size visible range on double-click + const int bestWidth = refParent().getBestColumnSize(action->col, action->compPos); //return -1 on error + if (bestWidth >= 0) + { + const size_t newWidth = std::max(COLUMN_MIN_WIDTH, bestWidth); + refParent().setColWidth(action->col, action->compPos, newWidth); + + const Opt<ColumnType> colType = refParent().colToType(action->col, action->compPos); + if (colType) + { + //notify column resize + GridColumnResizeEvent sizeEvent(newWidth, *colType, action->compPos); + sendEventNow(sizeEvent); + } + } + } + event.Skip(); + } + + virtual void onMouseMovement(wxMouseEvent& event) + { + if (activeResizing) + { + const int col = activeResizing->getColumn(); + const size_t compPos = activeResizing->getComponentPos(); + + if (Opt<size_t> colWidth = refParent().getAbsoluteWidth(col, compPos)) + { + const int newWidth = std::max(COLUMN_MIN_WIDTH, activeResizing->getStartWidth() + event.GetPosition().x - activeResizing->getStartPosX()); + if (newWidth != static_cast<int>(*colWidth)) + { + refParent().setColWidth(col, compPos, newWidth); + + const Opt<ColumnType> colType = refParent().colToType(col, compPos); + if (colType) + { + //notify column resize + GridColumnResizeEvent sizeEvent(newWidth, *colType, compPos); + sendEventNow(sizeEvent); + } + + refParent().Refresh(); + } + } + } + else if (activeMove) + { + const int clientPosX = event.GetPosition().x; + if (std::abs(clientPosX - activeMove->getStartPosX()) > COLUMN_MOVE_DELAY) //real move (not a single click) + { + activeMove->setRealMove(); + + const int col = refParent().clientPosToMoveTargetColumn(event.GetPosition(), activeMove->getComponentPos()); + if (col >= 0) + activeMove->refColumnTo() = col; + } + } + else + { + const Opt<ColAction> action = refParent().clientPosToColumnAction(event.GetPosition()); + if (action) + { + highlight.first = action->col; + highlight.second = action->compPos; + + if (action->wantResize) + SetCursor(wxCURSOR_SIZEWE); //set window-local only! :) + else + SetCursor(*wxSTANDARD_CURSOR); + } + else + { + highlight.first = -1; + SetCursor(*wxSTANDARD_CURSOR); + } + } + + //change tooltip + const wxString toolTip = [&]() -> wxString + { + const wxPoint absPos = refParent().CalcUnscrolledPosition(event.GetPosition()); + + const auto colInfo = refParent().getColumnAtPos(absPos.x); //returns (column type, compPos), column < 0 if not found + if (colInfo) + { + auto prov = refParent().getDataProvider(colInfo->second); + if (prov) + return prov->getToolTip(colInfo->first); + } + return wxString(); + }(); + setToolTip(toolTip); + + Refresh(); + event.Skip(); + } + + virtual void onLeaveWindow(wxMouseEvent& event) + { + highlight.first = -1; //onLeaveWindow() does not respect mouse capture! -> however highlight is drawn unconditionally during move/resize! + Refresh(); + event.Skip(); + } + + virtual void onMouseRightDown(wxMouseEvent& event) + { + const Opt<ColAction> action = refParent().clientPosToColumnAction(event.GetPosition()); + if (action) + { + const Opt<ColumnType> colType = refParent().colToType(action->col, action->compPos); + if (colType) + { + //notify right click + GridClickEvent clickEvent(EVENT_GRID_COL_LABEL_MOUSE_RIGHT, event, -1, *colType, action->compPos); + sendEventNow(clickEvent); + } + } + event.Skip(); + } + + std::unique_ptr<ColumnResizing> activeResizing; + std::unique_ptr<ColumnMove> activeMove; + std::pair<int, size_t> highlight; //(column, component) mouse-over, row < 0 if none +}; + +//---------------------------------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------------------------------- + +class Grid::MainWin : public SubWindow +{ +public: + MainWin(Grid& parent, + RowLabelWin& rowLabelWin, + ColLabelWin& colLabelWin) : SubWindow(parent), + rowLabelWin_(rowLabelWin), + colLabelWin_(colLabelWin), + cursor(-1, -1), + selectionAnchor(-1) {} + + void makeRowVisible(int row) + { + const wxRect labelRect = rowLabelWin_.getRowLabelArea(row); //returns empty rect if column not found + if (labelRect.height > 0) + { + int scrollPosX = 0; + refParent().GetViewStart(&scrollPosX, NULL); + + int pixelsPerUnitY = 0; + refParent().GetScrollPixelsPerUnit(NULL, &pixelsPerUnitY); + if (pixelsPerUnitY <= 0) return; + + const int clientPosY = refParent().CalcScrolledPosition(labelRect.GetTopLeft()).y; + if (clientPosY < 0) + { + const int scrollPosY = labelRect.GetTopLeft().y / pixelsPerUnitY; + refParent().Scroll(scrollPosX, scrollPosY); + refParent().updateWindowSizes(); //may show horizontal scroll bar + } + else if (clientPosY + labelRect.GetHeight() > rowLabelWin_.GetClientSize().GetHeight()) + { + auto execScroll = [&](int clientHeight) + { + const int scrollPosY = std::ceil((labelRect.GetTopLeft().y - clientHeight + + labelRect.GetHeight()) / static_cast<double>(pixelsPerUnitY)); + refParent().Scroll(scrollPosX, scrollPosY); + refParent().updateWindowSizes(); //may show horizontal scroll bar + }; + + const int clientHeightBefore = rowLabelWin_.GetClientSize().GetHeight(); + execScroll(clientHeightBefore); + + //client height may decrease after scroll due to a new horizontal scrollbar, resulting in a partially visible last row + const int clientHeightAfter = rowLabelWin_.GetClientSize().GetHeight(); + if (clientHeightAfter < clientHeightBefore) + execScroll(clientHeightAfter); + } + } + } + + void setCursor(int row, size_t compPos) + { + cursor = std::make_pair(row, compPos); + selectionAnchor = row; + } + std::pair<int, size_t> getCursor() const { return cursor; } // (row, component position) + +private: + virtual void render(wxDC& dc, const wxRect& rect) + { + if (IsEnabled()) + clearArea(dc, rect, getColorMainWinBackground()); + else + clearArea(dc, rect, wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE)); + + dc.SetFont(GetFont()); + dc.SetTextForeground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT)); + + const int rowHeight = rowLabelWin_.getRowHeight(); + + const wxPoint topLeft = refParent().CalcUnscrolledPosition(rect.GetTopLeft()); + const wxPoint bottomRight = refParent().CalcUnscrolledPosition(rect.GetBottomRight()); + + const int rowFirst = std::max(topLeft .y / rowHeight, 0); // [rowFirst, rowLast) + const int rowLast = std::min(bottomRight.y / rowHeight + 1, static_cast<int>(refParent().getRowCount())); + + wxPoint cellAreaTL(refParent().CalcScrolledPosition(wxPoint(0, 0))); //client coordinates + + std::vector<std::vector<VisibleColumn>> compAbsWidths = refParent().getAbsoluteWidths(); //resolve negative/stretched widths + for (auto iterComp = compAbsWidths.begin(); iterComp != compAbsWidths.end(); ++iterComp) + { + const int compWidth = std::accumulate(iterComp->begin(), iterComp->end(), 0, + [](int val, const VisibleColumn& vc) { return val + vc.width_; }); + + const size_t compPos = iterComp - compAbsWidths.begin(); + if (auto prov = refParent().getDataProvider(compPos)) + { + //draw background lines + { + DcClipper dummy(dc, rect); //solve issues with drawBackground() painting in area outside of rect (which is not also refreshed by renderCell()) -> keep small scope! + for (int row = rowFirst; row < rowLast; ++row) + drawBackground(*prov, dc, wxRect(cellAreaTL + wxPoint(0, row * rowHeight), wxSize(compWidth, rowHeight)), row, compPos); + } + + //draw single cells + for (auto iterCol = iterComp->begin(); iterCol != iterComp->end(); ++iterCol) + { + const int width = iterCol->width_; //don't use unsigned for calculations! + + if (cellAreaTL.x > rect.GetRight()) + return; //done + + if (cellAreaTL.x + width > rect.x) + for (int row = rowFirst; row < rowLast; ++row) + { + const wxRect& cellRect = wxRect(cellAreaTL.x, cellAreaTL.y + row * rowHeight, width, rowHeight); + DcClipper clip(dc, cellRect); + prov->renderCell(refParent(), dc, cellRect, row, iterCol->type_); + } + cellAreaTL.x += width; + } + } + else + cellAreaTL.x += compWidth; + } + } + + void drawBackground(GridData& prov, wxDC& dc, const wxRect& rect, int row, size_t compPos) + { + Grid& grid = refParent(); + //check if user is currently selecting with mouse + bool drawSelection = grid.isSelected(row, compPos); + if (activeSelection) + { + const int rowFrom = std::min(activeSelection->getStartRow(), activeSelection->getCurrentRow()); + const int rowTo = std::max(activeSelection->getStartRow(), activeSelection->getCurrentRow()); + + if (compPos == activeSelection->getComponentPos() && rowFrom <= row && row <= rowTo) + drawSelection = activeSelection->isPositiveSelect(); //overwrite default + } + + prov.renderRowBackgound(dc, rect, row, grid.IsEnabled(), drawSelection, wxWindow::FindFocus() == &grid.getMainWin()); + } + + virtual void onMouseLeftDown (wxMouseEvent& event) { onMouseDown(event); } + virtual void onMouseLeftUp (wxMouseEvent& event) { onMouseUp (event); } + virtual void onMouseRightDown(wxMouseEvent& event) { onMouseDown(event); } + virtual void onMouseRightUp (wxMouseEvent& event) { onMouseUp (event); } + + virtual void onMouseLeftDouble(wxMouseEvent& event) + { + const wxPoint absPos = refParent().CalcUnscrolledPosition(event.GetPosition()); + const int row = rowLabelWin_.getRowAtPos(absPos.y); //return -1 if no row at this position + const auto colInfo = refParent().getColumnAtPos(absPos.x); //returns (column type, compPos), column < 0 if not found + if (colInfo) + { + //notify event + GridClickEvent mouseEvent(EVENT_GRID_MOUSE_LEFT_DOUBLE, event, row, colInfo->first, colInfo->second); + sendEventNow(mouseEvent); + } + event.Skip(); + } + + void onMouseDown(wxMouseEvent& event) //handle left and right mouse button clicks (almost) the same + { + if (FindFocus() != this) //doesn't seem to happen automatically for right mouse button + SetFocus(); + + const wxPoint absPos = refParent().CalcUnscrolledPosition(event.GetPosition()); + + const int row = rowLabelWin_.getRowAtPos(absPos.y); //return -1 if no row at this position + const auto colInfo = refParent().getColumnAtPos(absPos.x); //returns (column type, compPos), column < 0 if not found + const ColumnType colType = colInfo ? colInfo->first : DUMMY_COLUMN_TYPE; + const int compPos = colInfo ? colInfo->second : -1; + + //notify event + GridClickEvent mouseEvent(event.RightDown() ? EVENT_GRID_MOUSE_RIGHT_DOWN : EVENT_GRID_MOUSE_LEFT_DOWN, event, row, colType, compPos); + if (!sendEventNow(mouseEvent)) //if event was not processed externally... + { + if (!event.RightDown() || !refParent().isSelected(row, compPos)) //do NOT start a new selection if user right-clicks on a selected area! + { + if (row >= 0 && compPos >= 0) + cursor = std::make_pair(row, compPos); + + if (event.ControlDown()) + { + if (row >= 0 && compPos >= 0) + activeSelection.reset(new MouseSelection(*this, row, compPos, !refParent().isSelected(row, compPos))); + selectionAnchor = row; + } + else if (event.ShiftDown()) + { + if (row >= 0 && compPos >= 0) + activeSelection.reset(new MouseSelection(*this, selectionAnchor, compPos, true)); + refParent().clearSelectionAll(); + } + else + { + if (row >= 0 && compPos >= 0) + activeSelection.reset(new MouseSelection(*this, row, compPos, true)); + selectionAnchor = row; + refParent().clearSelectionAll(); + } + } + Refresh(); + } + + event.Skip(); //allow changin focus + } + + void onMouseUp(wxMouseEvent& event) + { + //const int currentRow = clientPosToRow(event.GetPosition()); -> this one may point to row which is not in visible area! + + if (activeSelection) + { + const int rowFrom = activeSelection->getStartRow(); + const int rowTo = activeSelection->getCurrentRow(); + const size_t compPos = activeSelection->getComponentPos(); + const bool positive = activeSelection->isPositiveSelect(); + refParent().selectRange(rowFrom, rowTo, compPos, positive); + + cursor.first = activeSelection->getCurrentRow(); //slight deviation from Explorer: change cursor while dragging mouse! -> unify behavior with shift + direction keys + + activeSelection.reset(); + } + + //this one may point to row which is not in visible area! + const wxPoint absPos = refParent().CalcUnscrolledPosition(event.GetPosition()); + + const int row = rowLabelWin_.getRowAtPos(absPos.y); //return -1 if no row at this position + const auto colInfo = refParent().getColumnAtPos(absPos.x); //returns (column type, compPos), column < 0 if not found + + const ColumnType colType = colInfo ? colInfo->first : DUMMY_COLUMN_TYPE; //we probably should notify even if colInfo is invalid! + const int compPos = colInfo ? colInfo->second : 0; + + //notify event + GridClickEvent mouseEvent(event.RightUp() ? EVENT_GRID_MOUSE_RIGHT_UP : EVENT_GRID_MOUSE_LEFT_UP, event, row, colType, compPos); + sendEventNow(mouseEvent); + + Refresh(); + event.Skip(); //allow changing focus + } + + virtual void onMouseCaptureLost(wxMouseCaptureLostEvent& event) + { + activeSelection.reset(); + Refresh(); + //event.Skip(); -> we DID handle it! + } + + virtual void onMouseMovement(wxMouseEvent& event) + { + if (activeSelection) + activeSelection->evalMousePos(); //eval on both mouse movement + timer event! + + //change tooltip + const wxString toolTip = [&]() -> wxString + { + const wxPoint absPos = refParent().CalcUnscrolledPosition(event.GetPosition()); + + const int row = rowLabelWin_.getRowAtPos(absPos.y); //return -1 if no row at this position + const auto colInfo = refParent().getColumnAtPos(absPos.x); //returns (column type, compPos), column < 0 if not found + if (colInfo && row >= 0) + { + auto prov = refParent().getDataProvider(colInfo->second); + if (prov) + return prov->getToolTip(row, colInfo->first); + } + return wxString(); + }(); + + setToolTip(toolTip); + + event.Skip(); + } + + virtual void onKeyDown(wxKeyEvent& event) + { + int keyCode = event.GetKeyCode(); + if (GetLayoutDirection() == wxLayout_RightToLeft) + { + if (keyCode == WXK_LEFT) + keyCode = WXK_RIGHT; + else if (keyCode == WXK_RIGHT) + keyCode = WXK_LEFT; + else if (keyCode == WXK_NUMPAD_LEFT) + keyCode = WXK_NUMPAD_RIGHT; + else if (keyCode == WXK_NUMPAD_RIGHT) + keyCode = WXK_NUMPAD_LEFT; + } + + const int rowCount = refParent().getRowCount(); + + auto setSingleSelection = [&](int row, int compPos) + { + numeric::restrict(row, 0, rowCount - 1); + numeric::restrict(compPos, 0, static_cast<int>(refParent().comp.size()) - 1); + refParent().setGridCursor(row, compPos); + }; + + auto setSelectionRange = [&](int row) + { + numeric::restrict(row, 0, rowCount - 1); + + cursor.first = row; + if (selectionAnchor < 0) + selectionAnchor = row; + this->makeRowVisible(row); + + auto& comp = refParent().comp; + std::for_each(comp.begin(), comp.end(), [](Grid::Component& c) { c.selection.clear(); }); //clear selection, do NOT fire event + refParent().selectRange(selectionAnchor, row, cursor.second); //set new selection + fire event + }; + + switch (keyCode) + { + case WXK_UP: + case WXK_NUMPAD_UP: + if (event.ShiftDown()) + setSelectionRange(cursor.first - 1); + else if (event.ControlDown()) + refParent().scrollDelta(0, -1); + else + setSingleSelection(cursor.first - 1, cursor.second); + break; + + case WXK_DOWN: + case WXK_NUMPAD_DOWN: + if (event.ShiftDown()) + setSelectionRange(cursor.first + 1); + else if (event.ControlDown()) + refParent().scrollDelta(0, 1); + else + setSingleSelection(cursor.first + 1, cursor.second); + break; + + case WXK_LEFT: + case WXK_NUMPAD_LEFT: + if (event.ControlDown()) + refParent().scrollDelta(-1, 0); + else if (event.ShiftDown()) + ; + else + setSingleSelection(cursor.first, cursor.second - 1); + break; + + case WXK_RIGHT: + case WXK_NUMPAD_RIGHT: + if (event.ControlDown()) + refParent().scrollDelta(1, 0); + else if (event.ShiftDown()) + ; + else + setSingleSelection(cursor.first, cursor.second + 1); + break; + + case WXK_HOME: + case WXK_NUMPAD_HOME: + if (event.ShiftDown()) + setSelectionRange(0); + else if (event.ControlDown()) + setSingleSelection(0, 0); + else + setSingleSelection(0, cursor.second); + break; + + case WXK_END: + case WXK_NUMPAD_END: + if (event.ShiftDown()) + setSelectionRange(rowCount - 1); + else if (event.ControlDown()) + setSingleSelection(rowCount - 1, refParent().comp.size() - 1); + else + setSingleSelection(rowCount - 1, cursor.second); + break; + + case WXK_PAGEUP: + case WXK_NUMPAD_PAGEUP: + if (event.ShiftDown()) + setSelectionRange(cursor.first - GetClientSize().GetHeight() / rowLabelWin_.getRowHeight()); + else if (event.ControlDown()) + ; + else + setSingleSelection(cursor.first - GetClientSize().GetHeight() / rowLabelWin_.getRowHeight(), cursor.second); + break; + + case WXK_PAGEDOWN: + case WXK_NUMPAD_PAGEDOWN: + if (event.ShiftDown()) + setSelectionRange(cursor.first + GetClientSize().GetHeight() / rowLabelWin_.getRowHeight()); + else if (event.ControlDown()) + ; + else + setSingleSelection(cursor.first + GetClientSize().GetHeight() / rowLabelWin_.getRowHeight(), cursor.second); + break; + + case 'A': //Ctrl + A - select all + if (event.ControlDown()) + refParent().selectRange(0, rowCount, cursor.second); + break; + + case WXK_NUMPAD_ADD: //CTRL + '+' - auto-size all + if (event.ControlDown()) + refParent().autoSizeColumns(cursor.second); + break; + } + + Refresh(); + event.Skip(); + } + + virtual void onFocus(wxFocusEvent& event) { Refresh(); event.Skip(); } + + class MouseSelection : private wxEvtHandler + { + public: + MouseSelection(MainWin& wnd, + int rowStart, + size_t compPos, + bool positiveSelect) : wnd_(wnd), rowStart_(rowStart), compPos_(compPos), rowCurrent_(rowStart), positiveSelect_(positiveSelect), toScrollX(0), toScrollY(0), tickCountLast(clock()) + { + wnd_.CaptureMouse(); + timer.Connect(wxEVT_TIMER, wxEventHandler(MouseSelection::onTimer), NULL, this); + timer.Start(100); //timer interval in ms + evalMousePos(); + } + ~MouseSelection() { if (wnd_.HasCapture()) wnd_.ReleaseMouse(); } + + int getStartRow () const { return rowStart_; } + size_t getComponentPos () const { return compPos_; } + int getCurrentRow () const { return rowCurrent_; } + bool isPositiveSelect() const { return positiveSelect_; } //are we selecting or unselecting? + + void evalMousePos() + { + const clock_t now = clock(); + const double deltaTime = static_cast<double>(now - tickCountLast) / CLOCKS_PER_SEC; //unit: [sec] + tickCountLast = now; + + wxMouseState mouseState = wxGetMouseState(); + const wxPoint clientPos = wnd_.ScreenToClient(wxPoint(mouseState.GetX(), mouseState.GetY())); + const wxSize clientSize = wnd_.GetClientSize(); + + //scroll while dragging mouse + const int overlapPixY = clientPos.y < 0 ? clientPos.y : + clientPos.y >= clientSize.GetHeight() ? clientPos.y - (clientSize.GetHeight() - 1) : 0; + const int overlapPixX = clientPos.x < 0 ? clientPos.x : + clientPos.x >= clientSize.GetWidth() ? clientPos.x - (clientSize.GetWidth() - 1) : 0; + + int pixelsPerUnitY = 0; + wnd_.refParent().GetScrollPixelsPerUnit(NULL, &pixelsPerUnitY); + if (pixelsPerUnitY <= 0) return; + + const double mouseDragSpeedIncScrollU = pixelsPerUnitY > 0 ? MOUSE_DRAG_ACCELERATION * wnd_.rowLabelWin_.getRowHeight() / pixelsPerUnitY : 0; //unit: [scroll units / (pixel * sec)] + + auto autoScroll = [&](int overlapPix, double& toScroll) + { + if (overlapPix != 0) + { + const double scrollSpeed = overlapPix * mouseDragSpeedIncScrollU; //unit: [scroll units / sec] + toScroll += scrollSpeed * deltaTime; + } + else + toScroll = 0; + }; + + autoScroll(overlapPixX, toScrollX); + autoScroll(overlapPixY, toScrollY); + + if (toScrollX != 0 || toScrollY != 0) + { + wnd_.refParent().scrollDelta(static_cast<int>(toScrollX), static_cast<int>(toScrollY)); // + toScrollX -= static_cast<int>(toScrollX); //rounds down for positive numbers, up for negative, + toScrollY -= static_cast<int>(toScrollY); //exactly what we want + } + + { + //select current row *after* scrolling + wxPoint clientPosTrimmed = clientPos; + numeric::restrict(clientPosTrimmed.y, 0, clientSize.GetHeight() - 1); //do not select row outside client window! + + wxPoint absPos = wnd_.refParent().CalcUnscrolledPosition(clientPosTrimmed); + int currentRow = wnd_.rowLabelWin_.getRowAtPos(absPos.y); //return -1 if no row at this position + + //make sure "current row" is always at a valid position while moving! + if (currentRow < 0) + currentRow = static_cast<int>(wnd_.refParent().getRowCount()) - 1; //seems, we hit the empty space at the end + + if (currentRow >= 0 && rowCurrent_ != currentRow) + { + rowCurrent_ = currentRow; + wnd_.Refresh(); + } + } + } + + private: + void onTimer(wxEvent& event) { evalMousePos(); } + + MainWin& wnd_; + const int rowStart_; + const size_t compPos_; + int rowCurrent_; + const bool positiveSelect_; + wxTimer timer; + double toScrollX; //count outstanding scroll units to scroll while dragging mouse + double toScrollY; // + clock_t tickCountLast; + }; + + virtual void ScrollWindow(int dx, int dy, const wxRect* rect) + { + wxWindow::ScrollWindow(dx, dy, rect); + rowLabelWin_.ScrollWindow(0, dy, rect); + colLabelWin_.ScrollWindow(dx, 0, rect); + + refParent().updateWindowSizes(false); //row label width has changed -> do *not* update scrollbars: recursion on wxGTK! + rowLabelWin_.Update(); //update while dragging scroll thumb + } + + RowLabelWin& rowLabelWin_; + ColLabelWin& colLabelWin_; + + std::unique_ptr<MouseSelection> activeSelection; //bound while user is selecting with mouse + + std::pair<int, int> cursor; //(row, component position) -1 if none + int selectionAnchor; //-1 if none +}; + +//---------------------------------------------------------------------------------------------------------------- +//---------------------------------------------------------------------------------------------------------------- + +Grid::Grid(wxWindow* parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) : wxScrolledWindow(parent, id, pos, size, style | wxWANTS_CHARS, name), + showScrollbarX(true), + showScrollbarY(true), + colLabelHeight(DEFAULT_COL_LABEL_HEIGHT), + drawRowLabel(true), + comp(1), + colSizeOld(0) +{ + Connect(wxEVT_PAINT, wxPaintEventHandler(Grid::onPaintEvent ), NULL, this); + Connect(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(Grid::onEraseBackGround), NULL, this); + Connect(wxEVT_SIZE, wxEventHandler (Grid::onSizeEvent ), NULL, this); + + cornerWin_ = new CornerWin (*this); // + rowLabelWin_ = new RowLabelWin(*this); //owership handled by "this" + colLabelWin_ = new ColLabelWin(*this); // + mainWin_ = new MainWin (*this, *rowLabelWin_, *colLabelWin_); // + + SetTargetWindow(mainWin_); + + SetInitialSize(size); //"Most controls will use this to set their initial size" -> why not + + assert(GetClientSize() == GetSize()); //borders are NOT allowed for Grid + //reason: updateWindowSizes() wants to use "GetSize()" as a "GetClientSize()" including scrollbars +} + + +void Grid::updateWindowSizes(bool updateScrollbar) +{ + /* We have to deal with a nasty circular dependency: + + mainWin_->GetClientSize() + /|\ + SetScrollbars -> show/hide scrollbars depending on whether client size is big enough + /|\ + GetClientRect(); -> possibly trimmed by scrollbars + /|\ + mainWin_->GetClientSize() -> also trimmed, since it's a sub-window ! + + */ + + //update scrollbars: showing/hiding scrollbars changes client size! + if (updateScrollbar) + { + //help SetScrollbars() do a better job + //mainWin_->SetSize(std::max(0, GetSize().GetWidth () - rowLabelWidth), -> not working! + // std::max(0, GetSize().GetHeight() - colLabelHeight)); + + int scrollPosX = 0; + int scrollPosY = 0; + GetViewStart(&scrollPosX, &scrollPosY); //preserve current scroll position + + const int pixPerScrollUnitY = std::max(1, rowLabelWin_->getRowHeight()); + const int pixPerScrollUnitX = pixPerScrollUnitY; + + const int scrollUnitsX = std::ceil(static_cast<double>( getMinAbsoluteWidthTotal()) / pixPerScrollUnitX); + const int scrollUnitsY = std::ceil(static_cast<double>(rowLabelWin_->getLogicalHeight()) / pixPerScrollUnitY); + + SetScrollbars(pixPerScrollUnitX, pixPerScrollUnitY, //another abysmal wxWidgets design decision: why is precision needlessly reduced to "pixelsPerUnit"???? + scrollUnitsX, scrollUnitsY, + scrollPosX, scrollPosY); + } + + const wxRect clientRect = GetClientRect(); + + const int mainWinHeight = std::max(0, clientRect.height - colLabelHeight); + + int rowLabelWidth = 0; //calculate optimal row label width + if (drawRowLabel) + { + const int heightTotal = rowLabelWin_->getLogicalHeight(); + if (heightTotal > 0) + { + int yFrom = CalcUnscrolledPosition(wxPoint(0, 0)).y; + int yTo = CalcUnscrolledPosition(wxPoint(0, mainWinHeight - 1)).y ; + numeric::restrict(yFrom, 0, heightTotal - 1); + numeric::restrict(yTo, 0, heightTotal - 1); + + const int rowFrom = rowLabelWin_->getRowAtPos(yFrom); + const int rowTo = rowLabelWin_->getRowAtPos(yTo); + if (rowFrom >= 0 && rowTo >= 0) + rowLabelWidth = rowLabelWin_->getBestWidth(rowFrom, rowTo); + } + } + + const int mainWinWidth = std::max(0, clientRect.width - rowLabelWidth); + + cornerWin_ ->SetSize(0, 0, rowLabelWidth, colLabelHeight); + rowLabelWin_->SetSize(0, colLabelHeight, rowLabelWidth, mainWinHeight); + colLabelWin_->SetSize(rowLabelWidth, 0, mainWinWidth, colLabelHeight); + mainWin_ ->SetSize(rowLabelWidth, colLabelHeight, mainWinWidth, mainWinHeight); +} + + +void Grid::onPaintEvent(wxPaintEvent& event) { wxPaintDC dc(this); } + + +void Grid::setColumnLabelHeight(int height) +{ + colLabelHeight = std::max(0, height); + updateWindowSizes(); +} + + +void Grid::showRowLabel(bool show) +{ + drawRowLabel = show; + updateWindowSizes(); +} + + +std::vector<int> Grid::getSelectedRows(size_t compPos) const +{ + return compPos < comp.size() ? comp[compPos].selection.get() : std::vector<int>(); +} + + +void Grid::scrollDelta(int deltaX, int deltaY) +{ + int scrollPosX = 0; + int scrollPosY = 0; + GetViewStart(&scrollPosX, &scrollPosY); + + scrollPosX += deltaX; + scrollPosY += deltaY; + + //const int unitsTotalX = GetScrollLines(wxHORIZONTAL); + //const int unitsTotalY = GetScrollLines(wxVERTICAL); + + //if (unitsTotalX <= 0 || unitsTotalY <= 0) return; -> premature + //numeric::restrict(scrollPosX, 0, unitsTotalX - 1); //make sure scroll target is in valid range + //numeric::restrict(scrollPosY, 0, unitsTotalY - 1); // + + Scroll(scrollPosX, scrollPosY); + updateWindowSizes(); //may show horizontal scroll bar +} + + +void Grid::redirectRowLabelEvent(wxMouseEvent& event) +{ + event.m_x = 0; + mainWin_->ProcessEvent(event); + + if (event.ButtonDown() && wxWindow::FindFocus() != mainWin_) + mainWin_->SetFocus(); +} + + +size_t Grid::getRowCount() const +{ + return comp.empty() ? 0 : comp.front().dataView_ ? comp.front().dataView_->getRowCount() : 0; +} + + +void Grid::Refresh(bool eraseBackground, const wxRect* rect) +{ + const size_t rowCountNew = getRowCount(); + if (colSizeOld != rowCountNew) + { + colSizeOld = rowCountNew; + std::for_each(comp.begin(), comp.end(), [&](Component& c) { c.selection.init(rowCountNew); }); + updateWindowSizes(); + } + wxScrolledWindow::Refresh(eraseBackground, rect); +} + + +void Grid::setRowHeight(int height) +{ + rowLabelWin_->setRowHeight(height); + updateWindowSizes(); +} + + +void Grid::setColumnConfig(const std::vector<Grid::ColumnAttribute>& attr, size_t compPos) +{ + if (compPos < comp.size()) + { + //hold ownership of non-visible columns + comp[compPos].oldColAttributes = attr; + + std::vector<VisibleColumn> visibleCols; + std::for_each(attr.begin(), attr.end(), + [&](const ColumnAttribute& ca) + { + if (ca.visible_) + visibleCols.push_back(Grid::VisibleColumn(ca.type_, ca.width_)); + }); + + //set ownership of visible columns + comp[compPos].visibleCols = visibleCols; + + updateWindowSizes(); + Refresh(); + } +} + + +std::vector<Grid::ColumnAttribute> Grid::getColumnConfig(size_t compPos) const +{ + if (compPos < comp.size()) + { + auto iterVcols = comp[compPos].visibleCols.begin(); + auto iterVcolsend = comp[compPos].visibleCols.end(); + + std::set<ColumnType> visibleTypes; + std::transform(iterVcols, iterVcolsend, std::inserter(visibleTypes, visibleTypes.begin()), + [](const VisibleColumn& vc) { return vc.type_; }); + + //get non-visible columns (+ outdated visible ones) + std::vector<ColumnAttribute> output = comp[compPos].oldColAttributes; + + //update visible columns but keep order of non-visible ones! + std::for_each(output.begin(), output.end(), + [&](ColumnAttribute& ca) + { + if (visibleTypes.find(ca.type_) != visibleTypes.end()) + { + if (iterVcols != iterVcolsend) + { + ca.visible_ = true; //paranoia + ca.type_ = iterVcols->type_; + ca.width_ = iterVcols->width_; + ++iterVcols; + } + } + else + ca.visible_ = false; //paranoia + }); + + return output; + } + return std::vector<ColumnAttribute>(); +} + + +void Grid::showScrollBars(bool horizontal, bool vertical) +{ +#ifdef FFS_WIN + showScrollbarX = horizontal; + showScrollbarY = vertical; + updateWindowSizes(); + +#elif defined FFS_LINUX //get rid of scrollbars, but preserve scrolling behavior! + GtkWidget* gridWidget = wxWindow::m_widget; + GtkScrolledWindow* scrolledWindow = GTK_SCROLLED_WINDOW(gridWidget); + gtk_scrolled_window_set_policy(scrolledWindow, + horizontal ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER, + vertical ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER); +#endif +} + + +#ifdef FFS_WIN //get rid of scrollbars, but preserve scrolling behavior! +void Grid::SetScrollbar(int orientation, int position, int thumbSize, int range, bool refresh) +{ + if ((orientation == wxHORIZONTAL && !showScrollbarX) || (orientation == wxVERTICAL && !showScrollbarY)) + wxWindow::SetScrollbar(orientation, 0, 0, 0, refresh); + else + wxWindow::SetScrollbar(orientation, position, thumbSize, range, refresh); +} + + +#ifndef WM_MOUSEHWHEEL //MinGW is clueless... +#define WM_MOUSEHWHEEL 0x020E +#endif + +WXLRESULT Grid::MSWDefWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +{ + if (nMsg == WM_MOUSEHWHEEL) + { + const int distance = GET_WHEEL_DELTA_WPARAM(wParam); + const int delta = WHEEL_DELTA; + const int rotations = distance / delta; + + static int linesPerRotation = -1; + if (linesPerRotation < 0) + if (!::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &linesPerRotation, 0)) + linesPerRotation = 3; + + SetFocus(); + scrollDelta(rotations * linesPerRotation, 0); //in scroll units + } + + return wxScrolledWindow::MSWDefWindowProc(nMsg, wParam, lParam);; +} +#endif + + +wxWindow& Grid::getCornerWin () { return *cornerWin_; } +wxWindow& Grid::getRowLabelWin() { return *rowLabelWin_; } +wxWindow& Grid::getColLabelWin() { return *colLabelWin_; } +wxWindow& Grid::getMainWin () { return *mainWin_; } + + +wxRect Grid::getColumnLabelArea(ColumnType colType, size_t compPos) const +{ + std::vector<std::vector<VisibleColumn>> compAbsWidths = getAbsoluteWidths(); //resolve negative/stretched widths + if (compPos < compAbsWidths.size()) + { + auto iterComp = compAbsWidths.begin() + compPos; + + auto iterCol = std::find_if(iterComp->begin(), iterComp->end(), [&](const VisibleColumn& vc) { return vc.type_ == colType; }); + if (iterCol != iterComp->end()) + { + int posX = std::accumulate(compAbsWidths.begin(), iterComp, 0, + [](int val, const std::vector<VisibleColumn>& cols) + { + return val + std::accumulate(cols.begin(), cols.end(), 0, [](int val2, const VisibleColumn& vc) { return val2 + vc.width_; }); + }); + + posX += std::accumulate(iterComp->begin(), iterCol, 0, [](int val, const VisibleColumn& vc) { return val + vc.width_; }); + + return wxRect(wxPoint(posX, 0), wxSize(iterCol->width_, colLabelHeight)); + } + } + return wxRect(); +} + + +Opt<Grid::ColAction> Grid::clientPosToColumnAction(const wxPoint& pos) const +{ + const int absPosX = CalcUnscrolledPosition(pos).x; + if (absPosX >= 0) + { + int accuWidth = 0; + + std::vector<std::vector<VisibleColumn>> compAbsWidths = getAbsoluteWidths(); //resolve negative/stretched widths + for (auto iterComp = compAbsWidths.begin(); iterComp != compAbsWidths.end(); ++iterComp) + { + const size_t compPos = iterComp - compAbsWidths.begin(); + const int resizeTolerance = columnResizeAllowed(compPos) ? COLUMN_RESIZE_TOLERANCE : 0; + + for (auto iterCol = iterComp->begin(); iterCol != iterComp->end(); ++iterCol) + { + const size_t col = iterCol - iterComp->begin(); + + accuWidth += iterCol->width_; + if (std::abs(absPosX - accuWidth) < resizeTolerance) + { + ColAction out = {}; + out.wantResize = true; + out.col = col; + out.compPos = compPos; + return out; + } + else if (absPosX < accuWidth) + { + ColAction out = {}; + out.wantResize = false; + out.col = col; + out.compPos = compPos; + return out; + } + } + } + } + return NoValue(); +} + + +void Grid::moveColumn(size_t colFrom, size_t colTo, size_t compPos) +{ + if (compPos < comp.size()) + { + auto& visibleCols = comp[compPos].visibleCols; + if (colFrom < visibleCols.size() && + colTo < visibleCols.size() && + colTo != colFrom) + { + const auto colAtt = visibleCols[colFrom]; + visibleCols.erase (visibleCols.begin() + colFrom); + visibleCols.insert(visibleCols.begin() + colTo, colAtt); + } + } +} + + +int Grid::clientPosToMoveTargetColumn(const wxPoint& pos, size_t compPos) const +{ + std::vector<std::vector<VisibleColumn>> compAbsWidths = getAbsoluteWidths(); //resolve negative/stretched widths + if (compPos < compAbsWidths.size()) + { + auto iterComp = compAbsWidths.begin() + compPos; + const int absPosX = CalcUnscrolledPosition(pos).x; + + int accuWidth = std::accumulate(compAbsWidths.begin(), iterComp, 0, + [](int val, const std::vector<VisibleColumn>& cols) + { + return val + std::accumulate(cols.begin(), cols.end(), 0, + [](int val2, const VisibleColumn& vc) { return val2 + vc.width_; }); + }); + + for (auto iterCol = iterComp->begin(); iterCol != iterComp->end(); ++iterCol) + { + const int width = iterCol->width_; //beware dreaded unsigned conversions! + accuWidth += width; + + if (absPosX < accuWidth - width / 2) + return iterCol - iterComp->begin(); + } + return iterComp->size(); + } + return -1; +} + + +Opt<ColumnType> Grid::colToType(size_t col, size_t compPos) const +{ + if (compPos < comp.size()) + { + auto& visibleCols = comp[compPos].visibleCols; + if (col < visibleCols.size()) + return visibleCols[col].type_; + } + return NoValue(); +} + + +int Grid::getRowAtPos(int posY) const { return rowLabelWin_->getRowAtPos(posY); } + + +Opt<std::pair<ColumnType, size_t>> Grid::getColumnAtPos(int posX) const +{ + if (posX >= 0) + { + std::vector<std::vector<VisibleColumn>> compAbsWidths = getAbsoluteWidths(); //resolve negative/stretched widths + + int accWidth = 0; + for (auto iterComp = compAbsWidths.begin(); iterComp != compAbsWidths.end(); ++iterComp) + for (auto iterCol = iterComp->begin(); iterCol != iterComp->end(); ++iterCol) + { + accWidth += iterCol->width_; + if (posX < accWidth) + { + const size_t compPos = iterComp - compAbsWidths.begin(); + return std::make_pair(iterCol->type_, compPos); + } + } + } + return NoValue(); +} + + +wxRect Grid::getCellArea(int row, ColumnType colType, size_t compPos) const +{ + const wxRect& colArea = getColumnLabelArea(colType, compPos); + const wxRect& rowArea = rowLabelWin_->getRowLabelArea(row); + return wxRect(wxPoint(colArea.x, rowArea.y), wxSize(colArea.width, rowArea.height)); +} + + +void Grid::setGridCursor(int row, size_t compPos) +{ + if (compPos < comp.size()) + { + std::for_each(comp.begin(), comp.end(), [](Grid::Component& c) { c.selection.clear(); }); //clear selection, do NOT fire event + selectRange(row, row, compPos); //set new selection + fire event + + mainWin_->setCursor(row, compPos); + mainWin_->makeRowVisible(row); + mainWin_->Refresh(); + } +} + + +void Grid::selectRange(int rowFrom, int rowTo, size_t compPos, bool positive) +{ + if (compPos < comp.size()) + { + comp[compPos].selection.selectRange(rowFrom, rowTo, positive); + + //notify event + GridRangeSelectEvent selectionEvent(rowFrom, rowTo, compPos, positive); + if (wxEvtHandler* evtHandler = GetEventHandler()) + evtHandler->ProcessEvent(selectionEvent); + } +} + + +void Grid::clearSelectionAll() +{ + std::for_each(comp.begin(), comp.end(), [](Grid::Component& c) { c.selection.clear(); }); + + //notify event + GridRangeSelectEvent unselectionEvent(-1, -1, static_cast<size_t>(-1), false); + if (wxEvtHandler* evtHandler = GetEventHandler()) + evtHandler->ProcessEvent(unselectionEvent); +} + + +void Grid::scrollTo(int row) +{ + const wxRect labelRect = rowLabelWin_->getRowLabelArea(row); //returns empty rect if column not found + if (labelRect.height > 0) + { + int pixelsPerUnitY = 0; + GetScrollPixelsPerUnit(NULL, &pixelsPerUnitY); + if (pixelsPerUnitY >= 0) + { + int scrollPosX = 0; + GetViewStart(&scrollPosX, NULL); + int scrollPosY = labelRect.GetTopLeft().y / pixelsPerUnitY; + + Scroll(scrollPosX, scrollPosY); + updateWindowSizes(); //may show horizontal scroll bar + Refresh(); + } + } +} + + +std::pair<int, size_t> Grid::getGridCursor() const +{ + return mainWin_->getCursor(); +} + + +int Grid::getBestColumnSize(size_t col, size_t compPos) const +{ + if (compPos < comp.size()) + { + auto& visibleCols = comp[compPos].visibleCols; + auto dataView = comp[compPos].dataView_; + if (dataView && col < visibleCols.size()) + { + const ColumnType type = visibleCols[col].type_; + + wxClientDC dc(mainWin_); + dc.SetFont(mainWin_->GetFont()); + + size_t maxSize = 0; + const std::pair<int, int> rowRange = rowLabelWin_->getRowsOnClient(mainWin_->GetClientRect()); //returns range [begin, end) + + for (int row = rowRange.first; row < rowRange.second; ++row) + maxSize = std::max(maxSize, dataView->getBestSize(dc, row, type)); + + return maxSize; + } + } + return -1; +} + + +void Grid::autoSizeColumns(size_t compPos) +{ + if (compPos < comp.size() && comp[compPos].allowColumnResize) + { + auto& visibleCols = comp[compPos].visibleCols; + for (auto iter = visibleCols.begin(); iter != visibleCols.end(); ++iter) + { + const int col = iter - visibleCols.begin(); + const int bestWidth = getBestColumnSize(col, compPos); //return -1 on error + if (bestWidth >= 0) + { + const size_t newWidth = std::max(COLUMN_MIN_WIDTH, bestWidth); + iter->width_ = newWidth; + + //notify column resize (asynchronously!) + GridColumnResizeEvent sizeEvent(newWidth, iter->type_, compPos); + wxEvtHandler* evtHandler = GetEventHandler(); + if (evtHandler) + evtHandler->AddPendingEvent(sizeEvent); + } + } + updateWindowSizes(); + Refresh(); + } +} + + +int Grid::getMinAbsoluteWidthTotal() const +{ + int minWidthTotal = 0; + //bool haveStretchedCols = false; + std::for_each(comp.begin(), comp.end(), + [&](const Component& c) + { + std::for_each(c.visibleCols.begin(), c.visibleCols.end(), + [&](const VisibleColumn& vc) + { + if (vc.width_ >= 0) + minWidthTotal += vc.width_; + else + { + //haveStretchedCols = true; + minWidthTotal += COLUMN_MIN_WIDTH; //use "min width" if column is stretched + } + }); + }); + return minWidthTotal; +} + + +std::vector<std::vector<Grid::VisibleColumn>> Grid::getAbsoluteWidths() const //evaluate negative widths as stretched absolute values! structure matches "comp" +{ + std::vector<std::vector<VisibleColumn>> output; + + std::vector<std::pair<int, VisibleColumn*>> stretchedCols; //(factor, column to stretch) + int factorTotal = 0; + int minWidthTotal = 0; + + output.reserve(comp.size()); + std::for_each(comp.begin(), comp.end(), + [&](const Component& c) + { + output.push_back(std::vector<VisibleColumn>()); + auto& compWidths = output.back(); + + compWidths.reserve(c.visibleCols.size()); + std::for_each(c.visibleCols.begin(), c.visibleCols.end(), + [&](const VisibleColumn& vc) + { + if (vc.width_ >= 0) + { + compWidths.push_back(Grid::VisibleColumn(vc.type_, vc.width_)); + minWidthTotal += vc.width_; + } + else //stretched column + { + compWidths.push_back(Grid::VisibleColumn(vc.type_, COLUMN_MIN_WIDTH)); //use "min width" if column is stretched + minWidthTotal += COLUMN_MIN_WIDTH; + + stretchedCols.push_back(std::make_pair(vc.width_, &compWidths.back())); + factorTotal += vc.width_; + } + }); + }); + + if (!stretchedCols.empty()) + { + const int widthToFill = mainWin_->GetClientSize().GetWidth() - minWidthTotal; + if (widthToFill > 0) + { + int widthRemaining = widthToFill; + for (auto iter = stretchedCols.begin(); iter != stretchedCols.end(); ++iter) + { + const int addWidth = (widthToFill * iter->first) / factorTotal; //round down + iter->second->width_ += addWidth; + widthRemaining -= addWidth; + } + + if (widthRemaining > 0) //should be empty, except for rounding errors + stretchedCols.back().second->width_ += widthRemaining; + } + } + return output; +} |