sch_move_tool.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019 CERN
 * 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 KICAD_SCH_MOVE_TOOL_H
#define KICAD_SCH_MOVE_TOOL_H
 
#include <tools/sch_tool_base.h>
#include <sch_base_frame.h>
#include <unordered_map>
#include <unordered_set>
 
 
class SCH_EDIT_FRAME;
class SCH_SELECTION_TOOL;
class SCH_LINE;
class SCH_LABEL_BASE;
class SCH_SHEET_PIN;
class SCH_JUNCTION;
class SCH_SELECTION;
class SCH_SHEET;
class SCH_COMMIT;
class SCH_ITEM;
class EE_GRID_HELPER;
 
enum GRID_HELPER_GRIDS : int;
 
 
struct SPECIAL_CASE_LABEL_INFO
{
    SCH_LINE* attachedLine;
    VECTOR2I  originalLabelPos;
    VECTOR2I  originalLineStart;
    VECTOR2I  originalLineEnd;
    bool      trackMovingEnd = false;
};
 
 
class SCH_MOVE_TOOL : public SCH_TOOL_BASE<SCH_EDIT_FRAME>
{
public:
    enum MOVE_MODE
    {
        MOVE,
        DRAG,
        BREAK,
        SLICE
    };
 
    SCH_MOVE_TOOL();
    ~SCH_MOVE_TOOL() override { }

    bool Init() override;

    void Reset( RESET_REASON aReason ) override;

    int Main( const TOOL_EVENT& aEvent );

    int AlignToGrid( const TOOL_EVENT& aEvent );
 
private:
    bool doMoveSelection( const TOOL_EVENT& aEvent, SCH_COMMIT* aCommit );
 
    void moveItem( EDA_ITEM* aItem, const VECTOR2I& aDelta );

    void getConnectedItems( SCH_ITEM* aOriginalItem, const VECTOR2I& aPoint, EDA_ITEMS& aList );
    void getConnectedDragItems( SCH_COMMIT* aCommit, SCH_ITEM* fixed, const VECTOR2I& selected,
                                EDA_ITEMS& aList );
 
    void orthoLineDrag( SCH_COMMIT* aCommit, SCH_LINE* line, const VECTOR2I& splitDelta,
                        int& xBendCount, int& yBendCount, const EE_GRID_HELPER& grid );
 
    void moveSelectionToSheet( SCH_SELECTION& aSelection, SCH_SHEET* aTarget, SCH_COMMIT* aCommit );

    void clearNewDragLines();

    void setTransitions() override;

    void trimDanglingLines( SCH_COMMIT* aCommit );

    void preprocessBreakOrSliceSelection( SCH_COMMIT* aCommit, const TOOL_EVENT& aEvent );
 
    // Helper methods for doMoveSelection refactoring
    SCH_SELECTION& prepareSelection( bool& aUnselect );

    void refreshSelectionTraits( const SCH_SELECTION& aSelection, bool& aHasSheetPins,
                                 bool& aHasGraphicItems, bool& aHasNonGraphicItems,
                                 bool& aIsGraphicsOnly );

    void restartMoveOperation( const TOOL_EVENT& aEvent, SCH_SELECTION& aSelection, SCH_COMMIT* aCommit,
                               std::vector<DANGLING_END_ITEM>& aInternalPoints, GRID_HELPER_GRIDS& aSnapLayer );

    void prepareMoveOperation( SCH_SELECTION& aSelection, SCH_COMMIT* aCommit,
                               std::vector<DANGLING_END_ITEM>& aInternalPoints, GRID_HELPER_GRIDS& aSnapLayer );

    void startMoveOperation( SCH_SELECTION& aSelection, SCH_COMMIT* aCommit,
                             std::vector<DANGLING_END_ITEM>& aInternalPoints, GRID_HELPER_GRIDS& aSnapLayer );

    void setupItemsForDrag( SCH_SELECTION& aSelection, SCH_COMMIT* aCommit );

    void setupItemsForMove( SCH_SELECTION& aSelection,
                            std::vector<DANGLING_END_ITEM>& aInternalPoints );

    SCH_SHEET* findTargetSheet( const SCH_SELECTION& aSelection, const VECTOR2I& aCursorPos,
                                bool aHasSheetPins, bool aIsGraphicsOnly, bool aCtrlDown );

    bool dropWouldRecurse( const SCH_SELECTION& aSelection, const SCH_SHEET* aTargetSheet );

    void performItemMove( SCH_SELECTION& aSelection, const VECTOR2I& aDelta,
                          SCH_COMMIT* aCommit, int& aXBendCount, int& aYBendCount,
                          const EE_GRID_HELPER& aGrid );

    void spreadMovingSheetPinGroups( const SCH_SELECTION& aSelection );

    bool handleMoveToolActions( const TOOL_EVENT* aEvent, SCH_COMMIT* aCommit,
                                const SCH_SELECTION& aSelection );

    void updateStoredPositions( const SCH_SELECTION& aSelection );

    void recordRedundantJunctions( SCH_SELECTION& aSelection );

    void migrateHiddenJunctions( SCH_COMMIT* aCommit );

    void finalizeMoveOperation( SCH_SELECTION& aSelection, SCH_COMMIT* aCommit, bool aUnselect,
                                const std::vector<DANGLING_END_ITEM>& aInternalPoints );
 
private:
    bool                  m_inMoveTool;

    bool                  m_moveInProgress;
    MOVE_MODE             m_mode;

    std::vector<KIID>                   m_dragAdditions;

    std::map<SCH_LINE*, EDA_ITEMS>      m_lineConnectionCache;

    std::unordered_set<SCH_LINE*>       m_newDragLines;

    std::unordered_set<SCH_LINE*>       m_changedDragLines;

    struct HIDDEN_JUNCTION
    {
        SCH_JUNCTION* m_junction;
        KIID          m_lineId;
        bool          m_atLineStart;
    };
 
    std::vector<HIDDEN_JUNCTION> m_hiddenJunctions;
 
    VECTOR2I              m_moveOffset;

    VECTOR2I              m_cursor;
 
    OPT_VECTOR2I          m_anchorPos;
    OPT_VECTOR2I          m_breakPos;
 
    // A map of labels to scaling factors.  Used to scale the movement vector for labels that
    // are attached to wires which have only one end moving.
    std::map<SCH_LABEL_BASE*, SPECIAL_CASE_LABEL_INFO> m_specialCaseLabels;
 
    // A map of sheet pins to the line-endings (true == start) they're connected to.  Sheet
    // pins are constrained in their movement so their attached lines must be too.
    std::map<SCH_SHEET_PIN*, std::pair<SCH_LINE*, bool>> m_specialCaseSheetPins;
 
    // Each dragged sheet pin's distance along its sheet border at drag start.
    std::map<SCH_SHEET_PIN*, long long> m_sheetPinDragArc;
};
 
#endif //KICAD_SCH_MOVE_TOOL_H