gridcellcoordscontainer.hpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2022  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#ifndef GRIDCELLCOORDSCONTAINER_HPP
#define GRIDCELLCOORDSCONTAINER_HPP
 
struct wxGridCellsExtent
{
    wxGridCellCoords m_topleft;
    wxGridCellCoords m_bottomright;
};
 
 
class wxGridCellCoordsContainer
{
    private:
        wxGridCellsExtent m_extent;
        wxGridCellCoordsArray m_array;
        wxArrayInt m_rowsOrCols;
        bool m_rowsSelected;
 
    public:
 
        wxGridCellCoordsContainer() = default;
 
        wxGridCellCoordsContainer(const wxGridCellCoords& topleft, const wxGridCellCoords& bottomright) : m_rowsSelected(false)
        {
            m_extent.m_topleft = topleft;
            m_extent.m_bottomright = bottomright;
        }
 
        wxGridCellCoordsContainer(const wxGridCellCoordsArray& selected) : m_rowsSelected(false)
        {
            m_array = selected;
            m_extent.m_topleft = m_array[0];
            m_extent.m_bottomright = m_array[0];
 
            for (size_t n = 1; n < m_array.size(); n++)
            {
                m_extent.m_topleft.SetRow(std::min(m_extent.m_topleft.GetRow(), m_array[n].GetRow()));
                m_extent.m_topleft.SetCol(std::min(m_extent.m_topleft.GetCol(), m_array[n].GetCol()));
                m_extent.m_bottomright.SetRow(std::max(m_extent.m_bottomright.GetRow(), m_array[n].GetRow()));
                m_extent.m_bottomright.SetCol(std::max(m_extent.m_bottomright.GetCol(), m_array[n].GetCol()));
            }
        }
 
        wxGridCellCoordsContainer(const wxArrayInt& selectedRowsOrCols, int otherDim, bool rowsSelected = true) : m_rowsSelected(rowsSelected)
        {
            m_rowsOrCols = selectedRowsOrCols;
            m_extent.m_topleft = m_rowsSelected ? wxGridCellCoords(m_rowsOrCols[0], 0) : wxGridCellCoords(0, m_rowsOrCols[0]);
            m_extent.m_bottomright = m_rowsSelected ? wxGridCellCoords(m_rowsOrCols[0], otherDim) : wxGridCellCoords(otherDim, m_rowsOrCols[0]);
 
            for (size_t n = 0; n < m_rowsOrCols.size(); n++)
            {
                if (m_rowsSelected)
                {
                    m_extent.m_topleft.SetRow(std::min(m_extent.m_topleft.GetRow(), m_rowsOrCols[n]));
                    m_extent.m_bottomright.SetRow(std::max(m_extent.m_bottomright.GetRow(), m_rowsOrCols[n]));
                }
                else
                {
                    m_extent.m_topleft.SetCol(std::min(m_extent.m_topleft.GetCol(), m_rowsOrCols[n]));
                    m_extent.m_bottomright.SetCol(std::max(m_extent.m_bottomright.GetCol(), m_rowsOrCols[n]));
                }
            }
        }
 
        const wxGridCellsExtent& getExtent() const
        {
            return m_extent;
        }
 
        size_t getRows() const
        {
            return m_extent.m_bottomright.GetRow() - m_extent.m_topleft.GetRow()+1;
        }
 
        size_t getCols() const
        {
            return m_extent.m_bottomright.GetCol() - m_extent.m_topleft.GetCol()+1;
        }
 
        bool contains(const wxGridCellCoords& cell) const
        {
            if (isSparse())
            {
                for (size_t n = 0; n < m_array.size(); n++)
                {
                    if (m_array[n] == cell)
                        return true;
                }
 
                return false;
            }
 
            if (m_rowsOrCols.size())
                return std::find(m_rowsOrCols.begin(),
                                 m_rowsOrCols.end(),
                                 m_rowsSelected ? cell.GetRow() : cell.GetCol()) != m_rowsOrCols.end();
 
            return cell.GetRow() >= m_extent.m_topleft.GetRow()
                && cell.GetRow() <= m_extent.m_bottomright.GetRow()
                && cell.GetCol() >= m_extent.m_topleft.GetCol()
                && cell.GetCol() <= m_extent.m_bottomright.GetCol();
        }
 
        bool contains(int row, int col) const
        {
            return contains(wxGridCellCoords(row, col));
        }
 
        bool isBlock() const
        {
            if (isSparse())
                return false;
 
            if (m_rowsOrCols.size())
            {
                if (m_rowsSelected && m_rowsOrCols.size() != getRows())
                    return false;
 
                if (!m_rowsSelected && m_rowsOrCols.size() != getCols())
                    return false;
            }
 
            return true;
        }
 
        bool columnsSelected() const
        {
            return m_rowsOrCols.size() && !m_rowsSelected;
        }
 
        bool isSparse() const
        {
            return m_array.size();
        }
 
        const wxGridCellCoordsArray& getArray() const
        {
            return m_array;
        }
};
 
#endif // GRIDCELLCOORDSCONTAINER_HPP