KiCad PCB EDA Suite
PNS::ROUTER Class Reference

#include <pns_router.h>

Public Types

enum  RouterState { IDLE, DRAG_SEGMENT, DRAG_COMPONENT, ROUTE_TRACK }
 

Public Member Functions

 ROUTER ()
 
 ~ROUTER ()
 
void SetInterface (ROUTER_IFACE *aIface)
 
void SetMode (ROUTER_MODE aMode)
 
ROUTER_MODE Mode () const
 
RouterState GetState () const
 
DRAG_ALGOGetDragger ()
 
void ClearWorld ()
 
void SyncWorld ()
 
bool RoutingInProgress () const
 
bool StartRouting (const VECTOR2I &aP, ITEM *aItem, int aLayer)
 
void Move (const VECTOR2I &aP, ITEM *aItem)
 
bool FixRoute (const VECTOR2I &aP, ITEM *aItem, bool aForceFinish=false)
 
void BreakSegment (ITEM *aItem, const VECTOR2I &aP)
 
void UndoLastSegment ()
 
void CommitRouting ()
 
void StopRouting ()
 
void ClearViewDecorations ()
 
NODEGetWorld () const
 
void FlipPosture ()
 
bool SwitchLayer (int layer)
 
void ToggleViaPlacement ()
 
void SetOrthoMode (bool aEnable)
 
void ToggleCornerMode ()
 
int GetCurrentLayer () const
 
const std::vector< int > GetCurrentNets () const
 
LOGGERLogger ()
 
RULE_RESOLVERGetRuleResolver () const
 
bool IsPlacingVia () const
 
const ITEM_SET QueryHoverItems (const VECTOR2I &aP, bool aUseClearance=false)
 
bool StartDragging (const VECTOR2I &aP, ITEM *aItem, int aDragMode=DM_ANY)
 
bool StartDragging (const VECTOR2I &aP, ITEM_SET aItems, int aDragMode=DM_COMPONENT)
 
void SetIterLimit (int aX)
 
int GetIterLimit () const
 
ROUTING_SETTINGSSettings ()
 
void CommitRouting (NODE *aNode)
 
void UpdateSizes (const SIZES_SETTINGS &aSizes)
 Applies stored settings. More...
 
void LoadSettings (ROUTING_SETTINGS *aSettings)
 Changes routing settings to ones passed in the parameter. More...
 
SIZES_SETTINGSSizes ()
 
void SetFailureReason (const wxString &aReason)
 
const wxString & FailureReason () const
 
PLACEMENT_ALGOPlacer ()
 
ROUTER_IFACEGetInterface () const
 
void SetVisibleViewArea (const BOX2I &aExtents)
 
const BOX2IVisibleViewArea () const
 

Static Public Member Functions

static ROUTERGetInstance ()
 

Private Member Functions

void movePlacing (const VECTOR2I &aP, ITEM *aItem)
 
void moveDragging (const VECTOR2I &aP, ITEM *aItem)
 
void updateView (NODE *aNode, ITEM_SET &aCurrent, bool aDragging=false)
 
void markViolations (NODE *aNode, ITEM_SET &aCurrent, NODE::ITEM_VECTOR &aRemoved)
 
bool isStartingPointRoutable (const VECTOR2I &aWhere, ITEM *aItem, int aLayer)
 

Private Attributes

BOX2I m_visibleViewArea
 
RouterState m_state
 
std::unique_ptr< NODEm_world
 
NODEm_lastNode
 
std::unique_ptr< PLACEMENT_ALGOm_placer
 
std::unique_ptr< DRAG_ALGOm_dragger
 
std::unique_ptr< SHOVEm_shove
 
ROUTER_IFACEm_iface
 
int m_iterLimit
 
bool m_forceMarkObstaclesMode = false
 
ROUTING_SETTINGSm_settings
 
SIZES_SETTINGS m_sizes
 
ROUTER_MODE m_mode
 
LOGGERm_logger
 
wxString m_toolStatusbarName
 
wxString m_failureReason
 

Detailed Description

Definition at line 115 of file pns_router.h.

Member Enumeration Documentation

◆ RouterState

Enumerator
IDLE 
DRAG_SEGMENT 
DRAG_COMPONENT 
ROUTE_TRACK 

Definition at line 118 of file pns_router.h.

Constructor & Destructor Documentation

◆ ROUTER()

PNS::ROUTER::ROUTER ( )

Definition at line 60 of file pns_router.cpp.

61 {
62  theRouter = this;
63 
64  m_state = IDLE;
66 
67  m_logger = new LOGGER;
68 
69  // Initialize all other variables:
70  m_lastNode = nullptr;
71  m_iterLimit = 0;
72  m_settings = nullptr;
73  m_iface = nullptr;
75 }
BOX2I m_visibleViewArea
Definition: pns_router.h:225
int m_iterLimit
Definition: pns_router.h:237
ROUTING_SETTINGS * m_settings
Definition: pns_router.h:240
NODE * m_lastNode
Definition: pns_router.h:229
void SetMaximum()
Definition: box2.h:57
RouterState m_state
Definition: pns_router.h:226
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
LOGGER * m_logger
Definition: pns_router.h:243
static ROUTER * theRouter
Definition: pns_router.cpp:58
ROUTER_MODE m_mode
Definition: pns_router.h:242

References IDLE, m_iface, m_iterLimit, m_lastNode, m_logger, m_mode, m_settings, m_state, m_visibleViewArea, PNS::PNS_MODE_ROUTE_SINGLE, BOX2< Vec >::SetMaximum(), and PNS::theRouter.

◆ ~ROUTER()

PNS::ROUTER::~ROUTER ( )

Definition at line 84 of file pns_router.cpp.

85 {
86  ClearWorld();
87  theRouter = nullptr;
88  delete m_logger;
89 }
void ClearWorld()
Definition: pns_router.cpp:102
LOGGER * m_logger
Definition: pns_router.h:243
static ROUTER * theRouter
Definition: pns_router.cpp:58

References ClearWorld(), m_logger, and PNS::theRouter.

Member Function Documentation

◆ BreakSegment()

void PNS::ROUTER::BreakSegment ( ITEM aItem,
const VECTOR2I aP 
)

Definition at line 854 of file pns_router.cpp.

855 {
856  NODE *node = m_world->Branch();
857 
858  LINE_PLACER placer( this );
859 
860  if( placer.SplitAdjacentSegments( node, aItem, aP ) )
861  {
862  CommitRouting( node );
863  }
864  else
865  {
866  delete node;
867  }
868 }
void CommitRouting()
Definition: pns_router.cpp:710
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228

References CommitRouting(), m_world, and PNS::LINE_PLACER::SplitAdjacentSegments().

Referenced by ROUTER_TOOL::breakTrack().

◆ ClearViewDecorations()

void PNS::ROUTER::ClearViewDecorations ( )

◆ ClearWorld()

