rule_editor_dialog_base.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2024 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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef RULE_EDITOR_DIALOG_BASE_H
#define RULE_EDITOR_DIALOG_BASE_H
 
#include <wx/treectrl.h>
#include <wx/srchctrl.h>
#include <wx/bmpbuttn.h>
#include <wx/splitter.h>
#include <wx/scrolwin.h>
 
#include <variant>
#include <optional>
#include <unordered_map>
 
#include <dialog_shim.h>
#include <dialogs/rule_editor_data_base.h>
 
class WX_INFOBAR;
class wxDragImage;

enum RULE_EDITOR_TREE_CONTEXT_OPT
{
    ADD_RULE = 0,
    DUPLICATE_RULE,
    DELETE_RULE,
    MOVE_UP,
    MOVE_DOWN,
};

struct RULE_TREE_NODE
{
    int                                    m_nodeId;
    wxString                               m_nodeName;
    int                                    m_nodeType;
    int                                    m_nodeLevel;
    std::optional<int>                     m_nodeTypeMap;
    std::vector<RULE_TREE_NODE>            m_childNodes;
    std::shared_ptr<RULE_EDITOR_DATA_BASE> m_nodeData;
};
 

class RULE_TREE_ITEM_DATA : public wxTreeItemData
{
public:
    explicit RULE_TREE_ITEM_DATA( int aNodeId, wxTreeItemId aParentTreeItemId,
                                  wxTreeItemId aTreeItemId ) :
            m_nodeId( aNodeId ),
            m_treeItemId( aTreeItemId ),
            m_parentTreeItemId( aParentTreeItemId )
    {
    }
 
    int GetNodeId() const { return m_nodeId; }
 
    wxTreeItemId GetParentTreeItemId() const { return m_parentTreeItemId; }
 
    void SetParentTreeItemId( wxTreeItemId aParentTreeItemId )
    {
        m_parentTreeItemId = aParentTreeItemId;
    }
 
    wxTreeItemId GetTreeItemId() const { return m_treeItemId; }
 
    void SetTreeItemId( wxTreeItemId aTreeItemId ) { m_treeItemId = aTreeItemId; }
 
private:
    int          m_nodeId;
    wxTreeItemId m_treeItemId;
    wxTreeItemId m_parentTreeItemId;
};
 
 
class RULE_EDITOR_DIALOG_BASE : public DIALOG_SHIM
{
    friend class DIALOG_DRC_RULE_EDITOR;
 
public:
    RULE_EDITOR_DIALOG_BASE( wxWindow* aParent, const wxString& aTitle,
                             const wxSize& aInitialSize = wxDefaultSize );
 
    ~RULE_EDITOR_DIALOG_BASE() override;

    enum RULE_EDITOR_TREE_CONTEXT_OPT_ID
    {
        ID_NEWRULE = wxID_HIGHEST + 1,
        ID_COPYRULE,
        ID_DELETERULE,
        ID_MOVEUP,
        ID_MOVEDOWN
    };

    wxTreeCtrl* GetRuleTreeCtrl() { return m_ruleTreeCtrl; }

    void SetModified();

    void ClearModified();

    bool IsModified() const { return m_modified; }

    static RULE_EDITOR_DIALOG_BASE* GetDialog( wxWindow* aWindow );

    virtual std::vector<RULE_TREE_NODE> GetDefaultRuleTreeItems() = 0;

    virtual void AddNewRule( RULE_TREE_ITEM_DATA* aRuleTreeItemData ) = 0;

    virtual void DuplicateRule( RULE_TREE_ITEM_DATA* aRuleTreeItemData ) = 0;

    virtual void RemoveRule( int aNodeId ) = 0;

    virtual void RuleTreeItemSelectionChanged( RULE_TREE_ITEM_DATA* aCurrentRuleTreeItemData ) = 0;

    virtual void UpdateRuleTypeTreeItemData( RULE_TREE_ITEM_DATA* aRuleTreeItemData ) = 0;

    virtual bool isEnabled( RULE_TREE_ITEM_DATA* aRuleTreeItemData,
                                                          RULE_EDITOR_TREE_CONTEXT_OPT aOption ) = 0;

    void InitRuleTreeItems( const std::vector<RULE_TREE_NODE>& aRuleTreeNodes );

    wxPanel* GetContentPanel() { return m_contentPanel; }

    void SetContentPanel( wxPanel* aContentPanel );

    void RefreshContentScrollArea();

    void AppendNewRuleTreeItem( const RULE_TREE_NODE& aRuleTreeNode,
                                wxTreeItemId aParentTreeItemId );

    RULE_TREE_ITEM_DATA* GetCurrentlySelectedRuleTreeItemData() { return m_selectedData; }

