constraint_edit_tool.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 2
 * 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/>.
 */
 
#ifndef CONSTRAINT_EDIT_TOOL_H_
#define CONSTRAINT_EDIT_TOOL_H_
 
#include <map>
#include <memory>
#include <unordered_set>
#include <vector>
 
#include <tools/pcb_tool_base.h>
#include <constraints/board_constraint_adapter.h>
 
class PCB_SHAPE;
class PCB_CONSTRAINT;
class PCB_SELECTION_TOOL;
class CONDITIONAL_MENU;
class CONSTRAINT_OVERLAY;
 
namespace KIGFX
{
class PCB_RENDER_SETTINGS;
}
 

class CONSTRAINT_EDIT_TOOL : public PCB_TOOL_BASE
{
public:
    CONSTRAINT_EDIT_TOOL();
    ~CONSTRAINT_EDIT_TOOL() override = default;
 
    void Reset( RESET_REASON aReason ) override;
    bool Init() override;
 
    int AddConstraint( const TOOL_EVENT& aEvent );
    int AddPointConstraint( const TOOL_EVENT& aEvent );
    int RemoveConstraints( const TOOL_EVENT& aEvent );
    int ShowConstraints( const TOOL_EVENT& aEvent );
    int ManageConstraints( const TOOL_EVENT& aEvent );

    bool SelectConstraintAt( const VECTOR2I& aPos );

    bool EditConstraintAt( const VECTOR2I& aPos );

    bool ClearConstraintSelection();

    bool TryDeleteSelectedConstraint();

    bool TryEditSelectedConstraint();

    void SolveAfterMove( const std::vector<PCB_SHAPE*>& aShapes );

    void SolveAfterEdit( const std::vector<PCB_SHAPE*>& aShapes );

    void DiagnoseAfterMove( const std::vector<PCB_SHAPE*>& aShapes );

    void RemoveConstraintById( const KIID& aId );
    void EditConstraintById( const KIID& aId );
    void HighlightConstraintMembers( const KIID& aId, int aMemberIndex );

    int refreshOverlay( const TOOL_EVENT& aEvent );

    int onSelectionChanged( const TOOL_EVENT& aEvent );

    int onHoverMotion( const TOOL_EVENT& aEvent );
 
private:
    void setTransitions() override;

    BOARD_ITEM* constraintParent() const;

    void finishConstraintCommit( BOARD_COMMIT& aCommit,
                                 const std::vector<PCB_CONSTRAINT*>& aAdded );

    bool commitConstraint( std::unique_ptr<PCB_CONSTRAINT> aConstraint );

    int pickShapeConstraint( PCB_CONSTRAINT_TYPE aType, const TOOL_EVENT& aEvent );

    int pickLinearConstraint( PCB_CONSTRAINT_TYPE aType, const TOOL_EVENT& aEvent );

    void solveAddedConstraint( PCB_CONSTRAINT* aConstraint );

    PCB_CONSTRAINT* hitTestBadge( const VECTOR2I& aPos ) const;

    void setSelectedConstraint( PCB_CONSTRAINT* aConstraint );

    KIGFX::PCB_RENDER_SETTINGS* pcbRenderSettings() const;

    void updateConstrainedItems( const BOARD_CONSTRAINT_DIAGNOSTICS& aDiag );

    void updateHighlightedConstraintMembers( PCB_CONSTRAINT* aConstraint );

    void repaintShadowItems( const std::unordered_set<KIID>& aOld, const std::unordered_set<KIID>& aNew );

    void updateConstraintMsgPanel( PCB_CONSTRAINT* aConstraint );

    void refreshDiagnostics();

    void renderConstraintViews();

    const BOARD_CONSTRAINT_DIAGNOSTICS& ensureDiagnosis();

    const std::vector<PCB_SHAPE*>& hoverCandidates();

    void applyDiagnostics( const BOARD_CONSTRAINT_DIAGNOSTICS& aDiag );

    void removeConstraint( PCB_CONSTRAINT* aConstraint );

    PCB_CONSTRAINT* resolveConstraint( const KIID& aId ) const;

    void editConstraint( PCB_CONSTRAINT* aConstraint );

    bool allMembersLocked( const PCB_CONSTRAINT* aConstraint ) const;

    bool isDuplicateConstraint( const PCB_CONSTRAINT* aConstraint ) const;
 
private:
    PCB_SELECTION_TOOL*                          m_selectionTool;
    CONDITIONAL_MENU*                            m_menu;
    std::unique_ptr<CONSTRAINT_OVERLAY>          m_overlay;
    BOARD_CONSTRAINT_DIAGNOSTICS                 m_cachedDiag;       

    BOARD_CONSTRAINT_DIAGNOSER                   m_diagnoser;
    bool                                         m_diagDirty = true;
    std::optional<std::vector<PCB_SHAPE*>>       m_hoverCandidates;  

    std::map<PCB_CONSTRAINT_TYPE, double>        m_lastConstraintValue;
    std::map<PCB_CONSTRAINT_TYPE, bool>          m_lastConstraintDriving;
};
 
#endif // CONSTRAINT_EDIT_TOOL_H_