diff options
Diffstat (limited to 'pcbnew/router/pns_dragger.cpp')
| -rw-r--r-- | pcbnew/router/pns_dragger.cpp | 336 |
1 files changed, 336 insertions, 0 deletions
diff --git a/pcbnew/router/pns_dragger.cpp b/pcbnew/router/pns_dragger.cpp new file mode 100644 index 0000000..a30e7cd --- /dev/null +++ b/pcbnew/router/pns_dragger.cpp @@ -0,0 +1,336 @@ +/* + * KiRouter - a push-and-(sometimes-)shove PCB router + * + * Copyright (C) 2013-2014 CERN + * Author: Tomasz Wlostowski <tomasz.wlostowski@cern.ch> + * + * 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/>. + */ + +#include <boost/foreach.hpp> + +#include "pns_dragger.h" +#include "pns_shove.h" +#include "pns_router.h" + +PNS_DRAGGER::PNS_DRAGGER( PNS_ROUTER* aRouter ) : + PNS_ALGO_BASE( aRouter ) +{ + m_world = NULL; + m_lastNode = NULL; + m_mode = SEGMENT; + m_draggedVia = NULL; + m_shove = NULL; + m_draggedSegmentIndex = 0; + m_dragStatus = false; + m_currentMode = RM_MarkObstacles; + m_initialVia = NULL; +} + + +PNS_DRAGGER::~PNS_DRAGGER() +{ + if( m_shove ) + delete m_shove; +} + + +void PNS_DRAGGER::SetWorld( PNS_NODE* aWorld ) +{ + m_world = aWorld; +} + + +bool PNS_DRAGGER::startDragSegment( const VECTOR2D& aP, PNS_SEGMENT* aSeg ) +{ + int w2 = aSeg->Width() / 2; + + m_draggedLine = m_world->AssembleLine( aSeg, &m_draggedSegmentIndex ); + m_shove->SetInitialLine( m_draggedLine ); + m_lastValidDraggedLine = m_draggedLine; + m_lastValidDraggedLine.ClearSegmentLinks(); + + if( ( aP - aSeg->Seg().A ).EuclideanNorm() <= w2 ) + m_mode = CORNER; + else if( ( aP - aSeg->Seg().B ).EuclideanNorm() <= w2 ) + { + m_draggedSegmentIndex++; + m_mode = CORNER; + } else + m_mode = SEGMENT; + + return true; +} + + +bool PNS_DRAGGER::startDragVia( const VECTOR2D& aP, PNS_VIA* aVia ) +{ + m_draggedVia = aVia; + m_initialVia = aVia; + m_mode = VIA; + + VECTOR2I p0( aVia->Pos() ); + PNS_JOINT* jt = m_world->FindJoint( p0, aVia->Layers().Start(), aVia->Net() ); + + if( !jt ) + return false; + + BOOST_FOREACH( PNS_ITEM* item, jt->LinkList() ) + { + if( item->OfKind( PNS_ITEM::SEGMENT ) ) + { + int segIndex; + PNS_SEGMENT* seg = ( PNS_SEGMENT*) item; + PNS_LINE l = m_world->AssembleLine( seg, &segIndex ); + + if( segIndex != 0 ) + l.Reverse(); + + m_origViaConnections.Add( l ); + } + } + + return true; +} + + +bool PNS_DRAGGER::Start( const VECTOR2I& aP, PNS_ITEM* aStartItem ) +{ + m_shove = new PNS_SHOVE( m_world, Router() ); + m_lastNode = NULL; + m_draggedItems.Clear(); + m_currentMode = Settings().Mode(); + + TRACE( 2, "StartDragging: item %p [kind %d]", aStartItem % aStartItem->Kind() ); + + switch( aStartItem->Kind() ) + { + case PNS_ITEM::SEGMENT: + return startDragSegment( aP, static_cast<PNS_SEGMENT*>( aStartItem ) ); + + case PNS_ITEM::VIA: + return startDragVia( aP, static_cast<PNS_VIA*>( aStartItem ) ); + + default: + return false; + } +} + + +bool PNS_DRAGGER::dragMarkObstacles( const VECTOR2I& aP ) +{ + if( m_lastNode ) + { + delete m_lastNode; + m_lastNode = NULL; + } + + switch( m_mode ) + { + case SEGMENT: + case CORNER: + { + int thresh = Settings().SmoothDraggedSegments() ? m_draggedLine.Width() / 4 : 0; + PNS_LINE dragged( m_draggedLine ); + + if( m_mode == SEGMENT ) + dragged.DragSegment( aP, m_draggedSegmentIndex, thresh ); + else + dragged.DragCorner( aP, m_draggedSegmentIndex, thresh ); + + m_lastNode = m_shove->CurrentNode()->Branch(); + + m_lastValidDraggedLine = dragged; + m_lastValidDraggedLine.ClearSegmentLinks(); + m_lastValidDraggedLine.Unmark(); + + m_lastNode->Add( &m_lastValidDraggedLine ); + m_draggedItems.Clear(); + m_draggedItems.Add( m_lastValidDraggedLine ); + + break; + } + + case VIA: // fixme... + { + m_lastNode = m_shove->CurrentNode()->Branch(); + dumbDragVia( m_initialVia, m_lastNode, aP ); + + break; + } + } + + if( Settings().CanViolateDRC() ) + m_dragStatus = true; + else + m_dragStatus = !m_world->CheckColliding( m_draggedItems ); + + return true; +} + + +void PNS_DRAGGER::dumbDragVia( PNS_VIA* aVia, PNS_NODE* aNode, const VECTOR2I& aP ) +{ + m_draggedItems.Clear(); + + // fixme: this is awful. + m_draggedVia = aVia->Clone(); + m_draggedVia->SetPos( aP ); + + m_draggedItems.Add( m_draggedVia ); + + m_lastNode->Remove( aVia ); + m_lastNode->Add( m_draggedVia ); + + BOOST_FOREACH( PNS_ITEM* item, m_origViaConnections.Items() ) + { + if( const PNS_LINE* l = dyn_cast<const PNS_LINE*>( item ) ) + { + PNS_LINE origLine( *l ); + PNS_LINE draggedLine( *l ); + + draggedLine.DragCorner( aP, origLine.CLine().Find( aVia->Pos() ) ); + draggedLine.ClearSegmentLinks(); + + m_draggedItems.Add( draggedLine ); + + m_lastNode->Remove( &origLine ); + m_lastNode->Add( &draggedLine ); + } + } +} + + +bool PNS_DRAGGER::dragShove( const VECTOR2I& aP ) +{ + bool ok = false; + + if( m_lastNode ) + { + delete m_lastNode; + m_lastNode = NULL; + } + + switch( m_mode ) + { + case SEGMENT: + case CORNER: + { + int thresh = Settings().SmoothDraggedSegments() ? m_draggedLine.Width() / 4 : 0; + PNS_LINE dragged( m_draggedLine ); + + if( m_mode == SEGMENT ) + dragged.DragSegment( aP, m_draggedSegmentIndex, thresh ); + else + dragged.DragCorner( aP, m_draggedSegmentIndex, thresh ); + + PNS_SHOVE::SHOVE_STATUS st = m_shove->ShoveLines( dragged ); + + if( st == PNS_SHOVE::SH_OK ) + ok = true; + else if( st == PNS_SHOVE::SH_HEAD_MODIFIED ) + { + dragged = m_shove->NewHead(); + ok = true; + } + + m_lastNode = m_shove->CurrentNode()->Branch(); + + if( ok ) + m_lastValidDraggedLine = dragged; + + m_lastValidDraggedLine.ClearSegmentLinks(); + m_lastValidDraggedLine.Unmark(); + m_lastNode->Add( &m_lastValidDraggedLine ); + m_draggedItems.Clear(); + m_draggedItems.Add( m_lastValidDraggedLine ); + + break; + } + + case VIA: + { + PNS_VIA* newVia; + PNS_SHOVE::SHOVE_STATUS st = m_shove->ShoveDraggingVia( m_draggedVia, aP, &newVia ); + + if( st == PNS_SHOVE::SH_OK || st == PNS_SHOVE::SH_HEAD_MODIFIED ) + ok = true; + + m_lastNode = m_shove->CurrentNode()->Branch(); + + if( ok ) + { + m_draggedVia = newVia; + m_draggedItems.Clear(); + } + + break; + } + } + + m_dragStatus = ok; + + return ok; +} + + +bool PNS_DRAGGER::FixRoute() +{ + if( m_dragStatus ) + { + Router()->CommitRouting( CurrentNode() ); + return true; + } + + return false; +} + + +bool PNS_DRAGGER::Drag( const VECTOR2I& aP ) +{ + switch( m_currentMode ) + { + case RM_MarkObstacles: + return dragMarkObstacles( aP ); + + case RM_Shove: + case RM_Walkaround: + case RM_Smart: + return dragShove( aP ); + + default: + return false; + } +} + + +PNS_NODE* PNS_DRAGGER::CurrentNode() const +{ + return m_lastNode; +} + + +const PNS_ITEMSET PNS_DRAGGER::Traces() +{ + return m_draggedItems; +} + + +PNS_LOGGER* PNS_DRAGGER::Logger() +{ + if( m_shove ) + return m_shove->Logger(); + + return NULL; +} |