    wxTreeItemId GetPreviouslySelectedRuleTreeItemId() { return m_previousId; }

    void UpdateRuleTreeItemText( wxTreeItemId aItemId, wxString aItemText );

    void SetControlsEnabled( bool aEnable );

    void DeleteRuleTreeItem( wxTreeItemId aItemId, const int& aNodeId );
 
    virtual void OnSave( wxCommandEvent& aEvent ) = 0;
 
    virtual void OnCancel( wxCommandEvent& aEvent ) = 0;
 
    bool Show( bool show ) override;
 
protected:
    void finishInitialization();
 
    bool TransferDataToWindow() override;
 
    bool TransferDataFromWindow() override;
 
    void OnCharHook( wxKeyEvent& aEvt ) override;
 
private:
    void populateRuleTreeCtrl( const std::vector<RULE_TREE_NODE>& aRuleTreeNodes,
                               const RULE_TREE_NODE& aRuleTreeNode,
                               wxTreeItemId aParentTreeItemId );

    void onRuleTreeItemRightClick( wxTreeEvent& aEvent );

    void onRuleTreeItemSelectionChanged( wxTreeEvent& aEvent );

    void onRuleTreeItemActivated( wxTreeEvent& aEvent );

    void onNewRuleOptionClick( wxCommandEvent& aEvent );

    void onDuplicateRuleOptionClick( wxCommandEvent& aEvent );

    void onDeleteRuleOptionClick( wxCommandEvent& aEvent );

    void onMoveUpRuleOptionClick( wxCommandEvent& aEvent );

    void onMoveDownRuleOptionClick( wxCommandEvent& aEvent );

    void onRuleTreeItemLeftDown( wxMouseEvent& aEvent );

    void onRuleTreeItemMouseMotion( wxMouseEvent& aEvent );

    void onRuleTreeItemLeftUp( wxMouseEvent& aEvent );

    void onFilterSearch( wxCommandEvent& aEvent );

    bool filterRuleTree( const wxTreeItemId& aItem, const wxString& aFilter );

    void saveRuleTreeState( const wxTreeItemId& aItem, const int& aNodeId = 0 );

    void restoreRuleTree( const wxTreeItemId& aParent, const int& aNodeId );

    wxTreeItemId appendRuleTreeItem( const RULE_TREE_NODE& aRuleTreeNode,
                                     wxTreeItemId aParentTreeItemId );

    void getRuleTreeChildNodes( const std::vector<RULE_TREE_NODE>& aNodes, int aParentId,
                                std::vector<RULE_TREE_NODE>& aResult );

    void moveRuleTreeItemChildrensTooOnDrag( wxTreeItemId aSrcTreeItemId,
                                             wxTreeItemId aDestTreeItemId );

    void updateRuleTreeItemMoveOptionState();

    void updateRuleTreeActionButtonsState( RULE_TREE_ITEM_DATA* aRuleTreeItemData );
 
    void onResize( wxSizeEvent& event );
 
    void onClose( wxCloseEvent& aEvt );
 
protected:
    wxTreeCtrl*       m_ruleTreeCtrl;
    WX_INFOBAR*       m_infoBar;
    wxPanel*          m_contentPanel;
    wxScrolledWindow* m_scrolledContentWin;
    wxSplitterWindow* m_splitter;
    wxSearchCtrl*     m_filterSearch;
    wxTextCtrl*       m_filterText;
    wxBoxSizer*       m_buttonsSizer;
    wxBitmapButton*   m_addRuleButton;
    wxBitmapButton*   m_copyRuleButton;
    wxBitmapButton*   m_moveTreeItemUpButton;
    wxBitmapButton*   m_moveTreeItemDownButton;
    wxBitmapButton*   m_deleteRuleButton;
    wxButton*         m_saveRuleButton;
    wxButton*         m_cancelRuleButton;
 
private:
    bool m_isDragging;
    bool m_enableMoveUp;
    bool m_enableMoveDown;
    bool m_enableAddRule;
    bool m_enableDuplicateRule;
    bool m_enableDeleteRule;
    bool m_modified;
    int  m_defaultSashPosition;
 
    wxString                    m_title;
    std::vector<RULE_TREE_NODE> m_defaultTreeItems;
    RULE_TREE_ITEM_DATA*        m_selectedData;
    wxTreeItemId                m_previousId;
    wxTreeItemId                m_draggedItem;
    wxDragImage*                m_dragImage;
 
    std::unordered_map<int, std::tuple<wxString, std::vector<int>, wxTreeItemId>> m_treeHistoryData;
};
 
#endif //RULE_EDITOR_DIALOG_BASE_H