kicad/pcbnew/router/pns_router.h

298 lines
7.6 KiB
C++

/*
* KiRouter - a push-and-(sometimes-)shove PCB router
*
* Copyright (C) 2013-2014 CERN
* Copyright (C) 2016 KiCad Developers, see AUTHORS.txt for contributors.
* 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/>.
*/
#ifndef __PNS_ROUTER_H
#define __PNS_ROUTER_H
#include <list>
#include <memory>
#include <core/optional.h>
#include <boost/unordered_set.hpp>
#include <layers_id_colors_and_visibility.h>
#include <geometry/shape_line_chain.h>
#include "pns_routing_settings.h"
#include "pns_sizes_settings.h"
#include "pns_item.h"
#include "pns_itemset.h"
#include "pns_node.h"
namespace KIGFX
{
class VIEW;
class VIEW_GROUP;
}
namespace PNS {
class DEBUG_DECORATOR;
class NODE;
class DIFF_PAIR_PLACER;
class PLACEMENT_ALGO;
class LINE_PLACER;
class ITEM;
class ARC;
class LINE;
class SOLID;
class SEGMENT;
class JOINT;
class VIA;
class RULE_RESOLVER;
class SHOVE;
class DRAGGER;
class DRAG_ALGO;
class LOGGER;
enum ROUTER_MODE {
PNS_MODE_ROUTE_SINGLE = 1,
PNS_MODE_ROUTE_DIFF_PAIR,
PNS_MODE_TUNE_SINGLE,
PNS_MODE_TUNE_DIFF_PAIR,
PNS_MODE_TUNE_DIFF_PAIR_SKEW
};
enum DRAG_MODE
{
DM_CORNER = 0x1,
DM_SEGMENT = 0x2,
DM_VIA = 0x4,
DM_FREE_ANGLE = 0x8,
DM_ARC = 0x10,
DM_ANY = 0x17,
DM_COMPONENT = 0x20
};
/**
* ROUTER
*
* Main router class.
*/
class ROUTER_IFACE
{
public:
ROUTER_IFACE() {};
virtual ~ROUTER_IFACE() {};
virtual void SyncWorld( NODE* aNode ) = 0;
virtual void AddItem( ITEM* aItem ) = 0;
virtual void RemoveItem( ITEM* aItem ) = 0;
virtual bool IsAnyLayerVisible( const LAYER_RANGE& aLayer ) const = 0;
virtual bool IsItemVisible( const PNS::ITEM* aItem ) const = 0;
virtual bool IsOnLayer( const PNS::ITEM* aItem, int aLayer ) const = 0;
virtual void DisplayItem( const ITEM* aItem, int aColor = -1, int aClearance = -1, bool aEdit = false ) = 0;
virtual void DisplayRatline( const SHAPE_LINE_CHAIN& aRatline, int aColor = -1 ) = 0;
virtual void HideItem( ITEM* aItem ) = 0;
virtual void Commit() = 0;
virtual bool ImportSizes( SIZES_SETTINGS& aSizes, ITEM* aStartItem, int aNet ) = 0;
// virtual void Abort () = 0;
virtual void EraseView() = 0;
virtual void UpdateNet( int aNetCode ) = 0;
virtual PNS::NODE* GetWorld() const = 0;
virtual RULE_RESOLVER* GetRuleResolver() = 0;
virtual DEBUG_DECORATOR* GetDebugDecorator() = 0;
};
class ROUTER
{
private:
enum RouterState
{
IDLE,
DRAG_SEGMENT,
ROUTE_TRACK
};
public:
ROUTER();
~ROUTER();
void SetInterface( ROUTER_IFACE* aIface );
void SetMode ( ROUTER_MODE aMode );
ROUTER_MODE Mode() const { return m_mode; }
static ROUTER* GetInstance();
void ClearWorld();
void SyncWorld();
void SetView( KIGFX::VIEW* aView );
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();
int GetClearance( const ITEM* aA, const ITEM* aB ) const;
NODE* GetWorld() const
{
return m_world.get();
}
void FlipPosture();
void DisplayItem( const ITEM* aItem, int aColor = -1, int aClearance = -1, bool aEdit = false );
void DisplayItems( const ITEM_SET& aItems );
void DeleteTraces( ITEM* aStartItem, bool aWholeTrack );
void SwitchLayer( int layer );
void ToggleViaPlacement();
void SetOrthoMode( bool aEnable );
void ToggleRounded();
int GetCurrentLayer() const;
const std::vector<int> GetCurrentNets() const;
void DumpLog();
LOGGER* Logger();
RULE_RESOLVER* GetRuleResolver() const
{
return m_iface->GetRuleResolver();
}
bool IsPlacingVia() const;
const ITEM_SET QueryHoverItems( const VECTOR2I& aP );
const VECTOR2I SnapToItem( ITEM* aItem, VECTOR2I aP, bool& aSplitsSegment );
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 ) { m_iterLimit = aX; }
int GetIterLimit() const { return m_iterLimit; };
void SetShowIntermediateSteps( bool aX, int aSnapshotIter = -1 )
{
m_showInterSteps = aX;
m_snapshotIter = aSnapshotIter;
}
bool GetShowIntermediateSteps() const { return m_showInterSteps; }
int GetShapshotIter() const { return m_snapshotIter; }
ROUTING_SETTINGS& Settings() { return *m_settings; }
void CommitRouting( NODE* aNode );
/**
* Applies stored settings.
* @see Settings()
*/
void UpdateSizes( const SIZES_SETTINGS& aSizes );
/**
* Changes routing settings to ones passed in the parameter.
* @param aSettings are the new settings.
*/
void LoadSettings( ROUTING_SETTINGS* aSettings )
{
m_settings = aSettings;
}
SIZES_SETTINGS& Sizes()
{
return m_sizes;
}
ITEM* QueryItemByParent( const BOARD_ITEM* aItem ) const;
void SetFailureReason( const wxString& aReason ) { m_failureReason = aReason; }
const wxString& FailureReason() const { return m_failureReason; }
PLACEMENT_ALGO* Placer() { return m_placer.get(); }
ROUTER_IFACE* GetInterface() const
{
return m_iface;
}
private:
void movePlacing( const VECTOR2I& aP, ITEM* aItem );
void moveDragging( const VECTOR2I& aP, ITEM* aItem );
void eraseView();
void updateView( NODE* aNode, ITEM_SET& aCurrent, bool aDragging = false );
void clearViewFlags();
// optHoverItem queryHoverItemEx(const VECTOR2I& aP);
ITEM* pickSingleItem( ITEM_SET& aItems ) const;
void splitAdjacentSegments( NODE* aNode, ITEM* aSeg, const VECTOR2I& aP );
ITEM* syncPad( D_PAD* aPad );
ITEM* syncTrack( TRACK* aTrack );
ITEM* syncVia( VIA* aVia );
void commitPad( SOLID* aPad );
void commitSegment( SEGMENT* aTrack );
void commitVia( VIA* aVia );
void highlightCurrent( bool enabled );
void markViolations( NODE* aNode, ITEM_SET& aCurrent, NODE::ITEM_VECTOR& aRemoved );
bool isStartingPointRoutable( const VECTOR2I& aWhere, int aLayer );
VECTOR2I m_currentEnd;
RouterState m_state;
std::unique_ptr< NODE > m_world;
NODE* m_lastNode;
std::unique_ptr< PLACEMENT_ALGO > m_placer;
std::unique_ptr< DRAG_ALGO > m_dragger;
std::unique_ptr< SHOVE > m_shove;
ROUTER_IFACE* m_iface;
int m_iterLimit;
bool m_showInterSteps;
int m_snapshotIter;
bool m_violation;
bool m_forceMarkObstaclesMode = false;
ROUTING_SETTINGS* m_settings;
SIZES_SETTINGS m_sizes;
ROUTER_MODE m_mode;
LOGGER* m_logger;
wxString m_toolStatusbarName;
wxString m_failureReason;
};
}
#endif