void PNS::ROUTER::ClearWorld ( )

Definition at line 102 of file pns_router.cpp.

103 {
104  if( m_world )
105  {
106  m_world->KillChildren();
107  m_world.reset();
108  }
109 
110  m_placer.reset();
111 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228

References m_placer, and m_world.

Referenced by ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), PNS::TOOL_BASE::Reset(), SyncWorld(), and ~ROUTER().

◆ CommitRouting() [1/2]

◆ CommitRouting() [2/2]

void PNS::ROUTER::CommitRouting ( NODE aNode)

Definition at line 618 of file pns_router.cpp.

619 {
620  if( m_state == ROUTE_TRACK && !m_placer->HasPlacedAnything() )
621  return;
622 
623  NODE::ITEM_VECTOR removed;
624  NODE::ITEM_VECTOR added;
625  NODE::ITEM_VECTOR changed;
626 
627  aNode->GetUpdatedItems( removed, added );
628 
629  for( ITEM* item : removed )
630  {
631  bool is_changed = false;
632 
633  // Items in remove/add that share the same parent are just updated versions
634  // We move them to the updated vector to preserve attributes such as UUID and pad data
635  if( item->Parent() )
636  {
637  for( NODE::ITEM_VECTOR::iterator added_it = added.begin();
638  added_it != added.end(); ++added_it )
639  {
640  if( ( *added_it )->Parent() && ( *added_it )->Parent() == item->Parent() )
641  {
642  changed.push_back( *added_it );
643  added.erase( added_it );
644  is_changed = true;
645  break;
646  }
647  }
648  }
649 
650  if( !is_changed && !item->IsVirtual() )
651  m_iface->RemoveItem( item );
652  }
653 
654  for( ITEM* item : added )
655  {
656  if( !item->IsVirtual() )
657  {
658  m_iface->AddItem( item );
659  }
660  }
661 
662  for( ITEM* item : changed )
663  {
664  if( !item->IsVirtual() )
665  {
666  m_iface->UpdateItem( item );
667  }
668  }
669 
670  m_iface->Commit();
671  m_world->Commit( aNode );
672 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
virtual void AddItem(ITEM *aItem)=0
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228
RouterState m_state
Definition: pns_router.h:226
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
virtual void UpdateItem(ITEM *aItem)=0
virtual void Commit()=0
virtual void RemoveItem(ITEM *aItem)=0
std::vector< ITEM * > ITEM_VECTOR
Definition: pns_node.h:152

References PNS::ROUTER_IFACE::AddItem(), PNS::ROUTER_IFACE::Commit(), PNS::NODE::GetUpdatedItems(), m_iface, m_placer, m_state, m_world, PNS::ROUTER_IFACE::RemoveItem(), ROUTE_TRACK, and PNS::ROUTER_IFACE::UpdateItem().

◆ FailureReason()

const wxString& PNS::ROUTER::FailureReason ( ) const
inline

Definition at line 204 of file pns_router.h.

204 { return m_failureReason; }
wxString m_failureReason
Definition: pns_router.h:246

References m_failureReason.

Referenced by LENGTH_TUNER_TOOL::performTuning(), and ROUTER_TOOL::prepareInteractive().

◆ FixRoute()

bool PNS::ROUTER::FixRoute ( const VECTOR2I aP,
ITEM aItem,
bool  aForceFinish = false 
)

Definition at line 675 of file pns_router.cpp.

676 {
677  bool rv = false;
678 
679  if( m_logger )
680  m_logger->Log( LOGGER::EVT_FIX, aP, aEndItem );
681 
682  switch( m_state )
683  {
684  case ROUTE_TRACK:
685  rv = m_placer->FixRoute( aP, aEndItem, aForceFinish );
686  break;
687 
688  case DRAG_SEGMENT:
689  case DRAG_COMPONENT:
690  rv = m_dragger->FixRoute();
691  break;
692 
693  default:
694  break;
695  }
696 
697  return rv;
698 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232
RouterState m_state
Definition: pns_router.h:226
LOGGER * m_logger
Definition: pns_router.h:243
void Log(EVENT_TYPE evt, const VECTOR2I &pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:64

References DRAG_COMPONENT, DRAG_SEGMENT, PNS::LOGGER::EVT_FIX, PNS::LOGGER::Log(), m_dragger, m_logger, m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), and LENGTH_TUNER_TOOL::performTuning().

◆ FlipPosture()

void PNS::ROUTER::FlipPosture ( )

Definition at line 753 of file pns_router.cpp.

754 {
755  if( m_state == ROUTE_TRACK )
756  {
757  m_placer->FlipPosture();
758  }
759 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
RouterState m_state
Definition: pns_router.h:226

References m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::performRouting().

◆ GetCurrentLayer()

int PNS::ROUTER::GetCurrentLayer ( ) const

Definition at line 792 of file pns_router.cpp.

793 {
794  if( m_placer )
795  return m_placer->CurrentLayer();
796  else if( m_dragger )
797  return m_dragger->CurrentLayer();
798 
799  return -1;
800 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232

References m_dragger, and m_placer.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::performRouting(), ROUTER_TOOL::switchLayerOnViaPlacement(), PNS::TOOL_BASE::updateEndItem(), and ROUTER_TOOL::UpdateMessagePanel().

◆ GetCurrentNets()

const std::vector< int > PNS::ROUTER::GetCurrentNets ( ) const

Definition at line 781 of file pns_router.cpp.

782 {
783  if( m_placer )
784  return m_placer->CurrentNets();
785  else if( m_dragger )
786  return m_dragger->CurrentNets();
787 
788  return std::vector<int>();
789 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232

References m_dragger, and m_placer.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::onTrackViaSizeChanged(), and PNS::TOOL_BASE::updateEndItem().

◆ GetDragger()

DRAG_ALGO* PNS::ROUTER::GetDragger ( )
inline

Definition at line 136 of file pns_router.h.

136 { return m_dragger.get(); }
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232

References m_dragger.

◆ GetInstance()

ROUTER * PNS::ROUTER::GetInstance ( )
static

◆ GetInterface()

◆ GetIterLimit()

int PNS::ROUTER::GetIterLimit ( ) const
inline

Definition at line 180 of file pns_router.h.

180 { return m_iterLimit; };
int m_iterLimit
Definition: pns_router.h:237

References m_iterLimit.

◆ GetRuleResolver()

RULE_RESOLVER* PNS::ROUTER::GetRuleResolver ( ) const
inline

Definition at line 170 of file pns_router.h.

170 { return m_iface->GetRuleResolver(); }
virtual RULE_RESOLVER * GetRuleResolver()=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:235

References PNS::ROUTER_IFACE::GetRuleResolver(), and m_iface.

Referenced by PNS::MEANDER_PLACER_BASE::Clearance(), movePlacing(), and updateView().

◆ GetState()

RouterState PNS::ROUTER::GetState ( ) const
inline

Definition at line 134 of file pns_router.h.

134 { return m_state; }
RouterState m_state
Definition: pns_router.h:226

References m_state.

Referenced by PNS::TOOL_BASE::checkSnap(), BOARD_EDITOR_CONTROL::TrackWidthDec(), and BOARD_EDITOR_CONTROL::TrackWidthInc().

◆ GetWorld()

◆ IsPlacingVia()

bool PNS::ROUTER::IsPlacingVia ( ) const

Definition at line 809 of file pns_router.cpp.

810 {
811  if( !m_placer )
812  return false;
813 
814  return m_placer->IsPlacingVia();
815 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231

References m_placer.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::performRouting(), and PNS::TOOL_BASE::updateEndItem().

◆ isStartingPointRoutable()

bool PNS::ROUTER::isStartingPointRoutable ( const VECTOR2I aWhere,
ITEM aItem,
int  aLayer 
)
private

Definition at line 203 of file pns_router.cpp.

204 {
205  if( Settings().AllowDRCViolations() )
206  return true;
207 
209  {
211  {
212  SetFailureReason( _( "Diff pair gap is less than board minimum clearance." ) );
213  return false;
214  }
215  }
216 
217  ITEM_SET candidates = QueryHoverItems( aWhere );
218 
219  for( ITEM* item : candidates.Items() )
220  {
221  if( !item->IsRoutable() && item->Layers().Overlaps( aLayer ) )
222  {
223  BOARD_ITEM* parent = item->Parent();
224 
225  switch( parent->Type() )
226  {
227  case PCB_PAD_T:
228  {
229  PAD* pad = static_cast<PAD*>( parent );
230 
231  if( pad->GetAttribute() == PAD_ATTRIB::NPTH )
232  SetFailureReason( _( "Cannot start routing from a non-plated hole." ) );
233  }
234  break;
235 
236  case PCB_ZONE_T:
237  case PCB_FP_ZONE_T:
238  {
239  ZONE* zone = static_cast<ZONE*>( parent );
240 
241  if( !zone->GetZoneName().IsEmpty() )
242  {
243  SetFailureReason( wxString::Format( _( "Rule area '%s' disallows tracks." ),
244  zone->GetZoneName() ) );
245  }
246  else
247  {
248  SetFailureReason( _( "Rule area disallows tracks." ) );
249  }
250  }
251  break;
252 
253  case PCB_TEXT_T:
254  case PCB_FP_TEXT_T:
255  SetFailureReason( _( "Cannot start routing from a text item." ) );
256  break;
257 
258  case PCB_SHAPE_T:
259  case PCB_FP_SHAPE_T:
260  SetFailureReason( _( "Cannot start routing from a graphic." ) );
261 
262  default:
263  break;
264  }
265 
266  return false;
267  }
268  }
269 
270  VECTOR2I startPoint = aStartItem ? aStartItem->Anchor( 0 ) : aWhere;
271 
272  if( aStartItem && aStartItem->OfKind( ITEM::SEGMENT_T | ITEM::ARC_T ) )
273  {
274  VECTOR2I otherEnd = aStartItem->Anchor( 1 );
275 
276  if( ( otherEnd - aWhere ).SquaredEuclideanNorm()
277  < ( startPoint - aWhere ).SquaredEuclideanNorm() )
278  {
279  startPoint = otherEnd;
280  }
281  }
282 
284  {
285  SHAPE_LINE_CHAIN dummyStartSeg;
286  LINE dummyStartLine;
287 
288  dummyStartSeg.Append( startPoint );
289  dummyStartSeg.Append( startPoint, true );
290 
291  dummyStartLine.SetShape( dummyStartSeg );
292  dummyStartLine.SetLayer( aLayer );
293  dummyStartLine.SetNet( aStartItem ? aStartItem->Net() : 0 );
294  dummyStartLine.SetWidth( m_sizes.TrackWidth() );
295 
296  if( m_world->CheckColliding( &dummyStartLine, ITEM::ANY_T ) )
297  {
298  ITEM_SET dummyStartSet( &dummyStartLine );
299  NODE::ITEM_VECTOR highlightedItems;
300 
301  markViolations( m_world.get(), dummyStartSet, highlightedItems );
302 
303  for( ITEM* item : highlightedItems )
304  m_iface->HideItem( item );
305 
306  SetFailureReason( _( "The routing start point violates DRC." ) );
307  return false;
308  }
309  }
310  else if( m_mode == PNS_MODE_ROUTE_DIFF_PAIR )
311  {
312  if( !aStartItem )
313  {
314  SetFailureReason( _( "Cannot start a differential pair in the middle of nowhere." ) );
315  return false;
316  }
317 
318  DP_PRIMITIVE_PAIR dpPair;
319  wxString errorMsg;
320 
321  if( !DIFF_PAIR_PLACER::FindDpPrimitivePair( m_world.get(), startPoint, aStartItem, dpPair,
322  &errorMsg ) )
323  {
324  SetFailureReason( errorMsg );
325  return false;
326  }
327 
328  SHAPE_LINE_CHAIN dummyStartSegA;
329  SHAPE_LINE_CHAIN dummyStartSegB;
330  LINE dummyStartLineA;
331  LINE dummyStartLineB;
332 
333  dummyStartSegA.Append( dpPair.AnchorN() );
334  dummyStartSegA.Append( dpPair.AnchorN(), true );
335 
336  dummyStartSegB.Append( dpPair.AnchorP() );
337  dummyStartSegB.Append( dpPair.AnchorP(), true );
338 
339  dummyStartLineA.SetShape( dummyStartSegA );
340  dummyStartLineA.SetLayer( aLayer );
341  dummyStartLineA.SetNet( dpPair.PrimN()->Net() );
342  dummyStartLineA.SetWidth( m_sizes.DiffPairWidth() );
343 
344  dummyStartLineB.SetShape( dummyStartSegB );
345  dummyStartLineB.SetLayer( aLayer );
346  dummyStartLineB.SetNet( dpPair.PrimP()->Net() );
347  dummyStartLineB.SetWidth( m_sizes.DiffPairWidth() );
348 
349  if( m_world->CheckColliding( &dummyStartLineA, ITEM::ANY_T )
350  || m_world->CheckColliding( &dummyStartLineB, ITEM::ANY_T ) )
351  {
352  ITEM_SET dummyStartSet;
353  NODE::ITEM_VECTOR highlightedItems;
354 
355  dummyStartSet.Add( dummyStartLineA );
356  dummyStartSet.Add( dummyStartLineB );
357  markViolations( m_world.get(), dummyStartSet, highlightedItems );
358 
359  for( ITEM* item : highlightedItems )
360  m_iface->HideItem( item );
361 
362  SetFailureReason( _( "The routing start point violates DRC." ) );
363  return false;
364  }
365  }
366 
367  return true;
368 }
class FP_TEXT, text in a footprint
Definition: typeinfo.h:92
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:49
const ITEM_SET QueryHoverItems(const VECTOR2I &aP, bool aUseClearance=false)
Definition: pns_router.cpp:120
virtual void HideItem(ITEM *aItem)=0
class PCB_TEXT, text on a layer
Definition: typeinfo.h:91
class FP_SHAPE, a footprint edge
Definition: typeinfo.h:93
class PAD, a pad in a footprint
Definition: typeinfo.h:89
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228
like PAD_PTH, but not plated
void SetFailureReason(const wxString &aReason)
Definition: pns_router.h:203
#define _(s)
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
Handle a list of polygons defining a copper zone.
Definition: zone.h:56
class ZONE, a copper pour area
Definition: typeinfo.h:105
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
class ZONE, managed by a footprint
Definition: typeinfo.h:94
static bool FindDpPrimitivePair(NODE *aWorld, const VECTOR2I &aP, ITEM *aItem, DP_PRIMITIVE_PAIR &aPair, wxString *aErrorMsg=nullptr)
SIZES_SETTINGS m_sizes
Definition: pns_router.h:241
ROUTER_MODE m_mode
Definition: pns_router.h:242
Definition: pad.h:57
wxString GetZoneName() const
Definition: zone.h:129
class PCB_SHAPE, a segment not on copper layers
Definition: typeinfo.h:90
ROUTING_SETTINGS & Settings()
Definition: pns_router.h:182
std::vector< ITEM * > ITEM_VECTOR
Definition: pns_node.h:152
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:112
void markViolations(NODE *aNode, ITEM_SET &aCurrent, NODE::ITEM_VECTOR &aRemoved)
Definition: pns_router.cpp:461

References _, PNS::ITEM_SET::Add(), PNS::ITEM::Anchor(), PNS::ITEM::ANY_T, SHAPE_LINE_CHAIN::Append(), PNS::ITEM::ARC_T, PNS::SIZES_SETTINGS::DiffPairGap(), PNS::SIZES_SETTINGS::DiffPairWidth(), PNS::DIFF_PAIR_PLACER::FindDpPrimitivePair(), Format(), ZONE::GetZoneName(), PNS::ROUTER_IFACE::HideItem(), PNS::ITEM_SET::Items(), m_iface, m_mode, m_sizes, m_world, markViolations(), PNS::SIZES_SETTINGS::MinClearance(), PNS::ITEM::Net(), NPTH, PNS::ITEM::OfKind(), pad, PCB_FP_SHAPE_T, PCB_FP_TEXT_T, PCB_FP_ZONE_T, PCB_PAD_T, PCB_SHAPE_T, PCB_TEXT_T, PCB_ZONE_T, PNS::PNS_MODE_ROUTE_DIFF_PAIR, PNS::PNS_MODE_ROUTE_SINGLE, QueryHoverItems(), PNS::ITEM::SEGMENT_T, SetFailureReason(), PNS::ITEM::SetLayer(), PNS::ITEM::SetNet(), PNS::LINE::SetShape(), Settings(), PNS::LINE::SetWidth(), PNS::SIZES_SETTINGS::TrackWidth(), and EDA_ITEM::Type().

Referenced by StartRouting().

◆ LoadSettings()

void PNS::ROUTER::LoadSettings ( ROUTING_SETTINGS aSettings)
inline

Changes routing settings to ones passed in the parameter.

Parameters
aSettingsare the new settings.

Definition at line 196 of file pns_router.h.

197  {
198  m_settings = aSettings;
199  }
ROUTING_SETTINGS * m_settings
Definition: pns_router.h:240

References m_settings.

Referenced by PNS::TOOL_BASE::Reset().

◆ Logger()

LOGGER * PNS::ROUTER::Logger ( )

Definition at line 803 of file pns_router.cpp.

804 {
805  return m_logger;
806 }
LOGGER * m_logger
Definition: pns_router.h:243

References m_logger.

Referenced by ROUTER_TOOL::saveRouterDebugLog().

◆ markViolations()

void PNS::ROUTER::markViolations ( NODE aNode,
ITEM_SET aCurrent,
NODE::ITEM_VECTOR aRemoved 
)
private

Definition at line 461 of file pns_router.cpp.

462 {
463  auto updateItem =
464  [&]( ITEM* currentItem, ITEM* itemToMark )
465  {
466  std::unique_ptr<ITEM> tmp( itemToMark->Clone() );
467 
468  int clearance;
469  bool removeOriginal = true;
470  bool holeOnly = ( ( itemToMark->Marker() & MK_HOLE )
471  && !( itemToMark->Marker() & MK_VIOLATION ) );
472 
473  if( holeOnly )
474  clearance = aNode->GetHoleClearance( currentItem, itemToMark );
475  else
476  clearance = aNode->GetClearance( currentItem, itemToMark );
477 
478  if( itemToMark->Layers().IsMultilayer() && !currentItem->Layers().IsMultilayer() )
479  tmp->SetLayer( currentItem->Layer() );
480 
481  if( itemToMark->Kind() == ITEM::SOLID_T )
482  {
483  if( holeOnly || !m_iface->IsFlashedOnLayer( itemToMark, currentItem->Layer() ) )
484  {
485  SOLID* solid = static_cast<SOLID*>( tmp.get() );
486 
487  if( solid->Hole() )
488  {
489  solid->SetShape( solid->Hole()->Clone() );
490 
491  // Leave the pad flashing around the highlighted hole
492  removeOriginal = false;
493  }
494  }
495 
496  if( itemToMark->IsCompoundShapePrimitive() )
497  {
498  // We're only highlighting one (or more) of several primitives so we
499  // don't want all the other parts of the object to disappear
500  removeOriginal = false;
501  }
502  }
503 
504  m_iface->DisplayItem( tmp.get(), clearance );
505 
506  if( removeOriginal )
507  aRemoved.push_back( itemToMark );
508  };
509 
510  for( ITEM* item : aCurrent.Items() )
511  {
512  NODE::OBSTACLES obstacles;
513 
514  aNode->QueryColliding( item, obstacles, ITEM::ANY_T );
515 
516  if( item->OfKind( ITEM::LINE_T ) )
517  {
518  LINE* l = static_cast<LINE*>( item );
519 
520  if( l->EndsWithVia() )
521  {
522  VIA v( l->Via() );
523  aNode->QueryColliding( &v, obstacles, ITEM::ANY_T );
524  }
525  }
526 
527  for( OBSTACLE& obs : obstacles )
528  {
529  obs.m_item->Mark( obs.m_item->Marker() | MK_VIOLATION );
530  updateItem( item, obs.m_item );
531  }
532 
533  if( item->Kind() == ITEM::LINE_T )
534  {
535  LINE* line = static_cast<LINE*>( item );
536 
537  // Show clearance on any blocking obstacles
538  if( line->GetBlockingObstacle() )
539  updateItem( item, line->GetBlockingObstacle() );
540  }
541  }
542 }
virtual void DisplayItem(const ITEM *aItem, int aClearance, bool aEdit=false)=0
Normal via.
Definition: router_tool.cpp:72
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
virtual bool IsFlashedOnLayer(const PNS::ITEM *aItem, int aLayer) const =0
std::vector< OBSTACLE > OBSTACLES
Definition: pns_node.h:153

References PNS::ITEM::ANY_T, SHAPE::Clone(), PNS::ROUTER_IFACE::DisplayItem(), PNS::LINE::EndsWithVia(), PNS::LINE::GetBlockingObstacle(), PNS::NODE::GetClearance(), PNS::NODE::GetHoleClearance(), PNS::SOLID::Hole(), PNS::ROUTER_IFACE::IsFlashedOnLayer(), LAYER_RANGE::IsMultilayer(), PNS::ITEM_SET::Items(), PNS::ITEM::Layer(), PNS::ITEM::Layers(), PNS::ITEM::LINE_T, m_iface, PNS::MK_HOLE, PNS::MK_VIOLATION, PNS::NODE::QueryColliding(), PNS::SOLID::SetShape(), PNS::ITEM::SOLID_T, and PNS::LINE::Via().

Referenced by isStartingPointRoutable(), and updateView().

◆ Mode()

ROUTER_MODE PNS::ROUTER::Mode ( ) const
inline

◆ Move()

void PNS::ROUTER::Move ( const VECTOR2I aP,
ITEM aItem 
)

Definition at line 428 of file pns_router.cpp.

429 {
430  if( m_logger )
431  m_logger->Log( LOGGER::EVT_MOVE, aP, endItem );
432 
433  switch( m_state )
434  {
435  case ROUTE_TRACK:
436  movePlacing( aP, endItem );
437  break;
438 
439  case DRAG_SEGMENT:
440  case DRAG_COMPONENT:
441  moveDragging( aP, endItem );
442  break;
443 
444  default:
445  break;
446  }
447 }
void moveDragging(const VECTOR2I &aP, ITEM *aItem)
Definition: pns_router.cpp:450
RouterState m_state
Definition: pns_router.h:226
void movePlacing(const VECTOR2I &aP, ITEM *aItem)
Definition: pns_router.cpp:582
LOGGER * m_logger
Definition: pns_router.h:243
void Log(EVENT_TYPE evt, const VECTOR2I &pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:64

References DRAG_COMPONENT, DRAG_SEGMENT, PNS::LOGGER::EVT_MOVE, PNS::LOGGER::Log(), m_logger, m_state, moveDragging(), movePlacing(), and ROUTE_TRACK.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::onTrackViaSizeChanged(), ROUTER_TOOL::performDragging(), ROUTER_TOOL::performRouting(), and LENGTH_TUNER_TOOL::performTuning().

◆ moveDragging()

void PNS::ROUTER::moveDragging ( const VECTOR2I aP,
ITEM aItem 
)
private

Definition at line 450 of file pns_router.cpp.

451 {
452  m_iface->EraseView();
453 
454  m_dragger->Drag( aP );
455  ITEM_SET dragged = m_dragger->Traces();
456 
457  updateView( m_dragger->CurrentNode(), dragged, true );
458 }
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232
void updateView(NODE *aNode, ITEM_SET &aCurrent, bool aDragging=false)
Definition: pns_router.cpp:545
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
virtual void EraseView()=0

References PNS::ROUTER_IFACE::EraseView(), m_dragger, m_iface, and updateView().

Referenced by Move().

◆ movePlacing()

void PNS::ROUTER::movePlacing ( const VECTOR2I aP,
ITEM aItem 
)
private

Definition at line 582 of file pns_router.cpp.

583 {
584  m_iface->EraseView();
585 
586  m_placer->Move( aP, aEndItem );
587  ITEM_SET current = m_placer->Traces();
588 
589  for( const ITEM* item : current.CItems() )
590  {
591  if( !item->OfKind( ITEM::LINE_T ) )
592  continue;
593 
594  const LINE* l = static_cast<const LINE*>( item );
595  int clearance = GetRuleResolver()->Clearance( item, nullptr );
596 
597  m_iface->DisplayItem( l, clearance );
598 
599  if( l->EndsWithVia() )
600  {
601  const VIA& via = l->Via();
602  int viaClearance = GetRuleResolver()->Clearance( &via, nullptr );
603  int holeClearance = GetRuleResolver()->HoleClearance( &via, nullptr );
604 
605  if( holeClearance + via.Drill() / 2 > viaClearance + via.Diameter() / 2 )
606  viaClearance = holeClearance + via.Drill() / 2 - via.Diameter() / 2;
607 
608  m_iface->DisplayItem( &l->Via(), viaClearance );
609  }
610  }
611 
612  //ITEM_SET tmp( &current );
613 
614  updateView( m_placer->CurrentNode( true ), current );
615 }
RULE_RESOLVER * GetRuleResolver() const
Definition: pns_router.h:170
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
virtual int Clearance(const ITEM *aA, const ITEM *aB, bool aUseClearanceEpsilon=true)=0
virtual void DisplayItem(const ITEM *aItem, int aClearance, bool aEdit=false)=0
Normal via.
Definition: router_tool.cpp:72
void updateView(NODE *aNode, ITEM_SET &aCurrent, bool aDragging=false)
Definition: pns_router.cpp:545
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
virtual void EraseView()=0
virtual int HoleClearance(const ITEM *aA, const ITEM *aB, bool aUseClearanceEpsilon=true)=0

References PNS::ITEM_SET::CItems(), PNS::RULE_RESOLVER::Clearance(), PNS::ROUTER_IFACE::DisplayItem(), PNS::LINE::EndsWithVia(), PNS::ROUTER_IFACE::EraseView(), GetRuleResolver(), PNS::RULE_RESOLVER::HoleClearance(), PNS::ITEM::LINE_T, m_iface, m_placer, updateView(), PNS::LINE::Via(), and via.

Referenced by Move().

◆ Placer()

PLACEMENT_ALGO* PNS::ROUTER::Placer ( )
inline

Definition at line 206 of file pns_router.h.

206 { return m_placer.get(); }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231

References m_placer.

Referenced by LENGTH_TUNER_TOOL::meanderSettingsDialog(), LENGTH_TUNER_TOOL::performTuning(), and PNS_TUNE_STATUS_POPUP::UpdateStatus().

◆ QueryHoverItems()

const ITEM_SET PNS::ROUTER::QueryHoverItems ( const VECTOR2I aP,
bool  aUseClearance = false 
)

Definition at line 120 of file pns_router.cpp.

121 {
122  if( m_state == IDLE || m_placer == nullptr )
123  {
124  if( aUseClearance )
125  {
126  SEGMENT test( SEG( aP, aP ), -1 );
127  test.SetWidth( 1 );
128  test.SetLayers( LAYER_RANGE::All() );
129  NODE::OBSTACLES obs;
130  m_world->QueryColliding( &test, obs, ITEM::ANY_T, -1, false );
131 
132  PNS::ITEM_SET ret;
133 
134  for( OBSTACLE& obstacle : obs )
135  ret.Add( obstacle.m_item, false );
136 
137  return ret;
138  }
139  else
140  {
141  return m_world->HitTest( aP );
142  }
143  }
144  else
145  return m_placer->CurrentNode()->HitTest( aP );
146 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
void Add(const LINE &aLine)
Definition: pns_itemset.cpp:32
static LAYER_RANGE All()
Definition: pns_layerset.h:109
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228
RouterState m_state
Definition: pns_router.h:226
Definition: seg.h:40
std::vector< OBSTACLE > OBSTACLES
Definition: pns_node.h:153

References PNS::ITEM_SET::Add(), LAYER_RANGE::All(), PNS::ITEM::ANY_T, IDLE, m_placer, m_state, and m_world.

Referenced by isStartingPointRoutable(), and PNS::TOOL_BASE::pickSingleItem().

◆ RoutingInProgress()

◆ SetFailureReason()

void PNS::ROUTER::SetFailureReason ( const wxString &  aReason)
inline

◆ SetInterface()

void PNS::ROUTER::SetInterface ( ROUTER_IFACE aIface)

Definition at line 849 of file pns_router.cpp.

850 {
851  m_iface = aIface;
852 }
ROUTER_IFACE * m_iface
Definition: pns_router.h:235

References m_iface.

Referenced by PNS::TOOL_BASE::Reset().

◆ SetIterLimit()

void PNS::ROUTER::SetIterLimit ( int  aX)
inline

Definition at line 179 of file pns_router.h.

179 { m_iterLimit = aX; }
int m_iterLimit
Definition: pns_router.h:237

References m_iterLimit.

◆ SetMode()

void PNS::ROUTER::SetMode ( ROUTER_MODE  aMode)

Definition at line 843 of file pns_router.cpp.

844 {
845  m_mode = aMode;
846 }
ROUTER_MODE m_mode
Definition: pns_router.h:242

References m_mode.

Referenced by ROUTER_TOOL::MainLoop(), and LENGTH_TUNER_TOOL::MainLoop().

◆ SetOrthoMode()

void PNS::ROUTER::SetOrthoMode ( bool  aEnable)

Definition at line 834 of file pns_router.cpp.

835 {
836  if( !m_placer )
837  return;
838 
839  m_placer->SetOrthoMode( aEnable );
840 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231

References m_placer.

◆ Settings()

◆ SetVisibleViewArea()

void PNS::ROUTER::SetVisibleViewArea ( const BOX2I aExtents)
inline

Definition at line 210 of file pns_router.h.

210 { m_visibleViewArea = aExtents; }
BOX2I m_visibleViewArea
Definition: pns_router.h:225

References m_visibleViewArea.

Referenced by ROUTER_TOOL::handleCommonEvents(), and ROUTER_TOOL::InlineDrag().

◆ Sizes()

◆ StartDragging() [1/2]

bool PNS::ROUTER::StartDragging ( const VECTOR2I aP,
ITEM aItem,
int  aDragMode = DM_ANY 
)

Definition at line 149 of file pns_router.cpp.

150 {
151  return StartDragging( aP, ITEM_SET( aItem ), aDragMode );
152 }
bool StartDragging(const VECTOR2I &aP, ITEM *aItem, int aDragMode=DM_ANY)
Definition: pns_router.cpp:149

Referenced by ROUTER_TOOL::InlineDrag(), and ROUTER_TOOL::performDragging().

◆ StartDragging() [2/2]

bool PNS::ROUTER::StartDragging ( const VECTOR2I aP,
ITEM_SET  aItems,
int  aDragMode = DM_COMPONENT 
)

Definition at line 155 of file pns_router.cpp.

156 {
157  if( aStartItems.Empty() )
158  return false;
159 
160  if( aStartItems.Count( ITEM::SOLID_T ) == aStartItems.Size() )
161  {
162  m_dragger = std::make_unique<COMPONENT_DRAGGER>( this );
165  }
166  else
167  {
168  if( aDragMode & DM_FREE_ANGLE )
170  else
171  m_forceMarkObstaclesMode = false;
172 
173  m_dragger = std::make_unique<DRAGGER>( this );
175  }
176 
177  m_dragger->SetMode( aDragMode );
178  m_dragger->SetWorld( m_world.get() );
179  m_dragger->SetLogger( m_logger );
180  m_dragger->SetDebugDecorator( m_iface->GetDebugDecorator() );
181 
182  if( m_logger )
183  m_logger->Clear();
184 
185  if( m_logger && aStartItems.Size() )
186  {
187  m_logger->Log( LOGGER::EVT_START_DRAG, aP, aStartItems[0] );
188  }
189 
190  if( m_dragger->Start( aP, aStartItems ) )
191  {
192  return true;
193  }
194  else
195  {
196  m_dragger.reset();
197  m_state = IDLE;
198  return false;
199  }
200 }
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232
RouterState m_state
Definition: pns_router.h:226
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
void Clear()
Definition: pns_logger.cpp:40
LOGGER * m_logger
Definition: pns_router.h:243
virtual DEBUG_DECORATOR * GetDebugDecorator()=0
void Log(EVENT_TYPE evt, const VECTOR2I &pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:64
bool m_forceMarkObstaclesMode
Definition: pns_router.h:238

References PNS::LOGGER::Clear(), PNS::ITEM_SET::Count(), PNS::DM_FREE_ANGLE, DRAG_COMPONENT, DRAG_SEGMENT, PNS::ITEM_SET::Empty(), PNS::LOGGER::EVT_START_DRAG, PNS::ROUTER_IFACE::GetDebugDecorator(), IDLE, PNS::LOGGER::Log(), m_dragger, m_forceMarkObstaclesMode, m_iface, m_logger, m_state, m_world, PNS::ITEM_SET::Size(), and PNS::ITEM::SOLID_T.

◆ StartRouting()

bool PNS::ROUTER::StartRouting ( const VECTOR2I aP,
ITEM aItem,
int  aLayer 
)

Definition at line 371 of file pns_router.cpp.

372 {
373  if( !isStartingPointRoutable( aP, aStartItem, aLayer ) )
374  return false;
375 
376  m_forceMarkObstaclesMode = false;
377 
378  switch( m_mode )
379  {
381  m_placer = std::make_unique<LINE_PLACER>( this );
382  break;
383 
385  m_placer = std::make_unique<DIFF_PAIR_PLACER>( this );
386  break;
387 
389  m_placer = std::make_unique<MEANDER_PLACER>( this );
390  break;
391 
393  m_placer = std::make_unique<DP_MEANDER_PLACER>( this );
394  break;
395 
397  m_placer = std::make_unique<MEANDER_SKEW_PLACER>( this );
398  break;
399 
400  default:
401  return false;
402  }
403 
404  m_placer->UpdateSizes( m_sizes );
405  m_placer->SetLayer( aLayer );
406  m_placer->SetDebugDecorator( m_iface->GetDebugDecorator() );
407  m_placer->SetLogger( m_logger );
408 
409  if( m_logger )
410  {
411  m_logger->Clear();
412  m_logger->Log( LOGGER::EVT_START_ROUTE, aP, aStartItem );
413  }
414 
415  if( m_placer->Start( aP, aStartItem ) )
416  {
418  return true;
419  }
420  else
421  {
422  m_state = IDLE;
423  return false;
424  }
425 }
bool isStartingPointRoutable(const VECTOR2I &aWhere, ITEM *aItem, int aLayer)
Definition: pns_router.cpp:203
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
RouterState m_state
Definition: pns_router.h:226
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
void Clear()
Definition: pns_logger.cpp:40
LOGGER * m_logger
Definition: pns_router.h:243
virtual DEBUG_DECORATOR * GetDebugDecorator()=0
SIZES_SETTINGS m_sizes
Definition: pns_router.h:241
ROUTER_MODE m_mode
Definition: pns_router.h:242
void Log(EVENT_TYPE evt, const VECTOR2I &pos, const ITEM *item=nullptr)
Definition: pns_logger.cpp:64
bool m_forceMarkObstaclesMode
Definition: pns_router.h:238

References PNS::LOGGER::Clear(), PNS::LOGGER::EVT_START_ROUTE, PNS::ROUTER_IFACE::GetDebugDecorator(), IDLE, isStartingPointRoutable(), PNS::LOGGER::Log(), m_forceMarkObstaclesMode, m_iface, m_logger, m_mode, m_placer, m_sizes, m_state, PNS::PNS_MODE_ROUTE_DIFF_PAIR, PNS::PNS_MODE_ROUTE_SINGLE, PNS::PNS_MODE_TUNE_DIFF_PAIR, PNS::PNS_MODE_TUNE_DIFF_PAIR_SKEW, PNS::PNS_MODE_TUNE_SINGLE, and ROUTE_TRACK.

Referenced by LENGTH_TUNER_TOOL::performTuning(), and ROUTER_TOOL::prepareInteractive().

◆ StopRouting()

void PNS::ROUTER::StopRouting ( )

Definition at line 719 of file pns_router.cpp.

720 {
721  // Update the ratsnest with new changes
722 
723  if( m_placer )
724  {
725  std::vector<int> nets;
726  m_placer->GetModifiedNets( nets );
727 
728  // Update the ratsnest with new changes
729  for( int n : nets )
730  m_iface->UpdateNet( n );
731  }
732 
733  if( !RoutingInProgress() )
734  return;
735 
736  m_placer.reset();
737  m_dragger.reset();
738 
739  m_iface->EraseView();
740 
741  m_state = IDLE;
742  m_world->KillChildren();
743  m_world->ClearRanks();
744 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228
std::unique_ptr< DRAG_ALGO > m_dragger
Definition: pns_router.h:232
virtual void UpdateNet(int aNetCode)=0
RouterState m_state
Definition: pns_router.h:226
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
virtual void EraseView()=0
bool RoutingInProgress() const
Definition: pns_router.cpp:114

References PNS::ROUTER_IFACE::EraseView(), IDLE, m_dragger, m_iface, m_placer, m_state, m_world, RoutingInProgress(), and PNS::ROUTER_IFACE::UpdateNet().

Referenced by CommitRouting(), ROUTER_TOOL::finishInteractive(), ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::MainLoop(), ROUTER_TOOL::performDragging(), and LENGTH_TUNER_TOOL::performTuning().

◆ SwitchLayer()

bool PNS::ROUTER::SwitchLayer ( int  layer)

Definition at line 762 of file pns_router.cpp.

763 {
764  if( m_state == ROUTE_TRACK )
765  return m_placer->SetLayer( aLayer );
766 
767  return false;
768 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
RouterState m_state
Definition: pns_router.h:226

References m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::MainLoop(), and ROUTER_TOOL::switchLayerOnViaPlacement().

◆ SyncWorld()

void PNS::ROUTER::SyncWorld ( )

Definition at line 92 of file pns_router.cpp.

93 {
94  ClearWorld();
95 
96  m_world = std::make_unique<NODE>( );
97  m_iface->SyncWorld( m_world.get() );
98  m_world->FixupVirtualVias();
99 }
std::unique_ptr< NODE > m_world
Definition: pns_router.h:228
void ClearWorld()
Definition: pns_router.cpp:102
virtual void SyncWorld(NODE *aNode)=0
ROUTER_IFACE * m_iface
Definition: pns_router.h:235

References ClearWorld(), m_iface, m_world, and PNS::ROUTER_IFACE::SyncWorld().

Referenced by ROUTER_TOOL::InlineBreakTrack(), ROUTER_TOOL::InlineDrag(), ROUTER_TOOL::MainLoop(), LENGTH_TUNER_TOOL::MainLoop(), and PNS::TOOL_BASE::Reset().

◆ ToggleCornerMode()

void PNS::ROUTER::ToggleCornerMode ( )

Definition at line 818 of file pns_router.cpp.

819 {
821 
822  switch( m_settings->GetCornerMode() )
823  {
824  case DIRECTION_45::CORNER_MODE::MITERED_45: mode = DIRECTION_45::CORNER_MODE::ROUNDED_45; break;
825  case DIRECTION_45::CORNER_MODE::ROUNDED_45: mode = DIRECTION_45::CORNER_MODE::MITERED_90; break;
826  case DIRECTION_45::CORNER_MODE::MITERED_90: mode = DIRECTION_45::CORNER_MODE::ROUNDED_90; break;
827  case DIRECTION_45::CORNER_MODE::ROUNDED_90: mode = DIRECTION_45::CORNER_MODE::MITERED_45; break;
828  }
829 
830  m_settings->SetCornerMode( mode );
831 }
DIRECTION_45::CORNER_MODE GetCornerMode() const
void SetCornerMode(DIRECTION_45::CORNER_MODE aMode)
ROUTING_SETTINGS * m_settings
Definition: pns_router.h:240
CORNER_MODE
Corner modes.
Definition: direction45.h:66

References PNS::ROUTING_SETTINGS::GetCornerMode(), m_settings, and PNS::ROUTING_SETTINGS::SetCornerMode().

Referenced by ROUTER_TOOL::performRouting().

◆ ToggleViaPlacement()

void PNS::ROUTER::ToggleViaPlacement ( )

Definition at line 771 of file pns_router.cpp.

772 {
773  if( m_state == ROUTE_TRACK )
774  {
775  bool toggle = !m_placer->IsPlacingVia();
776  m_placer->ToggleVia( toggle );
777  }
778 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
RouterState m_state
Definition: pns_router.h:226

References m_placer, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::handleLayerSwitch().

◆ UndoLastSegment()

void PNS::ROUTER::UndoLastSegment ( )

Definition at line 701 of file pns_router.cpp.

702 {
703  if( !RoutingInProgress() )
704  return;
705 
706  m_placer->UnfixRoute();
707 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
bool RoutingInProgress() const
Definition: pns_router.cpp:114

References m_placer, and RoutingInProgress().

Referenced by ROUTER_TOOL::performRouting().

◆ UpdateSizes()

void PNS::ROUTER::UpdateSizes ( const SIZES_SETTINGS aSizes)

Applies stored settings.

See also
Settings()

Definition at line 570 of file pns_router.cpp.

571 {
572  m_sizes = aSizes;
573 
574  // Change track/via size settings
575  if( m_state == ROUTE_TRACK )
576  {
577  m_placer->UpdateSizes( m_sizes );
578  }
579 }
std::unique_ptr< PLACEMENT_ALGO > m_placer
Definition: pns_router.h:231
RouterState m_state
Definition: pns_router.h:226
SIZES_SETTINGS m_sizes
Definition: pns_router.h:241

References m_placer, m_sizes, m_state, and ROUTE_TRACK.

Referenced by ROUTER_TOOL::DpDimensionsDialog(), ROUTER_TOOL::handleLayerSwitch(), ROUTER_TOOL::onTrackViaSizeChanged(), ROUTER_TOOL::prepareInteractive(), and PNS::TOOL_BASE::Reset().

◆ updateView()

void PNS::ROUTER::updateView ( NODE aNode,
ITEM_SET aCurrent,
bool  aDragging = false 
)
private

Definition at line 545 of file pns_router.cpp.

546 {
547  NODE::ITEM_VECTOR removed, added;
548  NODE::OBSTACLES obstacles;
549 
550  if( !aNode )
551  return;
552 
554  markViolations( aNode, aCurrent, removed );
555 
556  aNode->GetUpdatedItems( removed, added );
557 
558  for( ITEM* item : added )
559  {
561  int clearance = GetRuleResolver()->Clearance( item, nullptr );
562  m_iface->DisplayItem( item, clearance, aDragging );
563  }
564 
565  for( ITEM* item : removed )
566  m_iface->HideItem( item );
567 }
RULE_RESOLVER * GetRuleResolver() const
Definition: pns_router.h:170
virtual void HideItem(ITEM *aItem)=0
virtual int Clearance(const ITEM *aA, const ITEM *aB, bool aUseClearanceEpsilon=true)=0
virtual void DisplayItem(const ITEM *aItem, int aClearance, bool aEdit=false)=0
virtual void ClearCacheForItem(const ITEM *aItem)
Definition: pns_node.h:100
ROUTER_IFACE * m_iface
Definition: pns_router.h:235
Ignore collisions, mark obstacles.
std::vector< OBSTACLE > OBSTACLES
Definition: pns_node.h:153
ROUTER_MODE Mode() const
Definition: pns_router.h:132
ROUTING_SETTINGS & Settings()
Definition: pns_router.h:182
bool m_forceMarkObstaclesMode
Definition: pns_router.h:238
std::vector< ITEM * > ITEM_VECTOR
Definition: pns_node.h:152
void markViolations(NODE *aNode, ITEM_SET &aCurrent, NODE::ITEM_VECTOR &aRemoved)
Definition: pns_router.cpp:461

References PNS::RULE_RESOLVER::Clearance(), PNS::RULE_RESOLVER::ClearCacheForItem(), PNS::ROUTER_IFACE::DisplayItem(), GetRuleResolver(), PNS::NODE::GetUpdatedItems(), PNS::ROUTER_IFACE::HideItem(), m_forceMarkObstaclesMode, m_iface, markViolations(), Mode(), PNS::RM_MarkObstacles, and Settings().

Referenced by moveDragging(), and movePlacing().

◆ VisibleViewArea()

const BOX2I& PNS::ROUTER::VisibleViewArea ( ) const
inline

Definition at line 211 of file pns_router.h.

211 { return m_visibleViewArea; }
BOX2I m_visibleViewArea
Definition: pns_router.h:225

References m_visibleViewArea.

Referenced by PNS::ALGO_BASE::VisibleViewArea().

Member Data Documentation

◆ m_dragger

std::unique_ptr<DRAG_ALGO> PNS::ROUTER::m_dragger
private

◆ m_failureReason

wxString PNS::ROUTER::m_failureReason
private

Definition at line 246 of file pns_router.h.

Referenced by FailureReason(), and SetFailureReason().

◆ m_forceMarkObstaclesMode

bool PNS::ROUTER::m_forceMarkObstaclesMode = false
private

Definition at line 238 of file pns_router.h.

Referenced by StartDragging(), StartRouting(), and updateView().

◆ m_iface

◆ m_iterLimit

int PNS::ROUTER::m_iterLimit
private

Definition at line 237 of file pns_router.h.

Referenced by GetIterLimit(), ROUTER(), and SetIterLimit().

◆ m_lastNode

NODE* PNS::ROUTER::m_lastNode
private

Definition at line 229 of file pns_router.h.

Referenced by ROUTER().

◆ m_logger

LOGGER* PNS::ROUTER::m_logger
private

Definition at line 243 of file pns_router.h.

Referenced by FixRoute(), Logger(), Move(), ROUTER(), StartDragging(), StartRouting(), and ~ROUTER().

◆ m_mode

ROUTER_MODE PNS::ROUTER::m_mode
private

Definition at line 242 of file pns_router.h.

Referenced by isStartingPointRoutable(), Mode(), ROUTER(), SetMode(), and StartRouting().

◆ m_placer

◆ m_settings

ROUTING_SETTINGS* PNS::ROUTER::m_settings
private

Definition at line 240 of file pns_router.h.

Referenced by LoadSettings(), ROUTER(), Settings(), and ToggleCornerMode().

◆ m_shove

std::unique_ptr<SHOVE> PNS::ROUTER::m_shove
private

Definition at line 233 of file pns_router.h.

◆ m_sizes

SIZES_SETTINGS PNS::ROUTER::m_sizes
private

Definition at line 241 of file pns_router.h.

Referenced by isStartingPointRoutable(), Sizes(), StartRouting(), and UpdateSizes().

◆ m_state

◆ m_toolStatusbarName

wxString PNS::ROUTER::m_toolStatusbarName
private

Definition at line 245 of file pns_router.h.

◆ m_visibleViewArea

BOX2I PNS::ROUTER::m_visibleViewArea
private

Definition at line 225 of file pns_router.h.

Referenced by ROUTER(), SetVisibleViewArea(), and VisibleViewArea().

◆ m_world

std::unique_ptr<NODE> PNS::ROUTER::m_world
private

The documentation for this class was generated from the following files: