wx_grid.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <bitset>
#include <memory>
#include <utility>
#include <vector>
 
#include <wx/event.h>
#include <wx/grid.h>
#include <wx/version.h>
 
#include <kicommon.h>
#include <libeval/numeric_evaluator.h>
#include <units_provider.h>
 
class wxTextEntryBase;
class ROW_ICON_PROVIDER;
 

enum class KICOMMON_API ROW_STATE
{
    // This does not mean the row contains only one item. For instance,
    // a row might contain references to U1A and U1B but symbol fields aren't
    // independently editable for units of one symbol, so the row DATA_MODEL_ROW
    // will contain multiple references but not be expandable to multiple child items
    NON_EXPANDABLE,
    // Synthetic headers display and edit every member of the group.
    GROUP_COLLAPSED,
    GROUP_COLLAPSED_DURING_SORT,
    GROUP_EXPANDED,
    // Real parent headers display and edit only the first member, above its descendants.
    PARENT_COLLAPSED,
    PARENT_COLLAPSED_DURING_SORT,
    PARENT_EXPANDED,
    EXPANDED_CHILD
};
 
 
inline bool IsParentRow( ROW_STATE aState )
{
    return aState == ROW_STATE::PARENT_COLLAPSED || aState == ROW_STATE::PARENT_COLLAPSED_DURING_SORT
           || aState == ROW_STATE::PARENT_EXPANDED;
}
 
 
inline bool IsRowCollapsed( ROW_STATE aState )
{
    return aState == ROW_STATE::GROUP_COLLAPSED || aState == ROW_STATE::PARENT_COLLAPSED;
}
 
 
inline bool IsRowExpanded( ROW_STATE aState )
{
    return aState == ROW_STATE::GROUP_EXPANDED || aState == ROW_STATE::PARENT_EXPANDED;
}
 
 
class KICOMMON_API WX_GRID_TABLE_BASE : public wxGridTableBase
{
public:
    ~WX_GRID_TABLE_BASE() override
    {
        for( const auto& [col, attr] : m_colAttrs )
            wxSafeDecRef( attr );
    }
 
    void SetColAttr( wxGridCellAttr* aAttr, int aCol ) override
    {
        wxSafeDecRef( m_colAttrs[aCol] );
        m_colAttrs[aCol] = aAttr;
    }
 
    wxGridCellAttr* GetAttr( int aRow, int aCol, wxGridCellAttr::wxAttrKind aKind ) override
    {
        if( m_colAttrs[aCol] )
        {
            m_colAttrs[aCol]->IncRef();
            return enhanceAttr( m_colAttrs[aCol], aRow, aCol, aKind );
        }
 
        return enhanceAttr( nullptr, aRow, aCol, aKind );
    }

    virtual bool      HasRowLabelExpanders() const { return false; }
    virtual ROW_STATE GetRowState( int aRow ) const { return ROW_STATE::NON_EXPANDABLE; }

    virtual bool     HasUndoStateSerialization() const { return false; }
    virtual wxString SerializeUndoState() const { return wxEmptyString; }
    virtual void     RestoreUndoState( const wxString& aState ) {}
 
    void Clear() override
    {
        if( GetNumberRows() )
            DeleteRows( 0, GetNumberRows() );
    }
 
protected:
    wxGridCellAttr* enhanceAttr( wxGridCellAttr* aInputAttr, int aRow, int aCol,
                                 wxGridCellAttr::wxAttrKind aKind  );
 
protected:
    std::map<int, wxGridCellAttr*> m_colAttrs;
};
 
 
class KICOMMON_API WX_GRID : public wxGrid
{
public:
    // Constructor has to be wxFormBuilder-compatible
    WX_GRID( wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition,
             const wxSize& size = wxDefaultSize, long style = wxWANTS_CHARS,
             const wxString& name = wxGridNameStr );
 
    ~WX_GRID() override;

    void SetColLabelSize( int aHeight );        // Yes, we're hiding a non-virtual method

    void SetLabelFont( const wxFont& aFont );   // Yes, we're hiding a non-virtual method

    void EnableAlternateRowColors( bool aEnable = true );

    void EnableCursorRowColumnHighlight( bool aEnable = true ) { m_cursorRowColumnHighlight = aEnable; }
 
    bool IsCursorRowColumnHighlightEnabled() const { return m_cursorRowColumnHighlight; }

    wxString GetShownColumnsAsString();
    std::bitset<64> GetShownColumns();

    void ShowHideColumns( const wxString& shownColumns );

    void SetTable( wxGridTableBase* table, bool aTakeOwnership = false );

    void DestroyTable( wxGridTableBase* aTable );

    bool CommitPendingChanges( bool aQuietMode = false );
    bool CancelPendingChanges();
 
    void OnAddRow( const std::function<std::pair<int, int>()>& aAdder );

    void OnDeleteRows( const std::function<void( int row )>& aDeleter );
 
    void OnDeleteRows( const std::function<bool( int row )>& aFilter,
                       const std::function<void( int row )>& aDeleter );

    void SwapRows( int aRowA, int aRowB );
    void OnMoveRowUp( const std::function<void( int row )>& aMover );
    void OnMoveRowDown( const std::function<void( int row )>& aMover );
    void OnMoveRowUp( const std::function<bool( int row )>& aFilter,
                      const std::function<void( int row )>& aMover );
    void OnMoveRowDown( const std::function<bool( int row )>& aFilter,
                        const std::function<void( int row )>& aMover );

    void SetUnitsProvider( UNITS_PROVIDER* aProvider, int aCol = 0 );
 
    void SetAutoEvalCols( const std::vector<int>& aCols ) { m_autoEvalCols = aCols; }

    void SetAutoEvalColUnits( int col, EDA_UNITS aUnit, EDA_DATA_TYPE aUnitType );

    void SetAutoEvalColUnits( int col, EDA_UNITS aUnit );

    int GetUnitValue( int aRow, int aCol );

    std::optional<int> GetOptionalUnitValue( int aRow, int aCol );

    void SetUnitValue( int aRow, int aCol, int aValue );

    void SetOptionalUnitValue( int aRow, int aCol, std::optional<int> aValue );

    int GetVisibleWidth( int aCol, bool aHeader = true, bool aContents = true, bool aKeep = false );

    void EnsureColLabelsVisible();

    void ShowEditorOnMouseUp() { m_waitForSlowClick = true; }
    void CancelShowEditorOnMouseUp() { m_waitForSlowClick = false; }

    void ClearRows( bool aUpdateLabels = true )
    {
        if( GetNumberRows() > 0 )
            DeleteRows( 0, GetNumberRows(), aUpdateLabels );
    }

    static void CellEditorSetMargins( wxTextEntryBase* aEntry );

    static void CellEditorTransformSizeRect( wxRect& aRect );

    void OverrideMinSize( double aXPct, double aYPct )
    {
        wxSize size = DoGetBestSize();
        m_minSizeOverride = wxSize( KiROUND( size.x * aXPct ), KiROUND( size.y * aYPct ) );
    }

    void SetMinVisibleRows( wxWindow* aDialog, int aMinRows );

    static int CapHeightToVisibleRows( int aMinHeight, int aHeaderHeight,
                                       const std::vector<int>& aRowHeights, int aMaxRows );
 
    wxSize DoGetBestSize() const override
    {
        if( m_minSizeOverride )
            return m_minSizeOverride.value();
        else
            return wxGrid::DoGetBestSize();
    }

    void SetupColumnAutosizer( int aFlexibleCol );
 
    void SetGridWidthsDirty() { m_gridWidthsDirty = true; }
 
    ROW_ICON_PROVIDER* GetRowIconProvider() const { return m_rowIconProvider; }
 
    void RecomputeGridWidths();
 
protected:
    void DrawColLabel( wxDC& dc, int col ) override;

    void DrawRowLabel( wxDC& dc, int row ) override;

    void DrawCornerLabel( wxDC& dc ) override;
 
    void onGridColMove( wxGridEvent& aEvent );
    void onGridCellSelect( wxGridEvent& aEvent );
    void onCellEditorShown( wxGridEvent& aEvent );
    void onCellEditorHidden( wxGridEvent& aEvent );
 
#ifdef __WXMSW__
    void onIdleRefreshHighlight( wxIdleEvent& aEvent );
#endif
 
    void onDPIChanged(wxDPIChangedEvent& event);
 
    UNITS_PROVIDER* getUnitsProvider( int aCol ) const
    {
        if( m_unitsProviders.contains( aCol ) )
            return m_unitsProviders.at( aCol );
        else
            return m_unitsProviders.begin()->second;
    }

    std::pair<EDA_UNITS, EDA_DATA_TYPE> getColumnUnits( int aCol ) const;
 
private:
    void onSizeEvent( wxSizeEvent& aEvent );
 
protected:
    bool                       m_weOwnTable;
    bool                       m_cursorRowColumnHighlight = false;
 
    std::map<int, UNITS_PROVIDER*>                                 m_unitsProviders;
    std::unique_ptr<NUMERIC_EVALUATOR>                             m_eval;
    std::vector<int>                                               m_autoEvalCols;
    std::unordered_map<int, std::pair<EDA_UNITS, EDA_DATA_TYPE>>   m_autoEvalColsUnits;
    std::map< std::pair<int, int>, std::pair<wxString, wxString> > m_evalBeforeAfter;
 
    std::optional<wxSize>      m_minSizeOverride;
 
    std::map<int, int>         m_autosizedCols;     // map of col : min_width
    int                        m_flexibleCol;
 
    bool                       m_gridWidthsDirty = true;
    int                        m_gridWidth = 0;
 
    ROW_ICON_PROVIDER*         m_rowIconProvider;
};