KiCad PCB EDA Suite
Loading...
Searching...
No Matches
ratsnest_view_item.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KICAD, a free EDA CAD application.
3 *
4 * Copyright (C) 2013 CERN
5 * Copyright (C) 2018-2023 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * @author Maciej Suminski <[email protected]>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, you may find one here:
21 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22 * or you may search the http://www.gnu.org website for the version 2 license,
23 * or you may write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
32
33#include <kiface_base.h>
35#include <pcbnew_settings.h>
36#include <pcb_painter.h>
38#include <layer_ids.h>
39#include <pcb_base_frame.h>
40#include <view/view.h>
41
42#include <memory>
43#include <utility>
44
45
46RATSNEST_VIEW_ITEM::RATSNEST_VIEW_ITEM( std::shared_ptr<CONNECTIVITY_DATA> aData ) :
48 m_data( std::move( aData ) )
49{
50}
51
52
54{
55 // Make it always visible
56 BOX2I bbox;
57 bbox.SetMaximum();
58
59 return bbox;
60}
61
62
63void RATSNEST_VIEW_ITEM::ViewDraw( int aLayer, KIGFX::VIEW* aView ) const
64{
65 std::unique_lock<KISPINLOCK> lock( m_data->GetLock(), std::try_to_lock );
66
67 if( !lock )
68 return;
69
70 constexpr int CROSS_SIZE = 200000;
71
72 PCBNEW_SETTINGS* cfg = dynamic_cast<PCBNEW_SETTINGS*>( Kiface().KifaceSettings() );
73
74 if( !cfg )
75 return;
76
77 auto rs = static_cast<KIGFX::PCB_RENDER_SETTINGS*>( aView->GetPainter()->GetSettings() );
78 KIGFX::GAL* gal = aView->GetGAL();
79 gal->SetIsStroke( true );
80 gal->SetIsFill( false );
82
83 std::set<int> highlightedNets = rs->GetHighlightNetCodes();
84 const std::set<int>& hiddenNets = rs->GetHiddenNets();
85
86 COLOR4D defaultColor = rs->GetColor( nullptr, LAYER_RATSNEST );
87 COLOR4D color = defaultColor;
88 const bool colorByNet = rs->GetNetColorMode() != NET_COLOR_MODE::OFF;
89 const bool dimStatic = m_data->GetLocalRatsnest().size() > 0 || highlightedNets.size() > 0;
90
91 std::map<int, KIGFX::COLOR4D>& netColors = rs->GetNetColorMap();
92 std::map<wxString, KIGFX::COLOR4D>& ncColors = rs->GetNetclassColorMap();
93 const std::map<int, wxString>& ncMap = m_data->GetNetclassMap();
94
95 const bool onlyVisibleLayers = cfg->m_Display.m_RatsnestMode == RATSNEST_MODE::VISIBLE;
96 LSET visibleLayers;
97
98 // If we are in "other layers off" mode, the active layer is the only visible layer
99 if( rs->m_ContrastModeDisplay == HIGH_CONTRAST_MODE::HIDDEN )
100 {
101 visibleLayers.set( rs->GetPrimaryHighContrastLayer() );
102 }
103 else
104 {
106 [&]( PCB_LAYER_ID layer )
107 {
108 if( aView->IsLayerVisible( layer ) )
109 visibleLayers.set( layer );
110 } );
111 }
112
113 auto adjustColor =
114 [&]( COLOR4D& color_base, double brightnessDelta, double alpha )
115 {
116 if( rs->GetColor( nullptr, LAYER_PCB_BACKGROUND ).GetBrightness() < 0.5 )
117 return color_base.Brightened( brightnessDelta ).WithAlpha( std::min( alpha, 1.0 ) );
118 else
119 return color_base.Darkened( brightnessDelta ).WithAlpha( std::min( alpha, 1.0 ) );
120 };
121
123
124 // Draw the "dynamic" ratsnest (i.e. for objects that may be currently being moved)
125 for( const RN_DYNAMIC_LINE& l : m_data->GetLocalRatsnest() )
126 {
127 if( hiddenNets.count( l.netCode ) )
128 continue;
129
130 if( colorByNet && netColors.count( l.netCode ) )
131 color = netColors.at( l.netCode );
132 else if( colorByNet && ncMap.count( l.netCode ) && ncColors.count( ncMap.at( l.netCode ) ) )
133 color = ncColors.at( ncMap.at( l.netCode ) );
134 else
135 color = defaultColor;
136
137 if( color == COLOR4D::UNSPECIFIED )
138 color = defaultColor;
139
140 gal->SetStrokeColor( adjustColor( color, 0.5, color.a + 0.3 ) );
141
142 if( l.a == l.b )
143 {
144 gal->DrawLine( VECTOR2I( l.a.x - CROSS_SIZE, l.a.y - CROSS_SIZE ),
145 VECTOR2I( l.b.x + CROSS_SIZE, l.b.y + CROSS_SIZE ) );
146 gal->DrawLine( VECTOR2I( l.a.x - CROSS_SIZE, l.a.y + CROSS_SIZE ),
147 VECTOR2I( l.b.x + CROSS_SIZE, l.b.y - CROSS_SIZE ) );
148 }
149 else
150 {
151 if( curved_ratsnest )
152 {
153 int dx = l.b.x - l.a.x;
154 int dy = l.b.y - l.a.y;
155 const VECTOR2I center = VECTOR2I( l.a.x + 0.5 * dx - 0.1 * dy,
156 l.a.y + 0.5 * dy + 0.1 * dx );
157 gal->DrawCurve( l.a, center, center, l.b );
158 }
159 else
160 {
161 gal->DrawLine( l.a, l.b );
162 }
163 }
164 }
165
166 for( int i = 1 /* skip "No Net" at [0] */; i < m_data->GetNetCount(); ++i )
167 {
168 if( hiddenNets.count( i ) )
169 continue;
170
171 RN_NET* net = m_data->GetRatsnestForNet( i );
172
173 if( !net || m_data->GetConnectivityAlgo()->IsNetDirty( i ) )
174 continue;
175
176 if( colorByNet && netColors.count( i ) )
177 color = netColors.at( i );
178 else if( colorByNet && ncMap.count( i ) && ncColors.count( ncMap.at( i ) ) )
179 color = ncColors.at( ncMap.at( i ) );
180 else
181 color = defaultColor;
182
183 if( color == COLOR4D::UNSPECIFIED )
184 color = defaultColor;
185
186 if( dimStatic )
187 color = adjustColor( color, 0.0, color.a / 2 );
188
189 // Draw the "static" ratsnest
190 if( highlightedNets.count( i ) )
191 gal->SetStrokeColor( adjustColor( color, 0.8, color.a + 0.4 ) );
192 else
193 gal->SetStrokeColor( color ); // using the default ratsnest color for not highlighted
194
195 for( const CN_EDGE& edge : net->GetEdges() )
196 {
197 if( !edge.IsVisible() )
198 continue;
199
200 const std::shared_ptr<const CN_ANCHOR>& sourceNode = edge.GetSourceNode();
201 const std::shared_ptr<const CN_ANCHOR>& targetNode = edge.GetTargetNode();
202
203 if( !sourceNode || sourceNode->Dirty() || !targetNode || targetNode->Dirty() )
204 continue;
205
206 const VECTOR2I source( sourceNode->Pos() );
207 const VECTOR2I target( targetNode->Pos() );
208
209 bool enable = !sourceNode->GetNoLine() && !targetNode->GetNoLine();
210 bool show;
211
212 // If the global ratsnest is currently enabled, the local ratsnest should be easy to
213 // turn off, so either element can disable it.
214 // If the global ratsnest is disabled, the local ratsnest should be easy to turn on
215 // so either element can enable it.
217 {
218 show = sourceNode->Parent()->GetLocalRatsnestVisible() &&
219 targetNode->Parent()->GetLocalRatsnestVisible();
220 }
221 else
222 {
223 show = sourceNode->Parent()->GetLocalRatsnestVisible() ||
224 targetNode->Parent()->GetLocalRatsnestVisible();
225 }
226
227 if( onlyVisibleLayers && show )
228 {
229 LSET sourceLayers = sourceNode->Parent()->GetLayerSet();
230 LSET targetLayers = targetNode->Parent()->GetLayerSet();
231
232 if( !( sourceLayers & visibleLayers ).any() ||
233 !( targetLayers & visibleLayers ).any() )
234 {
235 show = false;
236 }
237 }
238
239 if ( enable && show )
240 {
241 if ( source == target )
242 {
243 gal->DrawLine( VECTOR2I( source.x - CROSS_SIZE, source.y - CROSS_SIZE ),
244 VECTOR2I( source.x + CROSS_SIZE, source.y + CROSS_SIZE ) );
245 gal->DrawLine( VECTOR2I( source.x - CROSS_SIZE, source.y + CROSS_SIZE ),
246 VECTOR2I( source.x + CROSS_SIZE, source.y - CROSS_SIZE ) );
247 }
248 else
249 {
250 if( curved_ratsnest )
251 {
252 int dx = target.x - source.x;
253 int dy = target.y - source.y;
254 const VECTOR2I center = VECTOR2I( source.x + 0.5 * dx - 0.1 * dy,
255 source.y + 0.5 * dy + 0.1 * dx );
256 gal->DrawCurve( source, center, center, target );
257 }
258 else
259 {
260 gal->DrawLine( source, target );
261 }
262 }
263 }
264 }
265 }
266}
267
268
269void RATSNEST_VIEW_ITEM::ViewGetLayers( int aLayers[], int& aCount ) const
270{
271 aCount = 1;
272 aLayers[0] = LAYER_RATSNEST;
273}
274
int color
Definition: DXF_plotter.cpp:58
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
@ curved_ratsnest
BASE_SET & set(size_t pos=std::numeric_limits< size_t >::max(), bool value=true)
Definition: base_set.h:61
void SetMaximum()
Definition: box2.h:70
CN_EDGE represents a point-to-point connection, whether realized or unrealized (ie: tracks etc.
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:89
APP_SETTINGS_BASE * KifaceSettings() const
Definition: kiface_base.h:95
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
COLOR4D WithAlpha(double aAlpha) const
Return a color with the same color, but the given alpha.
Definition: color4d.h:311
COLOR4D Darkened(double aFactor) const
Return a color that is darker by a given factor, without modifying object.
Definition: color4d.h:282
COLOR4D Brightened(double aFactor) const
Return a color that is brighter by a given factor, without modifying object.
Definition: color4d.h:268
Abstract interface for drawing on a 2D-surface.
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
virtual void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint, double aFilterValue=0.0)
Draw a cubic bezier spline.
double GetWorldScale() const
Get the world scale.
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
PCB specific render settings.
Definition: pcb_painter.h:78
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
Definition: view.h:203
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
Definition: view.h:418
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:221
LSET is a set of PCB_LAYER_IDs.
Definition: lset.h:35
void RunOnLayers(const std::function< void(PCB_LAYER_ID)> &aFunction) const
Execute a function on each layer of the LSET.
Definition: lset.h:252
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:732
DISPLAY_OPTIONS m_Display
const BOX2I ViewBBox() const override
RATSNEST_VIEW_ITEM(std::shared_ptr< CONNECTIVITY_DATA > aData)
Class that draws missing connections on a PCB.
std::shared_ptr< CONNECTIVITY_DATA > m_data
Object containing ratsnest data.
void ViewGetLayers(int aLayers[], int &aCount) const override
void ViewDraw(int aLayer, KIGFX::VIEW *aView) const override
Describe ratsnest for a single net.
Definition: ratsnest_data.h:63
const std::vector< CN_EDGE > & GetEdges() const
Definition: ratsnest_data.h:96
@ LAYER_PCB_BACKGROUND
PCB background color.
Definition: layer_ids.h:224
@ LAYER_RATSNEST
Definition: layer_ids.h:208
PCB_LAYER_ID
A quick note on layer IDs:
Definition: layer_ids.h:60
STL namespace.
Class that computes missing connections on a PCB.
@ NOT_USED
the 3d code uses this value
Definition: typeinfo.h:79
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:673