dialog_drc_rule_editor.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 DIALOG_DRC_RULE_EDITOR_H
#define DIALOG_DRC_RULE_EDITOR_H
 
 
#include <map>
 
#include <drc/drc_rule_parser.h>
#include <thread_pool.h>
#include <drc/drc_item.h>
#include "tools/drc_tool.h"
#include <tool/tool_manager.h>
#include <drc/drc_rtree.h>
 
#include <widgets/progress_reporter_base.h>
 
#include <dialogs/rule_editor_dialog_base.h>
#include "panel_drc_rule_editor.h"
#include "drc_rule_editor_utils.h"
#include "panel_drc_group_header.h"
 
#define DIALOG_DRC_RULE_EDITOR_WINDOW_NAME wxT( "DialogDrcRuleEditorWindowName" )
 
class PCB_EDIT_FRAME;
class DIALOG_DRC_RULE_EDITOR;
class TOOL_MANAGER;
class DRC_RTREE;
 
class DIALOG_DRC_RULE_EDITOR : public RULE_EDITOR_DIALOG_BASE, PROGRESS_REPORTER_BASE
{
public:
    DIALOG_DRC_RULE_EDITOR( PCB_EDIT_FRAME* aEditorFrame, wxWindow* aParent );
 
    ~DIALOG_DRC_RULE_EDITOR();
 
    bool TransferDataToWindow() override;
 
    bool TransferDataFromWindow() override;
 
    std::vector<RULE_TREE_NODE> GetDefaultRuleTreeItems() override;

    void AddNewRule( RULE_TREE_ITEM_DATA* aRuleTreeItemData ) override;

    void DuplicateRule( RULE_TREE_ITEM_DATA* aRuleTreeItemData ) override;

    void RuleTreeItemSelectionChanged( RULE_TREE_ITEM_DATA* aCurrentRuleTreeItemData ) override;

    void UpdateRuleTypeTreeItemData( RULE_TREE_ITEM_DATA* aCurrentRuleTreeItemData ) override;

    bool isEnabled( RULE_TREE_ITEM_DATA*         aRuleTreeItemData,
                                                  RULE_EDITOR_TREE_CONTEXT_OPT aOption ) override;

    void RemoveRule( int aNodeId ) override;
 
    void UpdateData();
 
    void OnSave( wxCommandEvent& aEvent ) override;
 
    void OnCancel( wxCommandEvent& aEvent ) override;
 
private:
    std::vector<RULE_TREE_NODE> buildElectricalRuleTreeNodes( int& aParentId );
 
    std::vector<RULE_TREE_NODE> buildManufacturabilityRuleTreeNodes( int& aParentId );
 
    std::vector<RULE_TREE_NODE> buildHighspeedDesignRuleTreeNodes( int& aParentId );
 
    std::vector<RULE_TREE_NODE> buildFootprintsRuleTreeNodes( int& aParentId );
 
    void LoadExistingRules();
 
    void SaveRulesToFile();

    RULE_TREE_NODE buildRuleTreeNode( RULE_TREE_ITEM_DATA* aRuleTreeItemData,
                                    const wxString& aBaseName = wxEmptyString );

    RULE_TREE_NODE
    buildRuleTreeNodeData( const wxString& aName, const DRC_RULE_EDITOR_ITEM_TYPE& aNodeType,
                           const std::optional<int>&                             aParentId = std::nullopt,
                           const std::optional<DRC_RULE_EDITOR_CONSTRAINT_NAME>& aConstraintType = std::nullopt,
                           const std::vector<RULE_TREE_NODE>&                    aChildNodes = {},
                           const std::optional<int>&                             aId = std::nullopt );

    RULE_TREE_NODE buildRuleNodeFromKicadDrc( const wxString& aName, const wxString& aCode,
                                              const std::optional<int>& aParentId = std::nullopt );

    RULE_TREE_NODE* getRuleTreeNodeInfo( const int& aNodeId );

    void saveRule( int aNodeId );

    void closeRuleEntryView( int aNodeId );

    int highlightMatchingItems( int aNodeId );

    bool validateRuleName( int aNodeId, wxString aRuleName );

    bool deleteTreeNodeData( const int& aNodeId );

    void collectChildRuleNodes( int aParentId, std::vector<RULE_TREE_NODE*>& aResult );

    void collectModifiedRules( std::vector<RULE_TREE_NODE*>& aResult );

    bool validateAllRules( std::map<wxString, wxString>& aErrors );

    int promptUnsavedChanges();

    void selectRuleNode( int aNodeId );
 
    // PROGRESS_REPORTER calls
    bool updateUI() override;
 
    void AdvancePhase( const wxString& aMessage ) override;
 
 
protected:
    BOARD_DESIGN_SETTINGS& bds() { return m_currentBoard->GetDesignSettings(); }
 
    BOARD*          m_currentBoard; // the board currently on test
    PCB_EDIT_FRAME* m_frame;
    REPORTER*       m_reporter;
    DRC_TOOL*       m_drcTool;
    wxDataViewCtrl* m_markerDataView;
 
private:
    int                         m_nodeId;
    std::vector<RULE_TREE_NODE> m_ruleTreeNodeDatas;
    PANEL_DRC_RULE_EDITOR*      m_ruleEditorPanel;
    PANEL_DRC_GROUP_HEADER*     m_groupHeaderPanel;
 
    std::shared_ptr<RC_ITEMS_PROVIDER> m_markersProvider;
    RC_TREE_MODEL*                     m_markersTreeModel;
    int                                m_severities;
};
 
#endif //DIALOG_DRC_RULE_EDITOR_H