Added main execs

1 files changed, 1084 insertions, 0 deletions

diff --git a/pcbnew/router/pns_router.cpp b/pcbnew/router/pns_router.cpp
new file mode 100644
index 0000000..6f64f96
--- /dev/null
+++ b/pcbnew/router/pns_router.cpp
@@ -0,0 +1,1084 @@
+/*
+ * 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 <cstdio>
+#include <vector>
+
+#include <boost/foreach.hpp>
+
+#include <view/view.h>
+#include <view/view_item.h>
+#include <view/view_group.h>
+#include <gal/graphics_abstraction_layer.h>
+
+#include <pcb_painter.h>
+
+#include <geometry/shape.h>
+#include <geometry/shape_line_chain.h>
+#include <geometry/shape_rect.h>
+#include <geometry/shape_circle.h>
+
+#include <tools/grid_helper.h>
+
+#include "trace.h"
+#include "pns_node.h"
+#include "pns_line_placer.h"
+#include "pns_line.h"
+#include "pns_solid.h"
+#include "pns_utils.h"
+#include "pns_router.h"
+#include "pns_shove.h"
+#include "pns_dragger.h"
+#include "pns_topology.h"
+#include "pns_diff_pair_placer.h"
+#include "pns_meander_placer.h"
+#include "pns_meander_skew_placer.h"
+#include "pns_dp_meander_placer.h"
+
+#include <router/router_preview_item.h>
+
+#include <class_board.h>
+#include <class_board_connected_item.h>
+#include <class_module.h>
+#include <class_track.h>
+#include <ratsnest_data.h>
+#include <layers_id_colors_and_visibility.h>
+
+// an ugly singleton for drawing debug items within the router context.
+// To be fixed sometime in the future.
+static PNS_ROUTER* theRouter;
+
+
+PNS_PCBNEW_CLEARANCE_FUNC::PNS_PCBNEW_CLEARANCE_FUNC( PNS_ROUTER* aRouter ) :
+    m_router( aRouter )
+{
+    BOARD* brd = m_router->GetBoard();
+    PNS_NODE* world = m_router->GetWorld();
+
+    PNS_TOPOLOGY topo( world );
+    m_clearanceCache.resize( brd->GetNetCount() );
+    m_useDpGap = false;
+
+    for( unsigned int i = 0; i < brd->GetNetCount(); i++ )
+    {
+        NETINFO_ITEM* ni = brd->FindNet( i );
+        if( ni == NULL )
+            continue;
+
+        CLEARANCE_ENT ent;
+        ent.coupledNet = topo.DpCoupledNet( i );
+
+        wxString netClassName = ni->GetClassName();
+        NETCLASSPTR nc = brd->GetDesignSettings().m_NetClasses.Find( netClassName );
+
+        int clearance = nc->GetClearance();
+        ent.clearance = clearance;
+        m_clearanceCache[i] = ent;
+
+        TRACE( 1, "Add net %d netclass %s clearance %d", i % netClassName.mb_str() %
+            clearance );
+    }
+
+    m_overrideEnabled = false;
+    m_defaultClearance = Millimeter2iu( 0.254 );    // aBoard->m_NetClasses.Find ("Default clearance")->GetClearance();
+    m_overrideNetA = 0;
+    m_overrideNetB = 0;
+    m_overrideClearance = 0;
+}
+
+
+PNS_PCBNEW_CLEARANCE_FUNC::~PNS_PCBNEW_CLEARANCE_FUNC()
+{
+}
+
+
+int PNS_PCBNEW_CLEARANCE_FUNC::localPadClearance( const PNS_ITEM* aItem ) const
+{
+    if( !aItem->Parent() || aItem->Parent()->Type() != PCB_PAD_T )
+        return 0;
+
+    const D_PAD* pad = static_cast<D_PAD*>( aItem->Parent() );
+    return pad->GetLocalClearance();
+}
+
+
+int PNS_PCBNEW_CLEARANCE_FUNC::operator()( const PNS_ITEM* aA, const PNS_ITEM* aB )
+{
+    int net_a = aA->Net();
+    int cl_a = ( net_a >= 0 ? m_clearanceCache[net_a].clearance : m_defaultClearance );
+    int net_b = aB->Net();
+    int cl_b = ( net_b >= 0 ? m_clearanceCache[net_b].clearance : m_defaultClearance );
+
+    bool linesOnly = aA->OfKind( PNS_ITEM::SEGMENT | PNS_ITEM::LINE ) && aB->OfKind( PNS_ITEM::SEGMENT | PNS_ITEM::LINE );
+
+    if( net_a == net_b )
+        return 0;
+
+    if( m_useDpGap && linesOnly && net_a >= 0 && net_b >= 0 && m_clearanceCache[net_a].coupledNet == net_b )
+    {
+        cl_a = cl_b = m_router->Sizes().DiffPairGap() - 2 * PNS_HULL_MARGIN;
+    }
+
+    int pad_a = localPadClearance( aA );
+    int pad_b = localPadClearance( aB );
+
+    cl_a = std::max( cl_a, pad_a );
+    cl_b = std::max( cl_b, pad_b );
+
+    return std::max( cl_a, cl_b );
+}
+
+
+// fixme: ugly hack to make the optimizer respect gap width for currently routed differential pair.
+void PNS_PCBNEW_CLEARANCE_FUNC::OverrideClearance( bool aEnable, int aNetA, int aNetB , int aClearance )
+{
+    m_overrideEnabled = aEnable;
+    m_overrideNetA = aNetA;
+    m_overrideNetB = aNetB;
+    m_overrideClearance = aClearance;
+}
+
+
+PNS_ITEM* PNS_ROUTER::syncPad( D_PAD* aPad )
+{
+    PNS_LAYERSET layers( 0, MAX_CU_LAYERS - 1 );
+
+    // ignore non-copper pads
+    if ( (aPad->GetLayerSet() & LSET::AllCuMask()).none() )
+        return NULL;
+
+    switch( aPad->GetAttribute() )
+    {
+    case PAD_ATTRIB_STANDARD:
+        break;
+
+    case PAD_ATTRIB_SMD:
+    case PAD_ATTRIB_HOLE_NOT_PLATED:
+    case PAD_ATTRIB_CONN:
+        {
+            LSET lmsk = aPad->GetLayerSet();
+            bool is_copper = false;
+
+            for( int i = 0; i < MAX_CU_LAYERS; i++ )
+            {
+                if( lmsk[i] )
+                {
+                    is_copper = true;
+                    if( aPad->GetAttribute() != PAD_ATTRIB_HOLE_NOT_PLATED )
+                        layers = PNS_LAYERSET( i );
+                    break;
+                }
+            }
+
+            if( !is_copper )
+                return NULL;
+        }
+        break;
+
+    default:
+        TRACE( 0, "unsupported pad type 0x%x", aPad->GetAttribute() );
+        return NULL;
+    }
+
+    PNS_SOLID* solid = new PNS_SOLID;
+
+    solid->SetLayers( layers );
+    solid->SetNet( aPad->GetNetCode() );
+    solid->SetParent( aPad );
+
+    wxPoint wx_c = aPad->ShapePos();
+    wxSize  wx_sz = aPad->GetSize();
+    wxPoint offset = aPad->GetOffset();
+
+    VECTOR2I c( wx_c.x, wx_c.y );
+    VECTOR2I sz( wx_sz.x, wx_sz.y );
+
+    RotatePoint( &offset, aPad->GetOrientation() );
+
+    solid->SetPos( VECTOR2I( c.x - offset.x, c.y - offset.y ) );
+    solid->SetOffset ( VECTOR2I ( offset.x, offset.y ) );
+
+    double orient = aPad->GetOrientation() / 10.0;
+
+    if( aPad->GetShape() == PAD_SHAPE_CIRCLE )
+    {
+        solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) );
+    }
+    else
+    {
+        if( orient == 0.0 || orient == 90.0 || orient == 180.0 || orient == 270.0 )
+        {
+            if( orient == 90.0 || orient == 270.0 )
+                sz = VECTOR2I( sz.y, sz.x );
+
+            switch( aPad->GetShape() )
+            {
+            case PAD_SHAPE_OVAL:
+                if( sz.x == sz.y )
+                    solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) );
+                else
+                {
+                    VECTOR2I delta;
+
+                    if( sz.x > sz.y )
+                        delta = VECTOR2I( ( sz.x - sz.y ) / 2, 0 );
+                    else
+                        delta = VECTOR2I( 0, ( sz.y - sz.x ) / 2 );
+
+                    SHAPE_SEGMENT* shape = new SHAPE_SEGMENT( c - delta, c + delta,
+                                                              std::min( sz.x, sz.y ) );
+                    solid->SetShape( shape );
+                }
+                break;
+
+            case PAD_SHAPE_RECT:
+                solid->SetShape( new SHAPE_RECT( c - sz / 2, sz.x, sz.y ) );
+                break;
+
+            case PAD_SHAPE_TRAPEZOID:
+            {
+                wxPoint coords[4];
+                aPad->BuildPadPolygon( coords, wxSize( 0, 0 ), aPad->GetOrientation() );
+                SHAPE_CONVEX* shape = new SHAPE_CONVEX();
+
+                for( int ii = 0; ii < 4; ii++ )
+                {
+                    shape->Append( wx_c + coords[ii] );
+                }
+
+                solid->SetShape( shape );
+                break;
+            }
+
+            default:
+                TRACEn( 0, "unsupported pad shape" );
+                delete solid;
+                return NULL;
+            }
+        }
+        else
+        {
+            switch( aPad->GetShape() )
+            {
+            // PAD_SHAPE_CIRCLE already handled above
+
+            case PAD_SHAPE_OVAL:
+                if( sz.x == sz.y )
+                    solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) );
+                else
+                {
+                    wxPoint start;
+                    wxPoint end;
+                    wxPoint corner;
+
+                    SHAPE_CONVEX* shape = new SHAPE_CONVEX();
+
+                    int w = aPad->BuildSegmentFromOvalShape( start, end, 0.0, wxSize( 0, 0 ) );
+
+                    if( start.y == 0 )
+                        corner = wxPoint( start.x, -( w / 2 ) );
+                    else
+                        corner = wxPoint( w / 2, start.y );
+
+                    RotatePoint( &start, aPad->GetOrientation() );
+                    RotatePoint( &corner, aPad->GetOrientation() );
+                    shape->Append( wx_c + corner );
+
+                    for( int rot = 100; rot <= 1800; rot += 100 )
+                    {
+                        wxPoint p( corner );
+                        RotatePoint( &p, start, rot );
+                        shape->Append( wx_c + p );
+                    }
+
+                    if( end.y == 0 )
+                        corner = wxPoint( end.x, w / 2 );
+                    else
+                        corner = wxPoint( -( w / 2 ), end.y );
+
+                    RotatePoint( &end, aPad->GetOrientation() );
+                    RotatePoint( &corner, aPad->GetOrientation() );
+                    shape->Append( wx_c + corner );
+
+                    for( int rot = 100; rot <= 1800; rot += 100 )
+                    {
+                        wxPoint p( corner );
+                        RotatePoint( &p, end, rot );
+                        shape->Append( wx_c + p );
+                    }
+
+                    solid->SetShape( shape );
+                }
+                break;
+
+            case PAD_SHAPE_RECT:
+            case PAD_SHAPE_TRAPEZOID:
+            {
+                wxPoint coords[4];
+                aPad->BuildPadPolygon( coords, wxSize( 0, 0 ), aPad->GetOrientation() );
+
+                SHAPE_CONVEX* shape = new SHAPE_CONVEX();
+                for( int ii = 0; ii < 4; ii++ )
+                {
+                    shape->Append( wx_c + coords[ii] );
+                }
+
+                solid->SetShape( shape );
+                break;
+            }
+
+            default:
+                TRACEn( 0, "unsupported pad shape" );
+                delete solid;
+
+                return NULL;
+            }
+        }
+    }
+    return solid;
+}
+
+
+PNS_ITEM* PNS_ROUTER::syncTrack( TRACK* aTrack )
+{
+    PNS_SEGMENT* s =
+        new PNS_SEGMENT( SEG( aTrack->GetStart(), aTrack->GetEnd() ), aTrack->GetNetCode() );
+
+    s->SetWidth( aTrack->GetWidth() );
+    s->SetLayers( PNS_LAYERSET( aTrack->GetLayer() ) );
+    s->SetParent( aTrack );
+    return s;
+}
+
+
+PNS_ITEM* PNS_ROUTER::syncVia( VIA* aVia )
+{
+    LAYER_ID top, bottom;
+    aVia->LayerPair( &top, &bottom );
+    PNS_VIA* v = new PNS_VIA(
+            aVia->GetPosition(),
+            PNS_LAYERSET( top, bottom ),
+            aVia->GetWidth(),
+            aVia->GetDrillValue(),
+            aVia->GetNetCode(),
+            aVia->GetViaType() );
+
+    v->SetParent( aVia );
+
+    return v;
+}
+
+
+void PNS_ROUTER::SetBoard( BOARD* aBoard )
+{
+    m_board = aBoard;
+    TRACE( 1, "m_board = %p\n", m_board );
+}
+
+
+void PNS_ROUTER::SyncWorld()
+{
+    if( !m_board )
+    {
+        TRACEn( 0, "No board attached, aborting sync." );
+        return;
+    }
+
+    ClearWorld();
+
+    m_world = new PNS_NODE();
+
+    for( MODULE* module = m_board->m_Modules; module; module = module->Next() )
+    {
+        for( D_PAD* pad = module->Pads(); pad; pad = pad->Next() )
+        {
+            PNS_ITEM* solid = syncPad( pad );
+
+            if( solid )
+                m_world->Add( solid );
+        }
+    }
+
+    for( TRACK* t = m_board->m_Track; t; t = t->Next() )
+    {
+        KICAD_T type = t->Type();
+        PNS_ITEM* item = NULL;
+
+        if( type == PCB_TRACE_T )
+            item = syncTrack( t );
+        else if( type == PCB_VIA_T )
+            item = syncVia( static_cast<VIA*>( t ) );
+
+        if( item )
+            m_world->Add( item );
+    }
+
+    int worstClearance = m_board->GetDesignSettings().GetBiggestClearanceValue();
+    m_clearanceFunc = new PNS_PCBNEW_CLEARANCE_FUNC( this );
+    m_world->SetClearanceFunctor( m_clearanceFunc );
+    m_world->SetMaxClearance( 4 * worstClearance );
+}
+
+
+PNS_ROUTER::PNS_ROUTER()
+{
+    theRouter = this;
+
+    m_clearanceFunc = NULL;
+
+    m_state = IDLE;
+    m_world = NULL;
+    m_placer = NULL;
+    m_previewItems = NULL;
+    m_board = NULL;
+    m_dragger = NULL;
+    m_mode = PNS_MODE_ROUTE_SINGLE;
+
+    // Initialize all other variables:
+    m_lastNode = NULL;
+    m_shove = NULL;
+    m_iterLimit = 0;
+    m_showInterSteps = false;
+    m_snapshotIter = 0;
+    m_view = NULL;
+    m_snappingEnabled  = false;
+    m_violation = false;
+    m_gridHelper = NULL;
+
+}
+
+
+void PNS_ROUTER::SetView( KIGFX::VIEW* aView )
+{
+    if( m_previewItems )
+    {
+        m_previewItems->FreeItems();
+        delete m_previewItems;
+    }
+
+    m_view = aView;
+    m_previewItems = new KIGFX::VIEW_GROUP( m_view );
+    m_previewItems->SetLayer( ITEM_GAL_LAYER( GP_OVERLAY ) );
+    m_view->Add( m_previewItems );
+    m_previewItems->ViewSetVisible( true );
+}
+
+
+PNS_ROUTER* PNS_ROUTER::GetInstance()
+{
+    return theRouter;
+}
+
+
+PNS_ROUTER::~PNS_ROUTER()
+{
+    ClearWorld();
+    theRouter = NULL;
+
+    if( m_previewItems )
+        delete m_previewItems;
+}
+
+
+void PNS_ROUTER::ClearWorld()
+{
+    if( m_world )
+    {
+        m_world->KillChildren();
+        delete m_world;
+    }
+
+    if( m_clearanceFunc )
+        delete m_clearanceFunc;
+
+    if( m_placer )
+        delete m_placer;
+
+    if( m_previewItems )
+        delete m_previewItems;
+
+    m_clearanceFunc = NULL;
+    m_world = NULL;
+    m_placer = NULL;
+    m_previewItems = NULL;
+}
+
+
+bool PNS_ROUTER::RoutingInProgress() const
+{
+    return m_state != IDLE;
+}
+
+
+const PNS_ITEMSET PNS_ROUTER::QueryHoverItems( const VECTOR2I& aP )
+{
+    if( m_state == IDLE )
+        return m_world->HitTest( aP );
+    else
+    {
+        return m_placer->CurrentNode()->HitTest( aP );
+    }
+}
+
+
+const VECTOR2I PNS_ROUTER::SnapToItem( PNS_ITEM* aItem, VECTOR2I aP, bool& aSplitsSegment )
+{
+    VECTOR2I anchor;
+
+    if( !aItem )
+    {
+        aSplitsSegment = false;
+        return aP;
+    }
+
+    switch( aItem->Kind() )
+    {
+    case PNS_ITEM::SOLID:
+        anchor = static_cast<PNS_SOLID*>( aItem )->Pos();
+        aSplitsSegment = false;
+        break;
+
+    case PNS_ITEM::VIA:
+        anchor = static_cast<PNS_VIA*>( aItem )->Pos();
+        aSplitsSegment = false;
+        break;
+
+    case PNS_ITEM::SEGMENT:
+    {
+        PNS_SEGMENT* seg = static_cast<PNS_SEGMENT*>( aItem );
+        const SEG& s = seg->Seg();
+        int w = seg->Width();
+
+        aSplitsSegment = false;
+
+        if( ( aP - s.A ).EuclideanNorm() < w / 2 )
+            anchor = s.A;
+        else if( ( aP - s.B ).EuclideanNorm() < w / 2 )
+            anchor = s.B;
+        else
+        {
+            anchor = m_gridHelper->AlignToSegment ( aP, s );
+            aSplitsSegment = (anchor != s.A && anchor != s.B );
+        }
+
+        break;
+    }
+
+    default:
+        break;
+    }
+
+    return anchor;
+}
+
+
+bool PNS_ROUTER::StartDragging( const VECTOR2I& aP, PNS_ITEM* aStartItem )
+{
+    if( !aStartItem || aStartItem->OfKind( PNS_ITEM::SOLID ) )
+        return false;
+
+    m_dragger = new PNS_DRAGGER( this );
+    m_dragger->SetWorld( m_world );
+
+    if( m_dragger->Start ( aP, aStartItem ) )
+        m_state = DRAG_SEGMENT;
+    else
+    {
+        delete m_dragger;
+        m_state = IDLE;
+        return false;
+    }
+
+    return true;
+}
+
+bool PNS_ROUTER::StartRouting( const VECTOR2I& aP, PNS_ITEM* aStartItem, int aLayer )
+{
+    m_clearanceFunc->UseDpGap( false );
+
+    switch( m_mode )
+    {
+    case PNS_MODE_ROUTE_SINGLE:
+        m_placer = new PNS_LINE_PLACER( this );
+        break;
+    case PNS_MODE_ROUTE_DIFF_PAIR:
+        m_placer = new PNS_DIFF_PAIR_PLACER( this );
+        m_clearanceFunc->UseDpGap( true );
+        break;
+    case PNS_MODE_TUNE_SINGLE:
+        m_placer = new PNS_MEANDER_PLACER( this );
+        break;
+    case PNS_MODE_TUNE_DIFF_PAIR:
+        m_placer = new PNS_DP_MEANDER_PLACER( this );
+        break;
+    case PNS_MODE_TUNE_DIFF_PAIR_SKEW:
+        m_placer = new PNS_MEANDER_SKEW_PLACER( this );
+        break;
+
+    default:
+        return false;
+    }
+
+    m_placer->UpdateSizes ( m_sizes );
+    m_placer->SetLayer( aLayer );
+
+    bool rv = m_placer->Start( aP, aStartItem );
+
+    if( !rv )
+        return false;
+
+    m_currentEnd = aP;
+    m_state = ROUTE_TRACK;
+    return rv;
+}
+
+
+BOARD* PNS_ROUTER::GetBoard()
+{
+    return m_board;
+}
+
+
+void PNS_ROUTER::eraseView()
+{
+    BOOST_FOREACH( BOARD_ITEM* item, m_hiddenItems )
+    {
+        item->ViewSetVisible( true );
+    }
+
+    m_hiddenItems.clear();
+
+    if( m_previewItems )
+    {
+        m_previewItems->FreeItems();
+        m_previewItems->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
+    }
+}
+
+
+void PNS_ROUTER::DisplayItem( const PNS_ITEM* aItem, int aColor, int aClearance )
+{
+    ROUTER_PREVIEW_ITEM* pitem = new ROUTER_PREVIEW_ITEM( aItem, m_previewItems );
+
+    if( aColor >= 0 )
+        pitem->SetColor( KIGFX::COLOR4D( aColor ) );
+
+    if( aClearance >= 0 )
+        pitem->SetClearance( aClearance );
+
+    m_previewItems->Add( pitem );
+
+    pitem->ViewSetVisible( true );
+    m_previewItems->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY | KIGFX::VIEW_ITEM::APPEARANCE );
+}
+
+
+void PNS_ROUTER::DisplayItems( const PNS_ITEMSET& aItems )
+{
+    BOOST_FOREACH( const PNS_ITEM* item, aItems.CItems() )
+        DisplayItem( item );
+}
+
+
+void PNS_ROUTER::DisplayDebugLine( const SHAPE_LINE_CHAIN& aLine, int aType, int aWidth )
+{
+    ROUTER_PREVIEW_ITEM* pitem = new ROUTER_PREVIEW_ITEM( NULL, m_previewItems );
+
+    pitem->Line( aLine, aWidth, aType );
+    m_previewItems->Add( pitem );
+    pitem->ViewSetVisible( true );
+    m_previewItems->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY | KIGFX::VIEW_ITEM::APPEARANCE );
+}
+
+
+void PNS_ROUTER::DisplayDebugPoint( const VECTOR2I aPos, int aType )
+{
+    ROUTER_PREVIEW_ITEM* pitem = new ROUTER_PREVIEW_ITEM( NULL, m_previewItems );
+
+    pitem->Point( aPos, aType );
+    m_previewItems->Add( pitem );
+    pitem->ViewSetVisible( true );
+    m_previewItems->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY | KIGFX::VIEW_ITEM::APPEARANCE );
+}
+
+
+void PNS_ROUTER::Move( const VECTOR2I& aP, PNS_ITEM* endItem )
+{
+    m_currentEnd = aP;
+
+    switch( m_state )
+    {
+    case ROUTE_TRACK:
+        movePlacing( aP, endItem );
+        break;
+
+    case DRAG_SEGMENT:
+        moveDragging( aP, endItem );
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+void PNS_ROUTER::moveDragging( const VECTOR2I& aP, PNS_ITEM* aEndItem )
+{
+    eraseView();
+
+    m_dragger->Drag( aP );
+    PNS_ITEMSET dragged = m_dragger->Traces();
+
+    updateView( m_dragger->CurrentNode(), dragged );
+}
+
+
+void PNS_ROUTER::markViolations( PNS_NODE* aNode, PNS_ITEMSET& aCurrent,
+                                 PNS_NODE::ITEM_VECTOR& aRemoved )
+{
+    BOOST_FOREACH( PNS_ITEM* item, aCurrent.Items() )
+    {
+        PNS_NODE::OBSTACLES obstacles;
+
+        aNode->QueryColliding( item, obstacles, PNS_ITEM::ANY );
+
+        if( item->OfKind( PNS_ITEM::LINE ) )
+        {
+            PNS_LINE* l = static_cast<PNS_LINE*>( item );
+
+            if( l->EndsWithVia() )
+            {
+                PNS_VIA v( l->Via() );
+                aNode->QueryColliding( &v, obstacles, PNS_ITEM::ANY );
+            }
+        }
+
+        BOOST_FOREACH( PNS_OBSTACLE& obs, obstacles )
+        {
+            int clearance = aNode->GetClearance( item, obs.m_item );
+            std::auto_ptr<PNS_ITEM> tmp( obs.m_item->Clone() );
+            tmp->Mark( MK_VIOLATION );
+            DisplayItem( tmp.get(), -1, clearance );
+            aRemoved.push_back( obs.m_item );
+        }
+    }
+}
+
+
+void PNS_ROUTER::updateView( PNS_NODE* aNode, PNS_ITEMSET& aCurrent )
+{
+    PNS_NODE::ITEM_VECTOR removed, added;
+    PNS_NODE::OBSTACLES obstacles;
+
+    if( !aNode )
+        return;
+
+    if( Settings().Mode() == RM_MarkObstacles )
+        markViolations( aNode, aCurrent, removed );
+
+    aNode->GetUpdatedItems( removed, added );
+
+    BOOST_FOREACH( PNS_ITEM* item, added )
+    {
+        DisplayItem( item );
+    }
+
+    BOOST_FOREACH( PNS_ITEM* item, removed )
+    {
+        BOARD_CONNECTED_ITEM* parent = item->Parent();
+
+        if( parent )
+        {
+            if( parent->ViewIsVisible() )
+                m_hiddenItems.insert( parent );
+
+            parent->ViewSetVisible( false );
+            parent->ViewUpdate( KIGFX::VIEW_ITEM::APPEARANCE );
+        }
+    }
+}
+
+
+void PNS_ROUTER::UpdateSizes ( const PNS_SIZES_SETTINGS& aSizes )
+{
+    m_sizes = aSizes;
+
+    // Change track/via size settings
+    if( m_state == ROUTE_TRACK)
+    {
+        m_placer->UpdateSizes( m_sizes );
+    }
+}
+
+
+void PNS_ROUTER::movePlacing( const VECTOR2I& aP, PNS_ITEM* aEndItem )
+{
+    eraseView();
+
+    m_placer->Move( aP, aEndItem );
+    PNS_ITEMSET current = m_placer->Traces();
+
+    BOOST_FOREACH( const PNS_ITEM* item, current.CItems() )
+    {
+        if( !item->OfKind( PNS_ITEM::LINE ) )
+            continue;
+
+        const PNS_LINE* l = static_cast<const PNS_LINE*>( item );
+        DisplayItem( l );
+
+        if( l->EndsWithVia() )
+            DisplayItem( &l->Via() );
+    }
+
+    //PNS_ITEMSET tmp( &current );
+
+    updateView( m_placer->CurrentNode( true ), current );
+}
+
+
+void PNS_ROUTER::CommitRouting( PNS_NODE* aNode )
+{
+    PNS_NODE::ITEM_VECTOR removed, added;
+
+    aNode->GetUpdatedItems( removed, added );
+
+    for( unsigned int i = 0; i < removed.size(); i++ )
+    {
+        BOARD_CONNECTED_ITEM* parent = removed[i]->Parent();
+
+        if( parent )
+        {
+            m_view->Remove( parent );
+            m_board->Remove( parent );
+            m_undoBuffer.PushItem( ITEM_PICKER( parent, UR_DELETED ) );
+        }
+    }
+
+    BOOST_FOREACH( PNS_ITEM* item, added )
+    {
+        BOARD_CONNECTED_ITEM* newBI = NULL;
+
+        switch( item->Kind() )
+        {
+        case PNS_ITEM::SEGMENT:
+        {
+            PNS_SEGMENT* seg = static_cast<PNS_SEGMENT*>( item );
+            TRACK* track = new TRACK( m_board );
+            const SEG& s = seg->Seg();
+
+            track->SetStart( wxPoint( s.A.x, s.A.y ) );
+            track->SetEnd( wxPoint( s.B.x, s.B.y ) );
+            track->SetWidth( seg->Width() );
+            track->SetLayer( ToLAYER_ID( seg->Layers().Start() ) );
+            track->SetNetCode( seg->Net() > 0 ? seg->Net() : 0 );
+            newBI = track;
+            break;
+        }
+
+        case PNS_ITEM::VIA:
+        {
+            VIA* via_board = new VIA( m_board );
+            PNS_VIA* via = static_cast<PNS_VIA*>( item );
+            via_board->SetPosition( wxPoint( via->Pos().x, via->Pos().y ) );
+            via_board->SetWidth( via->Diameter() );
+            via_board->SetDrill( via->Drill() );
+            via_board->SetNetCode( via->Net() > 0 ? via->Net() : 0 );
+            via_board->SetViaType( via->ViaType() ); // MUST be before SetLayerPair()
+            via_board->SetLayerPair( ToLAYER_ID( via->Layers().Start() ),
+                                     ToLAYER_ID( via->Layers().End() ) );
+            newBI = via_board;
+            break;
+        }
+
+        default:
+            break;
+        }
+
+        if( newBI )
+        {
+            item->SetParent( newBI );
+            newBI->ClearFlags();
+            m_view->Add( newBI );
+            m_board->Add( newBI );
+            m_undoBuffer.PushItem( ITEM_PICKER( newBI, UR_NEW ) );
+            newBI->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
+        }
+    }
+
+    m_board->GetRatsnest()->Recalculate();
+    m_world->Commit( aNode );
+}
+
+
+bool PNS_ROUTER::FixRoute( const VECTOR2I& aP, PNS_ITEM* aEndItem )
+{
+    bool rv = false;
+
+    switch( m_state )
+    {
+    case ROUTE_TRACK:
+        rv = m_placer->FixRoute( aP, aEndItem );
+        break;
+
+    case DRAG_SEGMENT:
+        rv = m_dragger->FixRoute();
+        break;
+
+    default:
+        break;
+    }
+
+    if( rv )
+       StopRouting();
+
+    return rv;
+}
+
+
+void PNS_ROUTER::StopRouting()
+{
+    // Update the ratsnest with new changes
+
+    if( m_placer )
+    {
+        std::vector<int> nets;
+        m_placer->GetModifiedNets( nets );
+
+        BOOST_FOREACH ( int n, nets )
+        {
+            // Update the ratsnest with new changes
+            m_board->GetRatsnest()->Recalculate( n );
+        }
+    }
+
+    if( !RoutingInProgress() )
+        return;
+
+    if( m_placer )
+        delete m_placer;
+
+    if( m_dragger )
+        delete m_dragger;
+
+    m_placer = NULL;
+    m_dragger = NULL;
+
+    eraseView();
+
+    m_state = IDLE;
+    m_world->KillChildren();
+    m_world->ClearRanks();
+}
+
+
+void PNS_ROUTER::FlipPosture()
+{
+    if( m_state == ROUTE_TRACK )
+    {
+        m_placer->FlipPosture();
+    }
+}
+
+
+void PNS_ROUTER::SwitchLayer( int aLayer )
+{
+    switch( m_state )
+    {
+    case ROUTE_TRACK:
+        m_placer->SetLayer( aLayer );
+        break;
+    default:
+        break;
+    }
+}
+
+
+void PNS_ROUTER::ToggleViaPlacement()
+{
+    if( m_state == ROUTE_TRACK )
+    {
+        bool toggle = !m_placer->IsPlacingVia();
+        m_placer->ToggleVia( toggle );
+    }
+}
+
+
+const std::vector<int> PNS_ROUTER::GetCurrentNets() const
+{
+    if( m_placer )
+        return m_placer->CurrentNets();
+
+    return std::vector<int>();
+}
+
+
+int PNS_ROUTER::GetCurrentLayer() const
+{
+    if( m_placer )
+        return m_placer->CurrentLayer();
+    return -1;
+}
+
+
+void PNS_ROUTER::DumpLog()
+{
+    PNS_LOGGER* logger = NULL;
+
+    switch( m_state )
+    {
+    case DRAG_SEGMENT:
+        logger = m_dragger->Logger();
+        break;
+
+    case ROUTE_TRACK:
+        logger = m_placer->Logger();
+        break;
+
+    default:
+        break;
+    }
+
+    if( logger )
+        logger->Save( "/tmp/shove.log" );
+}
+
+
+bool PNS_ROUTER::IsPlacingVia() const
+{
+    if( !m_placer )
+        return false;
+
+    return m_placer->IsPlacingVia();
+}
+
+
+void PNS_ROUTER::SetOrthoMode( bool aEnable )
+{
+    if( !m_placer )
+        return;
+
+    m_placer->SetOrthoMode( aEnable );
+}
+
+
+void PNS_ROUTER::SetMode( PNS_ROUTER_MODE aMode )
+{
+    m_mode = aMode;
+}