/* * This program source code file is part of KiCad, a free EDA CAD application. * * Copyright (C) 2013-2017 CERN * Copyright (C) 2017-2021 KiCad Developers, see AUTHORS.txt for contributors. * @author Maciej Suminski * @author Tomasz Wlostowski * * 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, you may find one here: * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html * or you may search the http://www.gnu.org website for the version 2 license, * or you may write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std::placeholders; #include "kicad_clipboard.h" #include #include #include #include #include #include #include #include #include EDIT_TOOL::EDIT_TOOL() : PCB_TOOL_BASE( "pcbnew.InteractiveEdit" ), m_selectionTool( nullptr ), m_dragging( false ) { } void EDIT_TOOL::Reset( RESET_REASON aReason ) { m_dragging = false; m_statusPopup = std::make_unique( getEditFrame() ); if( aReason != RUN ) m_commit.reset( new BOARD_COMMIT( this ) ); } SPECIAL_TOOLS_CONTEXT_MENU::SPECIAL_TOOLS_CONTEXT_MENU( TOOL_INTERACTIVE* aTool ) : CONDITIONAL_MENU( aTool ) { SetIcon( BITMAPS::special_tools ); SetTitle( _( "Special Tools" ) ); AddItem( PCB_ACTIONS::moveExact, SELECTION_CONDITIONS::ShowAlways ); AddItem( PCB_ACTIONS::moveWithReference, SELECTION_CONDITIONS::ShowAlways ); AddItem( PCB_ACTIONS::positionRelative, SELECTION_CONDITIONS::ShowAlways ); AddItem( PCB_ACTIONS::createArray, SELECTION_CONDITIONS::ShowAlways ); } bool EDIT_TOOL::Init() { // Find the selection tool, so they can cooperate m_selectionTool = m_toolMgr->GetTool(); auto propertiesCondition = [&]( const SELECTION& aSel ) { if( aSel.GetSize() == 0 ) { if( getView()->IsLayerVisible( LAYER_SCHEMATIC_DRAWINGSHEET ) ) { DS_PROXY_VIEW_ITEM* ds = frame()->GetCanvas()->GetDrawingSheet(); VECTOR2D cursor = getViewControls()->GetCursorPosition( false ); if( ds && ds->HitTestDrawingSheetItems( getView(), (wxPoint) cursor ) ) return true; } return false; } if( aSel.GetSize() == 1 ) return true; for( EDA_ITEM* item : aSel ) { if( !dynamic_cast( item ) ) return false; } return true; }; auto inFootprintEditor = [ this ]( const SELECTION& aSelection ) { return m_isFootprintEditor; }; auto singleFootprintCondition = SELECTION_CONDITIONS::OnlyType( PCB_FOOTPRINT_T ) && SELECTION_CONDITIONS::Count( 1 ); auto noActiveToolCondition = [ this ]( const SELECTION& aSelection ) { return frame()->ToolStackIsEmpty(); }; auto notMovingCondition = [ this ]( const SELECTION& aSelection ) { return !frame()->IsCurrentTool( PCB_ACTIONS::move ) && !frame()->IsCurrentTool( PCB_ACTIONS::moveWithReference ); }; auto noItemsCondition = [ this ]( const SELECTION& aSelections ) -> bool { return frame()->GetBoard() && !frame()->GetBoard()->IsEmpty(); }; // Add context menu entries that are displayed when selection tool is active CONDITIONAL_MENU& menu = m_selectionTool->GetToolMenu().GetMenu(); menu.AddItem( PCB_ACTIONS::move, SELECTION_CONDITIONS::NotEmpty && notMovingCondition ); menu.AddItem( PCB_ACTIONS::breakTrack, SELECTION_CONDITIONS::Count( 1 ) && SELECTION_CONDITIONS::OnlyTypes( GENERAL_COLLECTOR::Tracks ) ); menu.AddItem( PCB_ACTIONS::drag45Degree, SELECTION_CONDITIONS::Count( 1 ) && SELECTION_CONDITIONS::OnlyTypes( GENERAL_COLLECTOR::DraggableItems ) ); menu.AddItem( PCB_ACTIONS::dragFreeAngle, SELECTION_CONDITIONS::Count( 1 ) && SELECTION_CONDITIONS::OnlyTypes( GENERAL_COLLECTOR::DraggableItems ) && !SELECTION_CONDITIONS::OnlyType( PCB_FOOTPRINT_T ) ); menu.AddItem( PCB_ACTIONS::filletTracks, SELECTION_CONDITIONS::OnlyTypes( GENERAL_COLLECTOR::Tracks ) ); menu.AddItem( PCB_ACTIONS::rotateCcw, SELECTION_CONDITIONS::NotEmpty ); menu.AddItem( PCB_ACTIONS::rotateCw, SELECTION_CONDITIONS::NotEmpty ); menu.AddItem( PCB_ACTIONS::flip, SELECTION_CONDITIONS::NotEmpty ); menu.AddItem( PCB_ACTIONS::mirror, inFootprintEditor && SELECTION_CONDITIONS::NotEmpty ); menu.AddItem( PCB_ACTIONS::properties, propertiesCondition ); // Footprint actions menu.AddSeparator(); menu.AddItem( PCB_ACTIONS::editFpInFpEditor, singleFootprintCondition ); menu.AddItem( PCB_ACTIONS::updateFootprint, singleFootprintCondition ); menu.AddItem( PCB_ACTIONS::changeFootprint, singleFootprintCondition ); // Add the submenu for create array and special move auto specialToolsSubMenu = std::make_shared( this ); menu.AddSeparator(); m_selectionTool->GetToolMenu().AddSubMenu( specialToolsSubMenu ); menu.AddMenu( specialToolsSubMenu.get(), SELECTION_CONDITIONS::NotEmpty, 100 ); menu.AddSeparator( 150 ); menu.AddItem( ACTIONS::cut, SELECTION_CONDITIONS::NotEmpty, 150 ); menu.AddItem( ACTIONS::copy, SELECTION_CONDITIONS::NotEmpty, 150 ); // Selection tool handles the context menu for some other tools, such as the Picker. // Don't add things like Paste when another tool is active. menu.AddItem( ACTIONS::paste, noActiveToolCondition, 150 ); menu.AddItem( ACTIONS::pasteSpecial, noActiveToolCondition && !inFootprintEditor, 150 ); menu.AddItem( ACTIONS::duplicate, SELECTION_CONDITIONS::NotEmpty, 150 ); menu.AddItem( ACTIONS::doDelete, SELECTION_CONDITIONS::NotEmpty, 150 ); menu.AddSeparator( 150 ); menu.AddItem( ACTIONS::selectAll, noItemsCondition, 150 ); return true; } int EDIT_TOOL::GetAndPlace( const TOOL_EVENT& aEvent ) { // GetAndPlace makes sense only in board editor, although it is also called // in fpeditor, that shares the same EDIT_TOOL list if( !getEditFrame()->IsType( FRAME_PCB_EDITOR ) ) return 0; PCB_SELECTION_TOOL* selectionTool = m_toolMgr->GetTool(); FOOTPRINT* fp = getEditFrame()->GetFootprintFromBoardByReference(); if( fp ) { m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, (void*) fp ); selectionTool->GetSelection().SetReferencePoint( fp->GetPosition() ); m_toolMgr->RunAction( PCB_ACTIONS::move, false ); } return 0; } bool EDIT_TOOL::invokeInlineRouter( int aDragMode ) { ROUTER_TOOL* theRouter = m_toolMgr->GetTool(); if( !theRouter ) return false; // don't allow switch from moving to dragging if( m_dragging ) { wxBell(); return false; } // make sure we don't accidentally invoke inline routing mode while the router is already // active! if( theRouter->IsToolActive() ) return false; if( theRouter->CanInlineDrag( aDragMode ) ) { m_toolMgr->RunAction( PCB_ACTIONS::routerInlineDrag, true, static_cast( aDragMode ) ); return true; } return false; } bool EDIT_TOOL::isRouterActive() const { ROUTER_TOOL* router = m_toolMgr->GetTool(); return router && router->RoutingInProgress(); } int EDIT_TOOL::Drag( const TOOL_EVENT& aEvent ) { if( !m_toolMgr->GetTool() ) return false; // don't drag when no router tool (i.e. fp editor) if( m_toolMgr->GetTool()->IsToolActive() ) return false; // don't drag when router is already active int mode = PNS::DM_ANY; if( aEvent.IsAction( &PCB_ACTIONS::dragFreeAngle ) ) mode |= PNS::DM_FREE_ANGLE; PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForFreePads( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); if( aCollector.GetCount() > 1 ) sTool->GuessSelectionCandidates( aCollector, aPt ); // If we have a knee between two segments, or a via attached to two segments, // then drop the selection to a single item. static KICAD_T trackTypes[] = { PCB_VIA_T, PCB_TRACE_T, PCB_ARC_T, EOT }; std::vector tracks; std::vector vias; for( EDA_ITEM* item : aCollector ) { if( item->IsType( trackTypes ) ) tracks.push_back( static_cast( item ) ); else if( item->Type() == PCB_VIA_T ) vias.push_back( static_cast( item ) ); } if( tracks.size() == 2 ) { const BOARD* board = tracks[0]->GetBoard(); std::shared_ptr c = board->GetConnectivity(); std::vector cItems; int accuracy = KiROUND( 5 * aCollector.GetGuide()->OnePixelInIU() ); if( vias.size() == 1 ) { cItems = c->GetConnectedItemsAtAnchor( vias[0], aPt, trackTypes, vias[0]->GetWidth() / 2 + accuracy ); if( alg::contains( cItems, tracks[0] ) && alg::contains( cItems, tracks[1] ) ) { aCollector.Remove( tracks[0] ); aCollector.Remove( tracks[1] ); } } else if( vias.size() == 0 ) { cItems = c->GetConnectedItemsAtAnchor( tracks[0], aPt, trackTypes, tracks[0]->GetWidth() / 2 + accuracy ); if( alg::contains( cItems, tracks[1] ) ) aCollector.Remove( tracks[1] ); } } }, true /* prompt user regarding locked items */ ); if( selection.Empty() ) return 0; if( selection.Size() == 1 && selection.Front()->Type() == PCB_ARC_T ) { // TODO: This really should be done in PNS to ensure DRC is maintained, but for now // it allows interactive editing of an arc track return DragArcTrack( aEvent ); } else { invokeInlineRouter( mode ); } return 0; } int EDIT_TOOL::DragArcTrack( const TOOL_EVENT& aEvent ) { PCB_SELECTION& selection = m_selectionTool->GetSelection(); if( selection.Size() != 1 || selection.Front()->Type() != PCB_ARC_T ) return 0; PCB_ARC* theArc = static_cast( selection.Front() ); double arcAngleDegrees = std::abs( theArc->GetAngle() ) / 10.0; if( arcAngleDegrees + ADVANCED_CFG::GetCfg().m_MaxTangentAngleDeviation >= 180.0 ) { frame()->ShowInfoBarError( wxString::Format( _( "Unable to resize arc tracks %.1f degrees or greater." ), 180.0 - ADVANCED_CFG::GetCfg().m_MaxTangentAngleDeviation ) ); return 0; // don't bother with > 180 degree arcs } KIGFX::VIEW_CONTROLS* controls = getViewControls(); Activate(); // Must be done after Activate() so that it gets set into the correct context controls->ShowCursor( true ); controls->SetAutoPan( true ); bool restore_state = false; VECTOR2I arcCenter = theArc->GetCenter(); SEG tanStart = SEG( arcCenter, theArc->GetStart() ).PerpendicularSeg( theArc->GetStart() ); SEG tanEnd = SEG( arcCenter, theArc->GetEnd() ).PerpendicularSeg( theArc->GetEnd() ); //Ensure the tangent segments are in the correct orientation VECTOR2I tanIntersect = tanStart.IntersectLines( tanEnd ).get(); tanStart.A = tanIntersect; tanStart.B = theArc->GetStart(); tanEnd.A = tanIntersect; tanEnd.B = theArc->GetEnd(); KICAD_T track_types[] = { PCB_PAD_T, PCB_VIA_T, PCB_TRACE_T, PCB_ARC_T, EOT }; auto getUniqueTrackAtAnchorCollinear = [&]( const VECTOR2I& aAnchor, const SEG& aCollinearSeg ) -> PCB_TRACK* { auto conn = board()->GetConnectivity(); // Allow items at a distance within the width of the arc track int allowedDeviation = theArc->GetWidth(); std::vector itemsOnAnchor; for( int i = 0; i < 3; i++ ) { itemsOnAnchor = conn->GetConnectedItemsAtAnchor( theArc, aAnchor, track_types, allowedDeviation ); allowedDeviation /= 2; if( itemsOnAnchor.size() == 1 ) break; } PCB_TRACK* retval = nullptr; if( itemsOnAnchor.size() == 1 && itemsOnAnchor.front()->Type() == PCB_TRACE_T ) { retval = static_cast( itemsOnAnchor.front() ); SEG trackSeg( retval->GetStart(), retval->GetEnd() ); // Allow deviations in colinearity as defined in ADVANCED_CFG if( trackSeg.AngleDegrees( aCollinearSeg ) > ADVANCED_CFG::GetCfg().m_MaxTangentAngleDeviation ) { retval = nullptr; } } if( !retval ) { retval = new PCB_TRACK( theArc->GetParent() ); retval->SetStart( (wxPoint) aAnchor ); retval->SetEnd( (wxPoint) aAnchor ); retval->SetNet( theArc->GetNet() ); retval->SetLayer( theArc->GetLayer() ); retval->SetWidth( theArc->GetWidth() ); retval->SetLocked( theArc->IsLocked() ); retval->SetFlags( IS_NEW ); getView()->Add( retval ); } return retval; }; PCB_TRACK* trackOnStart = getUniqueTrackAtAnchorCollinear( theArc->GetStart(), tanStart); PCB_TRACK* trackOnEnd = getUniqueTrackAtAnchorCollinear( theArc->GetEnd(), tanEnd ); // Make copies of items to be edited PCB_ARC* theArcCopy = new PCB_ARC( *theArc ); PCB_TRACK* trackOnStartCopy = new PCB_TRACK( *trackOnStart ); PCB_TRACK* trackOnEndCopy = new PCB_TRACK( *trackOnEnd ); if( trackOnStart->GetLength() != 0 ) { tanStart.A = trackOnStart->GetStart(); tanStart.B = trackOnStart->GetEnd(); } if( trackOnEnd->GetLength() != 0 ) { tanEnd.A = trackOnEnd->GetStart(); tanEnd.B = trackOnEnd->GetEnd(); } // Recalculate intersection point tanIntersect = tanStart.IntersectLines( tanEnd ).get(); auto isTrackStartClosestToArcStart = [&]( PCB_TRACK* aTrack ) -> bool { double trackStartToArcStart = GetLineLength( aTrack->GetStart(), theArc->GetStart() ); double trackEndToArcStart = GetLineLength( aTrack->GetEnd(), theArc->GetStart() ); return trackStartToArcStart < trackEndToArcStart; }; bool isStartTrackOnStartPt = isTrackStartClosestToArcStart( trackOnStart ); bool isEndTrackOnStartPt = isTrackStartClosestToArcStart( trackOnEnd ); // Calculate constraints //====================== // maxTanCircle is the circle with maximum radius that is tangent to the two adjacent straight // tracks and whose tangent points are constrained within the original tracks and their // projected intersection points. // // The cursor will be constrained first within the isosceles triangle formed by the segments // cSegTanStart, cSegTanEnd and cSegChord. After that it will be constrained to be outside // maxTanCircle. // // // ____________ <-cSegTanStart // / * . ' * // cSegTanEnd-> / * . ' * // /* . ' <-cSegChord * // /. ' // /* * // // * c * <-maxTanCircle // // * * // // * * // * * // * * // auto getFurthestPointToTanInterstect = [&]( VECTOR2I& aPointA, VECTOR2I& aPointB ) -> VECTOR2I { if( ( aPointA - tanIntersect ).EuclideanNorm() > ( aPointB - tanIntersect ).EuclideanNorm() ) { return aPointA; } else { return aPointB; } }; CIRCLE maxTanCircle; VECTOR2I tanStartPoint = getFurthestPointToTanInterstect( tanStart.A, tanStart.B ); VECTOR2I tanEndPoint = getFurthestPointToTanInterstect( tanEnd.A, tanEnd.B ); VECTOR2I tempTangentPoint = tanEndPoint; if( getFurthestPointToTanInterstect( tanStartPoint, tanEndPoint ) == tanEndPoint ) tempTangentPoint = tanStartPoint; maxTanCircle.ConstructFromTanTanPt( tanStart, tanEnd, tempTangentPoint ); VECTOR2I maxTanPtStart = tanStart.LineProject( maxTanCircle.Center ); VECTOR2I maxTanPtEnd = tanEnd.LineProject( maxTanCircle.Center ); SEG cSegTanStart( maxTanPtStart, tanIntersect ); SEG cSegTanEnd( maxTanPtEnd, tanIntersect ); SEG cSegChord( maxTanPtStart, maxTanPtEnd ); int cSegTanStartSide = cSegTanStart.Side( theArc->GetMid() ); int cSegTanEndSide = cSegTanEnd.Side( theArc->GetMid() ); int cSegChordSide = cSegChord.Side( theArc->GetMid() ); bool eatFirstMouseUp = true; // Start the tool loop while( TOOL_EVENT* evt = Wait() ) { m_cursor = controls->GetMousePosition(); // Constrain cursor within the isosceles triangle if( cSegTanStartSide != cSegTanStart.Side( m_cursor ) || cSegTanEndSide != cSegTanEnd.Side( m_cursor ) || cSegChordSide != cSegChord.Side( m_cursor ) ) { std::vector possiblePoints; possiblePoints.push_back( cSegTanEnd.NearestPoint( m_cursor ) ); possiblePoints.push_back( cSegChord.NearestPoint( m_cursor ) ); VECTOR2I closest = cSegTanStart.NearestPoint( m_cursor ); for( VECTOR2I candidate : possiblePoints ) { if( ( candidate - m_cursor ).SquaredEuclideanNorm() < ( closest - m_cursor ).SquaredEuclideanNorm() ) { closest = candidate; } } m_cursor = closest; } // Constrain cursor to be outside maxTanCircle if( ( m_cursor - maxTanCircle.Center ).EuclideanNorm() < maxTanCircle.Radius ) m_cursor = maxTanCircle.NearestPoint( m_cursor ); controls->ForceCursorPosition( true, m_cursor ); // Calculate resulting object coordinates CIRCLE circlehelper; circlehelper.ConstructFromTanTanPt( cSegTanStart, cSegTanEnd, m_cursor ); VECTOR2I newCenter = circlehelper.Center; VECTOR2I newStart = cSegTanStart.LineProject( newCenter ); VECTOR2I newEnd = cSegTanEnd.LineProject( newCenter ); VECTOR2I newMid = CalcArcMid( newStart, newEnd, newCenter ); // Update objects theArc->SetStart( (wxPoint) newStart ); theArc->SetEnd( (wxPoint) newEnd ); theArc->SetMid( (wxPoint) newMid ); if( isStartTrackOnStartPt ) trackOnStart->SetStart( (wxPoint) newStart ); else trackOnStart->SetEnd( (wxPoint) newStart ); if( isEndTrackOnStartPt ) trackOnEnd->SetStart( (wxPoint) newEnd ); else trackOnEnd->SetEnd( (wxPoint) newEnd ); // Update view getView()->Update( trackOnStart ); getView()->Update( trackOnEnd ); getView()->Update( theArc ); // Handle events if( evt->IsMotion() || evt->IsDrag( BUT_LEFT ) ) { eatFirstMouseUp = false; } else if( evt->IsCancelInteractive() || evt->IsActivate() ) { restore_state = true; // Canceling the tool means that items have to be restored break; // Finish } else if( evt->IsAction( &ACTIONS::undo ) ) { restore_state = true; // Perform undo locally break; // Finish } else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) || evt->IsDblClick( BUT_LEFT ) ) { // Eat mouse-up/-click events that leaked through from the lock dialog if( eatFirstMouseUp && evt->Parameter() != ACTIONS::CURSOR_CLICK ) { eatFirstMouseUp = false; continue; } break; // Finish } } // Ensure we only do one commit operation on each object auto processTrack = [&]( PCB_TRACK* aTrack, PCB_TRACK* aTrackCopy, int aMaxLengthIU ) -> bool { if( aTrack->IsNew() ) { getView()->Remove( aTrack ); if( aTrack->GetLength() <= aMaxLengthIU ) { delete aTrack; delete aTrackCopy; aTrack = nullptr; aTrackCopy = nullptr; return false; } else { m_commit->Add( aTrack ); delete aTrackCopy; aTrackCopy = nullptr; return true; } } else if( aTrack->GetLength() <= aMaxLengthIU ) { aTrack->SwapData( aTrackCopy ); //restore the original before notifying COMMIT m_commit->Remove( aTrack ); delete aTrackCopy; aTrackCopy = nullptr; return false; } else { m_commit->Modified( aTrack, aTrackCopy ); } return true; }; // Amend the end points of the arc if we delete the joining tracks wxPoint newStart = trackOnStart->GetStart(); wxPoint newEnd = trackOnEnd->GetStart(); if( isStartTrackOnStartPt ) newStart = trackOnStart->GetEnd(); if( isEndTrackOnStartPt ) newEnd = trackOnEnd->GetEnd(); int maxLengthIU = KiROUND( ADVANCED_CFG::GetCfg().m_MaxTrackLengthToKeep * IU_PER_MM ); if( !processTrack( trackOnStart, trackOnStartCopy, maxLengthIU ) ) theArc->SetStart( newStart ); if( !processTrack( trackOnEnd, trackOnEndCopy, maxLengthIU ) ) theArc->SetEnd( newEnd ); processTrack( theArc, theArcCopy, 0 ); // only delete the arc if start and end points coincide // Should we commit? if( restore_state ) m_commit->Revert(); else m_commit->Push( _( "Drag Arc Track" ) ); return 0; } int EDIT_TOOL::Move( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } return doMoveSelection( aEvent ); } int EDIT_TOOL::MoveWithReference( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } return doMoveSelection( aEvent, true ); } // Note: aEvent MUST NOT be const&; the source will get de-allocated if we go into the picker's // event loop. int EDIT_TOOL::doMoveSelection( TOOL_EVENT aEvent, bool aPickReference ) { PCB_BASE_EDIT_FRAME* editFrame = getEditFrame(); KIGFX::VIEW_CONTROLS* controls = getViewControls(); VECTOR2I originalCursorPos = controls->GetCursorPosition(); // Be sure that there is at least one item that we can modify. If nothing was selected before, // try looking for the stuff under mouse cursor (i.e. KiCad old-style hover selection) PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); }, // Prompt user regarding locked items if in board editor and in free-pad-mode (if // we're not in free-pad mode we delay this until the second RequestSelection()). frame()->Settings().m_AllowFreePads && !m_isFootprintEditor ); if( m_dragging || selection.Empty() ) return 0; LSET item_layers = selection.GetSelectionLayers(); bool is_hover = selection.IsHover(); // N.B. This must be saved before the second call // to RequestSelection() below VECTOR2I pickedReferencePoint; // Now filter out pads if not in free pads mode. We cannot do this in the first // RequestSelection() as we need the item_layers when a pad is the selection front. if( !m_isFootprintEditor && !frame()->Settings().m_AllowFreePads ) { selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); sTool->FilterCollectorForFreePads( aCollector ); }, true /* prompt user regarding locked items */ ); } if( selection.Empty() ) return 0; std::string tool = aEvent.GetCommandStr().get(); editFrame->PushTool( tool ); Activate(); // Must be done after Activate() so that it gets set into the correct context controls->ShowCursor( true ); controls->SetAutoPan( true ); if( aPickReference && !pickReferencePoint( _( "Select reference point for move..." ), "", "", pickedReferencePoint ) ) { if( is_hover ) m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); editFrame->PopTool( tool ); return 0; } auto displayConstraintsMessage = [editFrame]( bool constrained ) { editFrame->DisplayConstraintsMsg( constrained ? _( "Constrain to H, V, 45" ) : wxT( "" ) ); }; std::vector sel_items; // All the items operated on by the move below std::vector orig_items; // All the original items in the selection for( EDA_ITEM* item : selection ) { BOARD_ITEM* boardItem = dynamic_cast( item ); FOOTPRINT* footprint = dynamic_cast( item ); if( boardItem ) { if( !is_hover ) orig_items.push_back( boardItem ); sel_items.push_back( boardItem ); } if( footprint ) { for( PAD* pad : footprint->Pads() ) sel_items.push_back( pad ); // Clear this flag here; it will be set by the netlist updater if the footprint is new // so that it was skipped in the initial connectivity update in OnNetlistChanged footprint->SetAttributes( footprint->GetAttributes() & ~FP_JUST_ADDED ); } } bool restore_state = false; VECTOR2I originalPos; VECTOR2I totalMovement; PCB_GRID_HELPER grid( m_toolMgr, editFrame->GetMagneticItemsSettings() ); TOOL_EVENT* evt = &aEvent; VECTOR2I prevPos; bool lock45 = false; bool eatFirstMouseUp = true; bool hasRedrawn3D = false; bool allowRedraw3D = editFrame->GetDisplayOptions().m_Live3DRefresh; displayConstraintsMessage( lock45 ); // Prime the pump m_toolMgr->RunAction( ACTIONS::refreshPreview ); // Main loop: keep receiving events do { VECTOR2I movement; editFrame->GetCanvas()->SetCurrentCursor( KICURSOR::MOVING ); grid.SetSnap( !evt->Modifier( MD_SHIFT ) ); grid.SetUseGrid( getView()->GetGAL()->GetGridSnapping() && !evt->DisableGridSnapping() ); if( evt->IsMotion() || evt->IsDrag( BUT_LEFT ) ) eatFirstMouseUp = false; if( evt->IsAction( &PCB_ACTIONS::move ) || evt->IsMotion() || evt->IsDrag( BUT_LEFT ) || evt->IsAction( &ACTIONS::refreshPreview ) || evt->IsAction( &PCB_ACTIONS::moveWithReference ) ) { if( m_dragging && evt->Category() == TC_MOUSE ) { bool redraw3D = false; VECTOR2I mousePos( controls->GetMousePosition() ); m_cursor = grid.BestSnapAnchor( mousePos, item_layers, sel_items ); if( controls->GetSettings().m_lastKeyboardCursorPositionValid ) { long action = controls->GetSettings().m_lastKeyboardCursorCommand; // The arrow keys are by definition SINGLE AXIS. Do not allow the other // axis to be snapped to the grid. if( action == ACTIONS::CURSOR_LEFT || action == ACTIONS::CURSOR_RIGHT ) m_cursor.y = prevPos.y; else if( action == ACTIONS::CURSOR_UP || action == ACTIONS::CURSOR_DOWN ) m_cursor.x = prevPos.x; } if( !selection.HasReferencePoint() ) originalPos = m_cursor; if( lock45 ) { VECTOR2I moveVector = m_cursor - originalPos; m_cursor = originalPos + GetVectorSnapped45( moveVector ); } controls->ForceCursorPosition( true, m_cursor ); selection.SetReferencePoint( m_cursor ); movement = m_cursor - prevPos; prevPos = m_cursor; totalMovement += movement; // Drag items to the current cursor position for( EDA_ITEM* item : sel_items ) { // Don't double move footprint pads, fields, etc. // // For PCB_GROUP_T, we make sure the selection includes only the top level // group and not its descendants. if( !item->GetParent() || !item->GetParent()->IsSelected() ) static_cast( item )->Move( movement ); if( !redraw3D && item->Type() == PCB_FOOTPRINT_T ) redraw3D = true; } if( redraw3D && allowRedraw3D ) { editFrame->Update3DView( false, true ); hasRedrawn3D = true; } m_toolMgr->PostEvent( EVENTS::SelectedItemsMoved ); } else if( !m_dragging && !evt->IsAction( &ACTIONS::refreshPreview ) ) { // Prepare to start dragging if( !( evt->IsAction( &PCB_ACTIONS::move ) || evt->IsAction( &PCB_ACTIONS::moveWithReference ) ) && ( editFrame->Settings().m_TrackDragAction != TRACK_DRAG_ACTION::MOVE ) ) { if( invokeInlineRouter( PNS::DM_ANY ) ) break; } m_dragging = true; // When editing footprints, all items have the same parent if( IsFootprintEditor() ) { m_commit->Modify( selection.Front() ); } else { // Save items, so changes can be undone for( EDA_ITEM* item : selection ) { // Don't double move footprint pads, fields, etc. // // For PCB_GROUP_T, the parent is the board. if( item->GetParent() && item->GetParent()->IsSelected() ) continue; m_commit->Modify( item ); // If moving a group, record position of all the descendants for undo if( item->Type() == PCB_GROUP_T ) { PCB_GROUP* group = static_cast( item ); group->RunOnDescendants( [&]( BOARD_ITEM* bItem ) { m_commit->Modify( bItem ); }); } } } editFrame->UndoRedoBlock( true ); m_cursor = controls->GetCursorPosition(); if( selection.HasReferencePoint() ) { // start moving with the reference point attached to the cursor grid.SetAuxAxes( false ); if( lock45 ) { VECTOR2I moveVector = m_cursor - originalPos; m_cursor = originalPos + GetVectorSnapped45( moveVector ); } movement = m_cursor - selection.GetReferencePoint(); // Drag items to the current cursor position for( EDA_ITEM* item : selection ) { // Don't double move footprint pads, fields, etc. if( item->GetParent() && item->GetParent()->IsSelected() ) continue; static_cast( item )->Move( movement ); } selection.SetReferencePoint( m_cursor ); } else { std::vector items; for( EDA_ITEM* item : selection ) items.push_back( static_cast( item ) ); m_cursor = grid.BestDragOrigin( originalCursorPos, items ); // Set the current cursor position to the first dragged item origin, so the // movement vector could be computed later if( aPickReference ) { selection.SetReferencePoint( pickedReferencePoint ); controls->ForceCursorPosition( true, pickedReferencePoint ); m_cursor = pickedReferencePoint; } else { // Check if user wants to warp the mouse to origin of moved object if( !editFrame->GetMoveWarpsCursor() ) m_cursor = originalCursorPos; // No, so use original mouse pos instead selection.SetReferencePoint( m_cursor ); grid.SetAuxAxes( true, m_cursor ); } originalPos = m_cursor; } controls->SetCursorPosition( m_cursor, false ); prevPos = m_cursor; controls->SetAutoPan( true ); m_toolMgr->PostEvent( EVENTS::SelectedItemsModified ); } m_toolMgr->RunAction( PCB_ACTIONS::updateLocalRatsnest, false, new VECTOR2I( movement ) ); } else if( evt->IsCancelInteractive() || evt->IsActivate() ) { if( m_dragging && evt->IsCancelInteractive() ) evt->SetPassEvent( false ); restore_state = true; // Canceling the tool means that items have to be restored break; // Finish } else if( evt->IsAction( &ACTIONS::undo ) ) { restore_state = true; // Perform undo locally break; // Finish } else if( evt->IsAction( &ACTIONS::doDelete ) || evt->IsAction( &ACTIONS::cut ) ) { // Dispatch TOOL_ACTIONs evt->SetPassEvent(); break; // finish -- there is no further processing for removed items } else if( evt->IsAction( &ACTIONS::duplicate ) ) { evt->SetPassEvent(); break; // finish -- Duplicate tool will start a new Move with the dup'ed items } else if( evt->IsAction( &PCB_ACTIONS::rotateCw ) || evt->IsAction( &PCB_ACTIONS::rotateCcw ) || evt->IsAction( &PCB_ACTIONS::flip ) || evt->IsAction( &PCB_ACTIONS::mirror ) ) { eatFirstMouseUp = false; evt->SetPassEvent(); } else if( evt->IsAction( &PCB_ACTIONS::moveExact ) ) { // Reset positions so the Move Exactly is from the start. for( EDA_ITEM* item : selection ) { BOARD_ITEM* i = static_cast( item ); i->Move( -totalMovement ); } break; // finish -- we moved exactly, so we are finished } else if( evt->IsMouseUp( BUT_LEFT ) || evt->IsClick( BUT_LEFT ) ) { // Eat mouse-up/-click events that leaked through from the lock dialog if( eatFirstMouseUp && evt->Parameter() != ACTIONS::CURSOR_CLICK ) { eatFirstMouseUp = false; continue; } break; // finish } else if( evt->IsAction( &PCB_ACTIONS::toggle45 ) ) { lock45 = !lock45; displayConstraintsMessage( lock45 ); evt->SetPassEvent( false ); } else { evt->SetPassEvent(); } } while( ( evt = Wait() ) ); // Assignment (instead of equality test) is intentional controls->ForceCursorPosition( false ); controls->ShowCursor( false ); controls->SetAutoPan( false ); m_dragging = false; editFrame->UndoRedoBlock( false ); m_toolMgr->GetTool()->UpdateStatusBar(); if( hasRedrawn3D && restore_state ) editFrame->Update3DView( false, true ); // Discard reference point when selection is "dropped" onto the board selection.ClearReferencePoint(); // TODO: there's an encapsulation leak here: this commit often has more than just the move // in it; for instance it might have a paste, append board, etc. as well. if( restore_state ) m_commit->Revert(); else m_commit->Push( _( "Drag" ) ); // Remove the dynamic ratsnest from the screen m_toolMgr->RunAction( PCB_ACTIONS::hideDynamicRatsnest, true ); // Unselect all items to clear selection flags and then re-select the originally selected // items. m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); m_toolMgr->RunAction( PCB_ACTIONS::selectItems, true, &orig_items ); editFrame->PopTool( tool ); editFrame->GetCanvas()->SetCurrentCursor( KICURSOR::ARROW ); return restore_state ? -1 : 0; } int EDIT_TOOL::ChangeTrackWidth( const TOOL_EVENT& aEvent ) { const PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { // Iterate from the back so we don't have to worry about removals. for( int i = aCollector.GetCount() - 1; i >= 0; --i ) { BOARD_ITEM* item = aCollector[ i ]; if( !dynamic_cast( item ) ) aCollector.Remove( item ); } }, true /* prompt user regarding locked items */ ); for( EDA_ITEM* item : selection ) { if( item->Type() == PCB_VIA_T ) { PCB_VIA* via = static_cast( item ); m_commit->Modify( via ); int new_width; int new_drill; if( via->GetViaType() == VIATYPE::MICROVIA ) { NETCLASS* netClass = via->GetNetClass(); new_width = netClass->GetuViaDiameter(); new_drill = netClass->GetuViaDrill(); } else { new_width = board()->GetDesignSettings().GetCurrentViaSize(); new_drill = board()->GetDesignSettings().GetCurrentViaDrill(); } via->SetDrill( new_drill ); via->SetWidth( new_width ); } else if( item->Type() == PCB_TRACE_T || item->Type() == PCB_ARC_T ) { PCB_TRACK* track = dynamic_cast( item ); wxCHECK( track, 0 ); m_commit->Modify( track ); int new_width = board()->GetDesignSettings().GetCurrentTrackWidth(); track->SetWidth( new_width ); } } m_commit->Push( _("Edit track width/via size") ); if( selection.IsHover() ) { m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); // Notify other tools of the changes -- This updates the visual ratsnest m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); } return 0; } int EDIT_TOOL::FilletTracks( const TOOL_EVENT& aEvent ) { // Store last used fillet radius to allow pressing "enter" if repeat fillet is required static long long filletRadiusIU = 0; PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { // Iterate from the back so we don't have to worry about removals. for( int i = aCollector.GetCount() - 1; i >= 0; --i ) { BOARD_ITEM* item = aCollector[i]; if( !dynamic_cast( item ) ) aCollector.Remove( item ); } }, true /* prompt user regarding locked items */ ); if( selection.Size() < 2 ) { frame()->ShowInfoBarMsg( _( "At least two straight track segments must be selected." ) ); return 0; } WX_UNIT_ENTRY_DIALOG dia( frame(), _( "Enter fillet radius:" ), _( "Fillet Tracks" ), filletRadiusIU ); if( dia.ShowModal() == wxID_CANCEL ) return 0; filletRadiusIU = dia.GetValue(); if( filletRadiusIU == 0 ) { frame()->ShowInfoBarMsg( _( "A radius of zero was entered.\n" "The fillet operation was not performed." ) ); return 0; } struct FILLET_OP { PCB_TRACK* t1; PCB_TRACK* t2; // Start point of track is modified after PCB_ARC is added, otherwise the end point: bool t1Start = true; bool t2Start = true; }; std::vector filletOperations; KICAD_T track_types[] = { PCB_PAD_T, PCB_VIA_T, PCB_TRACE_T, PCB_ARC_T, EOT }; bool operationPerformedOnAtLeastOne = false; bool didOneAttemptFail = false; std::set processedTracks; for( auto it = selection.begin(); it != selection.end(); it++ ) { PCB_TRACK* track = dyn_cast( *it ); if( !track || track->Type() != PCB_TRACE_T || track->GetLength() == 0 ) { continue; } auto processFilletOp = [&]( bool aStartPoint ) { std::shared_ptr connectivity = board()->GetConnectivity(); wxPoint anchor = ( aStartPoint ) ? track->GetStart() : track->GetEnd(); auto itemsOnAnchor = connectivity->GetConnectedItemsAtAnchor( track, anchor, track_types ); if( itemsOnAnchor.size() > 0 && selection.Contains( itemsOnAnchor.at( 0 ) ) && itemsOnAnchor.at( 0 )->Type() == PCB_TRACE_T ) { PCB_TRACK* trackOther = dyn_cast( itemsOnAnchor.at( 0 ) ); // Make sure we don't fillet the same pair of tracks twice if( processedTracks.find( trackOther ) == processedTracks.end() ) { if( itemsOnAnchor.size() == 1 ) { FILLET_OP filletOp; filletOp.t1 = track; filletOp.t2 = trackOther; filletOp.t1Start = aStartPoint; filletOp.t2Start = track->IsPointOnEnds( filletOp.t2->GetStart() ); filletOperations.push_back( filletOp ); } else { // User requested to fillet these two tracks but not possible as // there are other elements connected at that point didOneAttemptFail = true; } } } }; processFilletOp( true ); // on the start point of track processFilletOp( false ); // on the end point of track processedTracks.insert( track ); } std::vector itemsToAddToSelection; for( FILLET_OP filletOp : filletOperations ) { PCB_TRACK* track1 = filletOp.t1; PCB_TRACK* track2 = filletOp.t2; bool trackOnStart = track1->IsPointOnEnds( track2->GetStart() ); bool trackOnEnd = track1->IsPointOnEnds( track2->GetEnd() ); if( trackOnStart && trackOnEnd ) continue; // Ignore duplicate tracks if( ( trackOnStart || trackOnEnd ) && track1->GetLayer() == track2->GetLayer() ) { SEG t1Seg( track1->GetStart(), track1->GetEnd() ); SEG t2Seg( track2->GetStart(), track2->GetEnd() ); if( t1Seg.ApproxCollinear( t2Seg ) ) continue; SHAPE_ARC sArc( t1Seg, t2Seg, filletRadiusIU ); wxPoint t1newPoint, t2newPoint; auto setIfPointOnSeg = []( wxPoint& aPointToSet, SEG aSegment, VECTOR2I aVecToTest ) { VECTOR2I segToVec = aSegment.NearestPoint( aVecToTest ) - aVecToTest; // Find out if we are on the segment (minimum precision) if( segToVec.EuclideanNorm() < SHAPE_ARC::MIN_PRECISION_IU ) { aPointToSet.x = aVecToTest.x; aPointToSet.y = aVecToTest.y; return true; } return false; }; //Do not draw a fillet if the end points of the arc are not within the track segments if( !setIfPointOnSeg( t1newPoint, t1Seg, sArc.GetP0() ) && !setIfPointOnSeg( t2newPoint, t2Seg, sArc.GetP0() ) ) { didOneAttemptFail = true; continue; } if( !setIfPointOnSeg( t1newPoint, t1Seg, sArc.GetP1() ) && !setIfPointOnSeg( t2newPoint, t2Seg, sArc.GetP1() ) ) { didOneAttemptFail = true; continue; } PCB_ARC* tArc = new PCB_ARC( frame()->GetBoard(), &sArc ); tArc->SetLayer( track1->GetLayer() ); tArc->SetWidth( track1->GetWidth() ); tArc->SetNet( track1->GetNet() ); tArc->SetLocked( track1->IsLocked() ); m_commit->Add( tArc ); itemsToAddToSelection.push_back( tArc ); m_commit->Modify( track1 ); m_commit->Modify( track2 ); if( filletOp.t1Start ) track1->SetStart( t1newPoint ); else track1->SetEnd( t1newPoint ); if( filletOp.t2Start ) track2->SetStart( t2newPoint ); else track2->SetEnd( t2newPoint ); operationPerformedOnAtLeastOne = true; } } m_commit->Push( _( "Fillet Tracks" ) ); //select the newly created arcs for( BOARD_ITEM* item : itemsToAddToSelection ) m_selectionTool->AddItemToSel( item ); if( !operationPerformedOnAtLeastOne ) frame()->ShowInfoBarMsg( _( "Unable to fillet the selected track segments." ) ); else if( didOneAttemptFail ) frame()->ShowInfoBarMsg( _( "Some of the track segments could not be filleted." ) ); return 0; } int EDIT_TOOL::Properties( const TOOL_EVENT& aEvent ) { PCB_BASE_EDIT_FRAME* editFrame = getEditFrame(); const PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { } ); // Tracks & vias are treated in a special way: if( ( SELECTION_CONDITIONS::OnlyTypes( GENERAL_COLLECTOR::Tracks ) )( selection ) ) { DIALOG_TRACK_VIA_PROPERTIES dlg( editFrame, selection, *m_commit ); dlg.ShowQuasiModal(); // QuasiModal required for NET_SELECTOR } else if( selection.Size() == 1 ) { // Display properties dialog BOARD_ITEM* item = static_cast( selection.Front() ); // Do not handle undo buffer, it is done by the properties dialogs editFrame->OnEditItemRequest( item ); // Notify other tools of the changes m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); } else if( selection.Size() == 0 && getView()->IsLayerVisible( LAYER_DRAWINGSHEET ) ) { DS_PROXY_VIEW_ITEM* ds = editFrame->GetCanvas()->GetDrawingSheet(); VECTOR2D cursorPos = getViewControls()->GetCursorPosition( false ); if( ds && ds->HitTestDrawingSheetItems( getView(), (wxPoint) cursorPos ) ) m_toolMgr->RunAction( ACTIONS::pageSettings ); else m_toolMgr->RunAction( PCB_ACTIONS::footprintProperties, true ); } if( selection.IsHover() ) { m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); } else { // Check for items becoming invisible and drop them from the selection. LSET visible = editFrame->GetBoard()->GetVisibleLayers(); for( EDA_ITEM* eda_item : selection ) { BOARD_ITEM* item = static_cast( eda_item ); if( !( item->GetLayerSet() & visible ).any() ) m_selectionTool->RemoveItemFromSel( item ); } } return 0; } int EDIT_TOOL::Rotate( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } PCB_BASE_EDIT_FRAME* editFrame = getEditFrame(); // Be sure that there is at least one item that we can modify. If nothing was selected before, // try looking for the stuff under mouse cursor (i.e. KiCad old-style hover selection) PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForHierarchy( aCollector, true ); sTool->FilterCollectorForMarkers( aCollector ); }, // Prompt user regarding locked items if in board editor and in free-pad-mode (if // we're not in free-pad mode we delay this until the second RequestSelection()). frame()->Settings().m_AllowFreePads && !m_isFootprintEditor ); if( selection.Empty() ) return 0; OPT oldRefPt = boost::make_optional( false, VECTOR2I( 0, 0 ) ); bool is_hover = selection.IsHover(); // N.B. This must be saved before the second // call to RequestSelection() below if( selection.HasReferencePoint() ) oldRefPt = selection.GetReferencePoint(); // Now filter out pads if not in free pads mode. We cannot do this in the first // RequestSelection() as we need the reference point when a pad is the selection front. if( !m_isFootprintEditor && !frame()->Settings().m_AllowFreePads ) { selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); sTool->FilterCollectorForFreePads( aCollector ); }, true /* prompt user regarding locked items */ ); } // Did we filter everything out? If so, don't try to operate further if( selection.Empty() ) return 0; updateModificationPoint( selection ); VECTOR2I refPt = selection.GetReferencePoint(); const int rotateAngle = TOOL_EVT_UTILS::GetEventRotationAngle( *editFrame, aEvent ); // When editing footprints, all items have the same parent if( IsFootprintEditor() ) m_commit->Modify( selection.Front() ); for( EDA_ITEM* item : selection ) { if( !item->IsNew() && !IsFootprintEditor() ) { m_commit->Modify( item ); // If rotating a group, record position of all the descendants for undo if( item->Type() == PCB_GROUP_T ) { static_cast( item )->RunOnDescendants( [&]( BOARD_ITEM* bItem ) { m_commit->Modify( bItem ); }); } } static_cast( item )->Rotate( refPt, rotateAngle ); } if( !m_dragging ) m_commit->Push( _( "Rotate" ) ); if( is_hover && !m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); if( m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::updateLocalRatsnest, false ); // Restore the old reference so any mouse dragging that occurs doesn't make the selection jump // to this now invalid reference if( oldRefPt ) selection.SetReferencePoint( *oldRefPt ); else selection.ClearReferencePoint(); return 0; } /** * Mirror a point about the vertical axis passing through another point. */ static wxPoint mirrorPointX( const wxPoint& aPoint, const wxPoint& aMirrorPoint ) { wxPoint mirrored = aPoint; mirrored.x -= aMirrorPoint.x; mirrored.x = -mirrored.x; mirrored.x += aMirrorPoint.x; return mirrored; } /** * Mirror a pad in the vertical axis passing through a point (mirror left to right). */ static void mirrorPadX( PAD& aPad, const wxPoint& aMirrorPoint ) { if( aPad.GetShape() == PAD_SHAPE::CUSTOM ) aPad.FlipPrimitives( true ); // mirror primitives left to right wxPoint tmpPt = mirrorPointX( aPad.GetPosition(), aMirrorPoint ); aPad.SetPosition( tmpPt ); aPad.SetX0( aPad.GetPosition().x ); tmpPt = aPad.GetOffset(); tmpPt.x = -tmpPt.x; aPad.SetOffset( tmpPt ); auto tmpz = aPad.GetDelta(); tmpz.x = -tmpz.x; aPad.SetDelta( tmpz ); aPad.SetOrientation( -aPad.GetOrientation() ); } int EDIT_TOOL::Mirror( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); sTool->FilterCollectorForFreePads( aCollector ); }, !m_dragging /* prompt user regarding locked items */ ); if( selection.Empty() ) return 0; updateModificationPoint( selection ); auto refPoint = selection.GetReferencePoint(); wxPoint mirrorPoint( refPoint.x, refPoint.y ); // When editing footprints, all items have the same parent if( IsFootprintEditor() ) m_commit->Modify( selection.Front() ); for( EDA_ITEM* item : selection ) { // only modify items we can mirror switch( item->Type() ) { case PCB_FP_SHAPE_T: case PCB_FP_TEXT_T: case PCB_FP_ZONE_T: case PCB_PAD_T: // Only create undo entry for items on the board if( !item->IsNew() && !IsFootprintEditor() ) m_commit->Modify( item ); break; default: continue; } // modify each object as necessary switch( item->Type() ) { case PCB_FP_SHAPE_T: { FP_SHAPE* shape = static_cast( item ); shape->Mirror( mirrorPoint, false ); break; } case PCB_FP_ZONE_T: { FP_ZONE* zone = static_cast( item ); zone->Mirror( mirrorPoint, false ); break; } case PCB_FP_TEXT_T: { FP_TEXT* text = static_cast( item ); text->Mirror( mirrorPoint, false ); break; } case PCB_PAD_T: { PAD* pad = static_cast( item ); mirrorPadX( *pad, mirrorPoint ); break; } default: // it's likely the commit object is wrong if you get here // Unsure if PCB_GROUP_T needs special attention here. assert( false ); break; } } if( !m_dragging ) m_commit->Push( _( "Mirror" ) ); if( selection.IsHover() && !m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); if( m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::updateLocalRatsnest, false ); return 0; } int EDIT_TOOL::Flip( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); sTool->FilterCollectorForFreePads( aCollector ); }, !m_dragging /* prompt user regarding locked items */ ); if( selection.Empty() ) return 0; OPT oldRefPt = boost::make_optional( false, VECTOR2I( 0, 0 ) ); if( selection.HasReferencePoint() ) oldRefPt = selection.GetReferencePoint(); updateModificationPoint( selection ); // Flip around the anchor for footprints, and the bounding box center for board items VECTOR2I refPt = IsFootprintEditor() ? VECTOR2I( 0, 0 ) : selection.GetCenter(); // If only one item selected, flip around the selection or item anchor point (instead // of the bounding box center) to avoid moving the item anchor if( selection.GetSize() == 1 ) { if( m_dragging && selection.HasReferencePoint() ) refPt = selection.GetReferencePoint(); else refPt = static_cast( selection.GetItem( 0 ) )->GetPosition(); } bool leftRight = frame()->Settings().m_FlipLeftRight; // When editing footprints, all items have the same parent if( IsFootprintEditor() ) m_commit->Modify( selection.Front() ); for( EDA_ITEM* item : selection ) { if( !item->IsNew() && !IsFootprintEditor() ) m_commit->Modify( item ); if( item->Type() == PCB_GROUP_T ) { static_cast( item )->RunOnDescendants( [&]( BOARD_ITEM* bItem ) { m_commit->Modify( bItem ); }); } static_cast( item )->Flip( refPt, leftRight ); } if( !m_dragging ) m_commit->Push( _( "Change Side / Flip" ) ); if( selection.IsHover() && !m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); if( m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::updateLocalRatsnest, false ); // Restore the old reference so any mouse dragging that occurs doesn't make the selection jump // to this now invalid reference if( oldRefPt ) selection.SetReferencePoint( *oldRefPt ); else selection.ClearReferencePoint(); return 0; } int EDIT_TOOL::Remove( const TOOL_EVENT& aEvent ) { PCB_BASE_EDIT_FRAME* editFrame = getEditFrame(); if( isRouterActive() ) { m_toolMgr->RunAction( PCB_ACTIONS::routerUndoLastSegment, true ); return 0; } std::string tool = aEvent.GetCommandStr().value(); editFrame->PushTool( tool ); std::vector lockedItems; Activate(); // get a copy instead of reference (as we're going to clear the selection before removing items) PCB_SELECTION selectionCopy; bool isCut = aEvent.Parameter() == PCB_ACTIONS::REMOVE_FLAGS::CUT; bool isAlt = aEvent.Parameter() == PCB_ACTIONS::REMOVE_FLAGS::ALT; // If we are in a "Cut" operation, then the copied selection exists already and we want to // delete exactly that; no more, no fewer. Any filtering for locked items must be done in // the copyToClipboard() routine. if( isCut ) { selectionCopy = m_selectionTool->GetSelection(); } else { // When not in free-pad mode we normally auto-promote selected pads to their parent // footprints. But this is probably a little too dangerous for a destructive operation, // so we just do the promotion but not the deletion (allowing for a second delete to do // it if that's what the user wanted). selectionCopy = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { } ); size_t beforeFPCount = selectionCopy.CountType( PCB_FOOTPRINT_T ); m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForFreePads( aCollector ); } ); if( !selectionCopy.IsHover() && m_selectionTool->GetSelection().CountType( PCB_FOOTPRINT_T ) > beforeFPCount ) { wxBell(); canvas()->Refresh(); editFrame->PopTool( tool ); return 0; } // In "alternative" mode, we expand selected track items to their full connection. if( isAlt && ( selectionCopy.HasType( PCB_TRACE_T ) || selectionCopy.HasType( PCB_VIA_T ) ) ) { m_toolMgr->RunAction( PCB_ACTIONS::selectConnection, true ); } // Finally run RequestSelection() one more time to find out what user wants to do about // locked objects. selectionCopy = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForFreePads( aCollector ); }, true /* prompt user regarding locked items */ ); } // As we are about to remove items, they have to be removed from the selection first m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); for( EDA_ITEM* item : selectionCopy ) { PCB_GROUP* parentGroup = static_cast( item )->GetParentGroup(); if( parentGroup ) { m_commit->Modify( parentGroup ); parentGroup->RemoveItem( static_cast( item ) ); } switch( item->Type() ) { case PCB_FP_TEXT_T: { FP_TEXT* text = static_cast( item ); FOOTPRINT* parent = static_cast( item->GetParent() ); if( text->GetType() == FP_TEXT::TEXT_is_DIVERS ) { m_commit->Modify( parent ); getView()->Remove( text ); parent->Remove( text ); } break; } case PCB_PAD_T: if( IsFootprintEditor() || frame()->Settings().m_AllowFreePads ) { PAD* pad = static_cast( item ); FOOTPRINT* parent = static_cast( item->GetParent() ); m_commit->Modify( parent ); getView()->Remove( pad ); parent->Remove( pad ); } break; case PCB_FP_ZONE_T: { FP_ZONE* zone = static_cast( item ); FOOTPRINT* parent = static_cast( item->GetParent() ); m_commit->Modify( parent ); getView()->Remove( zone ); parent->Remove( zone ); break; } case PCB_ZONE_T: // We process the zones special so that cutouts can be deleted when the delete tool // is called from inside a cutout when the zone is selected. { // Only interact with cutouts when deleting and a single item is selected if( !isCut && selectionCopy.GetSize() == 1 ) { VECTOR2I curPos = getViewControls()->GetCursorPosition(); ZONE* zone = static_cast( item ); int outlineIdx, holeIdx; if( zone->HitTestCutout( curPos, &outlineIdx, &holeIdx ) ) { // Remove the cutout m_commit->Modify( zone ); zone->RemoveCutout( outlineIdx, holeIdx ); zone->UnFill(); // TODO Refill zone when KiCad supports auto re-fill // Update the display zone->HatchBorder(); canvas()->Refresh(); // Restore the selection on the original zone m_toolMgr->RunAction( PCB_ACTIONS::selectItem, true, zone ); break; } } // Remove the entire zone otherwise m_commit->Remove( item ); break; } case PCB_GROUP_T: { PCB_GROUP* group = static_cast( item ); auto removeItem = [&]( BOARD_ITEM* bItem ) { if( bItem->GetParent() && bItem->GetParent()->Type() == PCB_FOOTPRINT_T ) { // Silently ignore delete of Reference or Value if they happen to be // in group. if( bItem->Type() == PCB_FP_TEXT_T ) { FP_TEXT* textItem = static_cast( bItem ); if( textItem->GetType() != FP_TEXT::TEXT_is_DIVERS ) return; } else if( bItem->Type() == PCB_PAD_T ) { if( !IsFootprintEditor() && !frame()->Settings().m_AllowFreePads ) return; } m_commit->Modify( bItem->GetParent() ); getView()->Remove( bItem ); bItem->GetParent()->Remove( bItem ); } else { m_commit->Remove( bItem ); } }; removeItem( group ); group->RunOnDescendants( [&]( BOARD_ITEM* aDescendant ) { removeItem( aDescendant ); }); break; } default: m_commit->Remove( item ); break; } } // If the entered group has been emptied then leave it. PCB_GROUP* enteredGroup = m_selectionTool->GetEnteredGroup(); if( enteredGroup && enteredGroup->GetItems().empty() ) m_selectionTool->ExitGroup(); if( isCut ) m_commit->Push( _( "Cut" ) ); else m_commit->Push( _( "Delete" ) ); editFrame->PopTool( tool ); return 0; } int EDIT_TOOL::MoveExact( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } const PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); }, true /* prompt user regarding locked items */ ); if( selection.Empty() ) return 0; wxPoint translation; double rotation; ROTATION_ANCHOR rotationAnchor = selection.Size() > 1 ? ROTATE_AROUND_SEL_CENTER : ROTATE_AROUND_ITEM_ANCHOR; // TODO: Implement a visible bounding border at the edge auto sel_box = selection.GetBoundingBox(); DIALOG_MOVE_EXACT dialog( frame(), translation, rotation, rotationAnchor, sel_box ); int ret = dialog.ShowModal(); if( ret == wxID_OK ) { VECTOR2I rp = selection.GetCenter(); wxPoint selCenter( rp.x, rp.y ); // Make sure the rotation is from the right reference point selCenter += translation; if( !frame()->GetDisplayOptions().m_DisplayInvertYAxis ) rotation *= -1.0; // When editing footprints, all items have the same parent if( IsFootprintEditor() ) m_commit->Modify( selection.Front() ); for( EDA_ITEM* selItem : selection ) { BOARD_ITEM* item = static_cast( selItem ); if( !item->IsNew() && !IsFootprintEditor() ) { m_commit->Modify( item ); if( item->Type() == PCB_GROUP_T ) { PCB_GROUP* group = static_cast( item ); group->RunOnDescendants( [&]( BOARD_ITEM* bItem ) { m_commit->Modify( bItem ); }); } } if( !item->GetParent() || !item->GetParent()->IsSelected() ) item->Move( translation ); switch( rotationAnchor ) { case ROTATE_AROUND_ITEM_ANCHOR: item->Rotate( item->GetPosition(), rotation ); break; case ROTATE_AROUND_SEL_CENTER: item->Rotate( selCenter, rotation ); break; case ROTATE_AROUND_USER_ORIGIN: item->Rotate( (wxPoint) frame()->GetScreen()->m_LocalOrigin, rotation ); break; case ROTATE_AROUND_AUX_ORIGIN: item->Rotate( board()->GetDesignSettings().GetAuxOrigin(), rotation ); break; } if( !m_dragging ) getView()->Update( item ); } m_commit->Push( _( "Move exact" ) ); if( selection.IsHover() ) m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); m_toolMgr->ProcessEvent( EVENTS::SelectedItemsModified ); if( m_dragging ) m_toolMgr->RunAction( PCB_ACTIONS::updateLocalRatsnest, false ); } return 0; } int EDIT_TOOL::Duplicate( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } bool increment = aEvent.IsAction( &PCB_ACTIONS::duplicateIncrement ); // Be sure that there is at least one item that we can modify const PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I&, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); } ); if( selection.Empty() ) return 0; // we have a selection to work on now, so start the tool process PCB_BASE_EDIT_FRAME* editFrame = getEditFrame(); // If the selection was given a hover, we do not keep the selection after completion bool is_hover = selection.IsHover(); std::vector new_items; new_items.reserve( selection.Size() ); // Each selected item is duplicated and pushed to new_items list // Old selection is cleared, and new items are then selected. for( EDA_ITEM* item : selection ) { BOARD_ITEM* dupe_item = nullptr; BOARD_ITEM* orig_item = static_cast( item ); if( m_isFootprintEditor ) { FOOTPRINT* parentFootprint = editFrame->GetBoard()->GetFirstFootprint(); dupe_item = parentFootprint->DuplicateItem( orig_item ); if( increment && dupe_item->Type() == PCB_PAD_T && static_cast( dupe_item )->CanHaveNumber() ) { PAD_TOOL* padTool = m_toolMgr->GetTool(); wxString padNumber = padTool->GetLastPadNumber(); padNumber = parentFootprint->GetNextPadNumber( padNumber ); padTool->SetLastPadNumber( padNumber ); static_cast( dupe_item )->SetNumber( padNumber ); } } else if( orig_item->GetParent() && orig_item->GetParent()->Type() == PCB_FOOTPRINT_T ) { FOOTPRINT* parentFootprint = static_cast( orig_item->GetParent() ); m_commit->Modify( parentFootprint ); dupe_item = parentFootprint->DuplicateItem( orig_item, true /* add to parent */ ); } else { switch( orig_item->Type() ) { case PCB_FOOTPRINT_T: case PCB_TEXT_T: case PCB_SHAPE_T: case PCB_TRACE_T: case PCB_ARC_T: case PCB_VIA_T: case PCB_ZONE_T: case PCB_TARGET_T: case PCB_DIM_ALIGNED_T: case PCB_DIM_CENTER_T: case PCB_DIM_ORTHOGONAL_T: case PCB_DIM_LEADER_T: dupe_item = orig_item->Duplicate(); break; case PCB_GROUP_T: dupe_item = static_cast( orig_item )->DeepDuplicate(); break; default: wxASSERT_MSG( false, wxString::Format( wxT( "Unhandled item type %d" ), orig_item->Type() ) ); break; } } if( dupe_item ) { if( dupe_item->Type() == PCB_GROUP_T ) { static_cast( dupe_item )->RunOnDescendants( [&]( BOARD_ITEM* bItem ) { m_commit->Add( bItem ); }); } // Clear the selection flag here, otherwise the PCB_SELECTION_TOOL // will not properly select it later on dupe_item->ClearSelected(); new_items.push_back( dupe_item ); m_commit->Add( dupe_item ); } } // Clear the old selection first m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); // Select the new items m_toolMgr->RunAction( PCB_ACTIONS::selectItems, true, &new_items ); // record the new items as added if( !selection.Empty() ) { editFrame->DisplayToolMsg( wxString::Format( _( "Duplicated %d item(s)" ), (int) new_items.size() ) ); // TODO(ISM): This line can't be used to activate the tool until we allow multiple // activations. // m_toolMgr->RunAction( PCB_ACTIONS::move, true ); // Instead we have to create the event and call the tool's function // directly // If items were duplicated, pick them up // this works well for "dropping" copies around and pushes the commit TOOL_EVENT evt = PCB_ACTIONS::move.MakeEvent(); Move( evt ); // Deslect the duplicated item if we originally started as a hover selection if( is_hover ) m_toolMgr->RunAction( PCB_ACTIONS::selectionClear, true ); } return 0; } int EDIT_TOOL::CreateArray( const TOOL_EVENT& aEvent ) { if( isRouterActive() ) { wxBell(); return 0; } // Be sure that there is at least one item that we can modify const auto& selection = m_selectionTool->RequestSelection( []( const VECTOR2I&, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { sTool->FilterCollectorForMarkers( aCollector ); sTool->FilterCollectorForHierarchy( aCollector, true ); } ); if( selection.Empty() ) return 0; // we have a selection to work on now, so start the tool process PCB_BASE_FRAME* editFrame = getEditFrame(); ARRAY_CREATOR array_creator( *editFrame, m_isFootprintEditor, selection, m_toolMgr ); array_creator.Invoke(); return 0; } void EDIT_TOOL::PadFilter( const VECTOR2I&, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { for( int i = aCollector.GetCount() - 1; i >= 0; i-- ) { BOARD_ITEM* item = static_cast( aCollector[i] ); if( item->Type() != PCB_PAD_T ) aCollector.Remove( i ); } } void EDIT_TOOL::FootprintFilter( const VECTOR2I&, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { for( int i = aCollector.GetCount() - 1; i >= 0; i-- ) { BOARD_ITEM* item = static_cast( aCollector[i] ); if( item->Type() != PCB_FOOTPRINT_T ) aCollector.Remove( i ); } } bool EDIT_TOOL::updateModificationPoint( PCB_SELECTION& aSelection ) { if( m_dragging && aSelection.HasReferencePoint() ) return false; // Can't modify an empty group if( aSelection.Empty() ) return false; // When there is only one item selected, the reference point is its position... if( aSelection.Size() == 1 ) { auto item = static_cast( aSelection.Front() ); auto pos = item->GetPosition(); aSelection.SetReferencePoint( VECTOR2I( pos.x, pos.y ) ); } // ...otherwise modify items with regard to the grid-snapped center position else { PCB_GRID_HELPER grid( m_toolMgr, frame()->GetMagneticItemsSettings() ); aSelection.SetReferencePoint( grid.BestSnapAnchor( aSelection.GetCenter(), nullptr ) ); } return true; } bool EDIT_TOOL::pickReferencePoint( const wxString& aTooltip, const wxString& aSuccessMessage, const wxString& aCanceledMessage, VECTOR2I& aReferencePoint ) { PCB_PICKER_TOOL* picker = m_toolMgr->GetTool(); OPT pickedPoint; bool done = false; m_statusPopup->SetText( aTooltip ); /// This allow the option of snapping in the tool picker->SetSnapping( true ); picker->SetClickHandler( [&]( const VECTOR2D& aPoint ) -> bool { pickedPoint = aPoint; if( !aSuccessMessage.empty() ) { m_statusPopup->SetText( aSuccessMessage ); m_statusPopup->Expire( 800 ); } else { m_statusPopup->Hide(); } return false; // we don't need any more points } ); picker->SetMotionHandler( [&]( const VECTOR2D& aPos ) { m_statusPopup->Move( wxGetMousePosition() + wxPoint( 20, -50 ) ); } ); picker->SetCancelHandler( [&]() { if( !aCanceledMessage.empty() ) { m_statusPopup->SetText( aCanceledMessage ); m_statusPopup->Expire( 800 ); } else { m_statusPopup->Hide(); } } ); picker->SetFinalizeHandler( [&]( const int& aFinalState ) { done = true; } ); m_statusPopup->Move( wxGetMousePosition() + wxPoint( 20, -50 ) ); m_statusPopup->Popup(); std::string tool = ""; m_toolMgr->RunAction( ACTIONS::pickerTool, true, &tool ); while( !done ) { // Pass events unless we receive a null event, then we must shut down if( TOOL_EVENT* evt = Wait() ) evt->SetPassEvent(); else break; } // Ensure statusPopup is hidden after use and before deleting it: m_statusPopup->Hide(); if( pickedPoint.is_initialized() ) aReferencePoint = pickedPoint.get(); return pickedPoint.is_initialized(); } int EDIT_TOOL::copyToClipboard( const TOOL_EVENT& aEvent ) { std::string tool = "pcbnew.InteractiveEdit.selectReferencePoint"; CLIPBOARD_IO io; PCB_GRID_HELPER grid( m_toolMgr, getEditFrame()->GetMagneticItemsSettings() ); frame()->PushTool( tool ); Activate(); PCB_SELECTION& selection = m_selectionTool->RequestSelection( []( const VECTOR2I& aPt, GENERAL_COLLECTOR& aCollector, PCB_SELECTION_TOOL* sTool ) { for( int i = aCollector.GetCount() - 1; i >= 0; --i ) { BOARD_ITEM* item = aCollector[i]; // We can't copy both a footprint and its text in the same operation, so if // both are selected, remove the text if( item->Type() == PCB_FP_TEXT_T && aCollector.HasItem( item->GetParent() ) ) aCollector.Remove( item ); } }, // Prompt user regarding locked items. aEvent.IsAction( &ACTIONS::cut ) && !m_isFootprintEditor ); if( !selection.Empty() ) { std::vector items; for( EDA_ITEM* item : selection ) items.push_back( static_cast( item ) ); VECTOR2I refPoint; if( aEvent.IsAction( &PCB_ACTIONS::copyWithReference ) ) { if( !pickReferencePoint( _( "Select reference point for the copy..." ), _( "Selection copied" ), _( "Copy canceled" ), refPoint ) ) { frame()->PopTool( tool ); return 0; } } else { refPoint = grid.BestDragOrigin( getViewControls()->GetCursorPosition(), items ); } selection.SetReferencePoint( refPoint ); io.SetBoard( board() ); io.SaveSelection( selection, m_isFootprintEditor ); frame()->SetStatusText( _( "Selection copied" ) ); } frame()->PopTool( tool ); return 0; } int EDIT_TOOL::cutToClipboard( const TOOL_EVENT& aEvent ) { if( !copyToClipboard( aEvent ) ) { // N.B. Setting the CUT flag prevents lock filtering as we only want to delete the items // that were copied to the clipboard, no more, no fewer. Filtering for locked item, if // any will be done in the copyToClipboard() routine TOOL_EVENT evt( aEvent.Category(), aEvent.Action(), TOOL_ACTION_SCOPE::AS_GLOBAL ); evt.SetParameter( PCB_ACTIONS::REMOVE_FLAGS::CUT ); Remove( evt ); } return 0; } void EDIT_TOOL::setTransitions() { Go( &EDIT_TOOL::GetAndPlace, PCB_ACTIONS::getAndPlace.MakeEvent() ); Go( &EDIT_TOOL::Move, PCB_ACTIONS::move.MakeEvent() ); Go( &EDIT_TOOL::Drag, PCB_ACTIONS::drag45Degree.MakeEvent() ); Go( &EDIT_TOOL::Drag, PCB_ACTIONS::dragFreeAngle.MakeEvent() ); Go( &EDIT_TOOL::Rotate, PCB_ACTIONS::rotateCw.MakeEvent() ); Go( &EDIT_TOOL::Rotate, PCB_ACTIONS::rotateCcw.MakeEvent() ); Go( &EDIT_TOOL::Flip, PCB_ACTIONS::flip.MakeEvent() ); Go( &EDIT_TOOL::Remove, ACTIONS::doDelete.MakeEvent() ); Go( &EDIT_TOOL::Remove, PCB_ACTIONS::deleteFull.MakeEvent() ); Go( &EDIT_TOOL::Properties, PCB_ACTIONS::properties.MakeEvent() ); Go( &EDIT_TOOL::MoveExact, PCB_ACTIONS::moveExact.MakeEvent() ); Go( &EDIT_TOOL::MoveWithReference, PCB_ACTIONS::moveWithReference.MakeEvent() ); Go( &EDIT_TOOL::Duplicate, ACTIONS::duplicate.MakeEvent() ); Go( &EDIT_TOOL::Duplicate, PCB_ACTIONS::duplicateIncrement.MakeEvent() ); Go( &EDIT_TOOL::CreateArray, PCB_ACTIONS::createArray.MakeEvent() ); Go( &EDIT_TOOL::Mirror, PCB_ACTIONS::mirror.MakeEvent() ); Go( &EDIT_TOOL::ChangeTrackWidth, PCB_ACTIONS::changeTrackWidth.MakeEvent() ); Go( &EDIT_TOOL::FilletTracks, PCB_ACTIONS::filletTracks.MakeEvent() ); Go( &EDIT_TOOL::copyToClipboard, ACTIONS::copy.MakeEvent() ); Go( &EDIT_TOOL::copyToClipboard, PCB_ACTIONS::copyWithReference.MakeEvent() ); Go( &EDIT_TOOL::cutToClipboard, ACTIONS::cut.MakeEvent() ); }