KiCad PCB EDA Suite
Loading...
Searching...
No Matches
router_preview_item.cpp
Go to the documentation of this file.
1/*
2 * KiRouter - a push-and-(sometimes-)shove PCB router
3 *
4 * Copyright (C) 2013-2014 CERN
5 * Copyright (C) 2016-2023 KiCad Developers, see AUTHORS.txt for contributors.
6 * Author: Tomasz Wlostowski <[email protected]>
7 *
8 * This program is free software: you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <deque>
23#include <gal/color4d.h>
24
26#include <geometry/shape_rect.h>
28#include <pcb_painter.h>
29#include <trigo.h>
30
31#include "router_preview_item.h"
32
33#include "pns_arc.h"
34#include "pns_line.h"
35#include "pns_segment.h"
36#include "pns_via.h"
37#include "pns_kicad_iface.h"
38
39using namespace KIGFX;
40
41
43 KIGFX::VIEW* aView, int aFlags ) :
45 m_iface( aIface ),
46 m_view( aView ),
47 m_shape( nullptr ),
48 m_hole( nullptr ),
49 m_flags( aFlags )
50{
51 BOARD_ITEM* boardItem = aItem ? aItem->BoardItem() : nullptr;
52
53 // A PNS::SOLID for an edge-cut item must have 0 width for collision calculations, but when
54 // highlighting an edge we want to show it with its true width
55 if( boardItem && boardItem->IsOnLayer( Edge_Cuts ) )
56 {
57 m_shape = aItem->Shape( -1 )->Clone();
58
59 switch( m_shape->Type() )
60 {
61 case SH_SEGMENT: static_cast<SHAPE_SEGMENT*>( m_shape )->SetWidth( 0 ); break;
62 case SH_ARC: static_cast<SHAPE_ARC*>( m_shape )->SetWidth( 0 ); break;
63 case SH_LINE_CHAIN: static_cast<SHAPE_LINE_CHAIN*>( m_shape )->SetWidth( 0 ); break;
64 default: /* remaining shapes don't have width */ break;
65 }
66 }
67 else if( aItem )
68 {
69 // TODO(JE) padstacks -- need to know the layer here
70 m_shape = aItem->Shape( -1 )->Clone();
71
72 if( aItem->Hole() )
73 m_hole = aItem->Hole()->Shape( -1 )->Clone();
74 }
75
76 m_clearance = -1;
78
79 m_showClearance = false;
80
81 // initialize variables, overwritten by Update( aItem ), if aItem != NULL
83 m_width = ( aFlags & PNS_SEMI_SOLID ) ? 1 : 0;
85
86 if( aItem )
87 Update( aItem );
88}
89
90
92 KIGFX::VIEW* aView ) :
94 m_iface( aIface ),
95 m_view( aView ),
96 m_flags( 0 )
97{
98 m_shape = aShape.Clone();
99 m_hole = nullptr;
100
101 m_clearance = -1;
103
104 m_showClearance = false;
105
106 // initialize variables, overwritten by Update( aItem ), if aItem != NULL
108 m_width = 0;
110}
111
112
114{
115 delete m_shape;
116 delete m_hole;
117}
118
119
121{
123
124 if( const PNS::LINE* l = dyn_cast<const PNS::LINE*>( aItem ) )
125 {
126 if( !l->SegmentCount() )
127 return;
128 }
129 else if( const PNS::VIA* v = dyn_cast<const PNS::VIA*>( aItem ) )
130 {
131 if( v->IsVirtual() )
132 return;
133 }
134
135 if( m_originLayer < 0 )
136 m_originLayer = 0;
137
140 m_color.a = 0.8;
141 m_depth = m_originDepth - ( ( aItem->Layers().Start() + 1 ) * LayerDepthFactor );
142
143 switch( aItem->Kind() )
144 {
147 m_width = static_cast<const PNS::LINE*>( aItem )->Width();
148 break;
149
150 case PNS::ITEM::ARC_T:
152 m_width = static_cast<const PNS::ARC*>( aItem )->Width();
153 break;
154
157 m_width = static_cast<const PNS::SEGMENT*>( aItem )->Width();
158 break;
159
160 case PNS::ITEM::VIA_T:
161 {
164 m_width = 0;
165 m_color = COLOR4D( 0.7, 0.7, 0.7, 0.8 );
166 m_depth = m_originDepth - ( static_cast<double>( PCB_LAYER_ID_COUNT ) * LayerDepthFactor );
167
168 delete m_shape;
169 m_shape = nullptr;
170
171 auto via = static_cast<const PNS::VIA*>( aItem );
172 int shapeLayer = -1;
173 int largestDiameter = 0;
174
175 for( int layer : via->UniqueShapeLayers() )
176 {
177 if( via->Diameter( layer ) > largestDiameter )
178 {
179 largestDiameter = via->Diameter( layer );
180 shapeLayer = layer;
181 }
182 }
183
184 if( aItem->Shape( shapeLayer ) )
185 m_shape = aItem->Shape( shapeLayer )->Clone();
186
187 delete m_hole;
188 m_hole = nullptr;
189
190 if( aItem->Hole() )
191 m_hole = aItem->Hole()->Shape( -1 )->Clone();
192
193 break;
194 }
195
198 break;
199
200 default:
201 break;
202 }
203
204 if( aItem->Marker() & PNS::MK_VIOLATION )
206
207 if( m_flags & PNS_COLLISION )
208 m_color = COLOR4D( 0, 1, 0, 1 );
209
210 if( m_flags & PNS_HOVER_ITEM )
211 m_color = m_color.WithAlpha( 1.0 );
212}
213
214
216{
217 BOX2I bbox;
218
219 switch( m_type )
220 {
221 case PR_SHAPE:
222 if( m_shape )
223 {
224 bbox = m_shape->BBox();
225 bbox.Inflate( m_width / 2 );
226 }
227
228 if( m_hole )
229 bbox.Merge( m_hole->BBox() );
230
231 return bbox;
232
233 case PR_POINT:
234 bbox = BOX2I ( m_pos - VECTOR2I( 100000, 100000 ), VECTOR2I( 200000, 200000 ) );
235 return bbox;
236
237 default:
238 break;
239 }
240
241 return bbox;
242}
243
244
246{
247 wxCHECK( aL, /* void */ );
248
249 gal->SetIsFill( false );
250
251 for( int s = 0; s < aL->GetSegmentCount(); s++ )
252 {
253 SEG seg = aL->GetSegment( s );
254
255 if( seg.A == seg.B )
256 {
257 gal->SetIsFill( true );
258 gal->SetIsStroke( false );
259 gal->DrawCircle( seg.A, gal->GetLineWidth() / 2 );
260 gal->SetIsFill( false );
261 gal->SetIsStroke( true );
262 }
263 else
264 {
265 gal->DrawLine( seg.A, seg.B );
266 }
267 }
268
269 const SHAPE_LINE_CHAIN* lineChain = dynamic_cast<const SHAPE_LINE_CHAIN*>( aL );
270
271 for( size_t s = 0; lineChain && s < lineChain->ArcCount(); s++ )
272 {
273 const SHAPE_ARC& arc = lineChain->CArcs()[s];
274 EDA_ANGLE start_angle = arc.GetStartAngle();
275 EDA_ANGLE angle = arc.GetCentralAngle();
276
277 gal->DrawArc( arc.GetCenter(), arc.GetRadius(), start_angle, angle);
278 }
279
280 if( aL->IsClosed() )
281 gal->DrawLine( aL->GetSegment( -1 ).B, aL->GetSegment( 0 ).A );
282}
283
284
285void ROUTER_PREVIEW_ITEM::drawShape( const SHAPE* aShape, KIGFX::GAL* gal ) const
286{
287 bool holeDrawn = false;
288 bool showClearance = m_showClearance;
289
290 // Always show clearance when we're in collision, even if the preference is off
291 if( ( m_flags & PNS_COLLISION ) > 0 )
292 showClearance = true;
293
294 switch( aShape->Type() )
295 {
297 {
298 const SHAPE_LINE_CHAIN_BASE* l = (const SHAPE_LINE_CHAIN_BASE*) aShape;
299
300 if( showClearance && m_clearance > 0 )
301 {
302 gal->SetLineWidth( m_width + 2 * m_clearance );
303 drawLineChain( l, gal );
304 }
305
306 gal->SetLayerDepth( m_depth );
307 gal->SetLineWidth( m_width );
308 gal->SetStrokeColor( m_color );
309 gal->SetFillColor( m_color );
310 drawLineChain( l, gal );
311 break;
312 }
313
314 case SH_LINE_CHAIN:
315 {
316 const SHAPE_LINE_CHAIN* l = (const SHAPE_LINE_CHAIN*) aShape;
317 const int w = m_width;
318
319 if( showClearance && m_clearance > 0 )
320 {
321 gal->SetLineWidth( w + 2 * m_clearance );
322 drawLineChain( l, gal );
323 }
324
325 gal->SetLayerDepth( m_depth );
326 gal->SetLineWidth( w );
327 gal->SetStrokeColor( m_color );
328 gal->SetFillColor( m_color );
329 drawLineChain( l, gal );
330 break;
331 }
332
333 case SH_SEGMENT:
334 {
335 const SHAPE_SEGMENT* s = (const SHAPE_SEGMENT*) aShape;
336 const int w = s->GetWidth();
337
338 gal->SetIsStroke( false );
339
340 if( showClearance && m_clearance > 0 )
341 {
342 gal->SetLineWidth( w + 2 * m_clearance );
343 gal->DrawSegment( s->GetSeg().A, s->GetSeg().B, s->GetWidth() + 2 * m_clearance );
344 }
345
346 gal->SetLayerDepth( m_depth );
347 gal->SetLineWidth( w );
348 gal->SetFillColor( m_color );
349 gal->DrawSegment( s->GetSeg().A, s->GetSeg().B, s->GetWidth() );
350 break;
351 }
352
353 case SH_CIRCLE:
354 {
355 const SHAPE_CIRCLE* c = static_cast<const SHAPE_CIRCLE*>( aShape );
356 gal->SetStrokeColor( m_color );
357
358 if( showClearance && m_clearance > 0 )
359 {
360 gal->SetIsStroke( false );
361 gal->DrawCircle( c->GetCenter(), c->GetRadius() + m_clearance );
362 }
363
364 gal->SetLayerDepth( m_depth );
365
366 if( m_hole && dynamic_cast<SHAPE_CIRCLE*>( m_hole ) )
367 {
368 const SHAPE_CIRCLE* h = static_cast<const SHAPE_CIRCLE*>( m_hole );
369 int halfWidth = m_width / 2;
370
371 gal->SetIsStroke( true );
372 gal->SetIsFill( false );
373 gal->SetLineWidth( halfWidth + c->GetRadius() - h->GetRadius() );
374 gal->DrawCircle( c->GetCenter(), ( halfWidth + c->GetRadius() + h->GetRadius() ) / 2 );
375
376 holeDrawn = true;
377 }
378 else
379 {
380 gal->SetIsStroke( m_width ? true : false );
381 gal->SetLineWidth( m_width );
382 gal->SetFillColor( m_color );
383 gal->DrawCircle( c->GetCenter(), c->GetRadius() );
384 }
385
386 break;
387 }
388
389 case SH_RECT:
390 {
391 const SHAPE_RECT* r = (const SHAPE_RECT*) aShape;
392 gal->SetFillColor( m_color );
393
394 if( showClearance && m_clearance > 0 )
395 {
396 VECTOR2I p0( r->GetPosition() ), s( r->GetSize() );
397 gal->SetIsStroke( true );
398 gal->SetLineWidth( 2 * m_clearance );
399 gal->DrawLine( p0, VECTOR2I( p0.x + s.x, p0.y ) );
400 gal->DrawLine( p0, VECTOR2I( p0.x, p0.y + s.y ) );
401 gal->DrawLine( p0 + s , VECTOR2I( p0.x + s.x, p0.y ) );
402 gal->DrawLine( p0 + s, VECTOR2I( p0.x, p0.y + s.y ) );
403 }
404
405 gal->SetLayerDepth( m_depth );
406 gal->SetIsStroke( m_width ? true : false );
407 gal->SetLineWidth( m_width);
408 gal->SetStrokeColor( m_color );
409 gal->DrawRectangle( r->GetPosition(), r->GetPosition() + r->GetSize() );
410
411 break;
412 }
413
414 case SH_SIMPLE:
415 {
416 const SHAPE_SIMPLE* c = (const SHAPE_SIMPLE*) aShape;
417 std::deque<VECTOR2D> polygon = std::deque<VECTOR2D>();
418
419 for( int i = 0; i < c->PointCount(); i++ )
420 {
421 polygon.push_back( c->CDPoint( i ) );
422 }
423
424 gal->SetFillColor( m_color );
425
426 if( showClearance && m_clearance > 0 )
427 {
428 gal->SetIsStroke( true );
429 gal->SetLineWidth( 2 * m_clearance );
430
431 // need the implicit last segment to be explicit for DrawPolyline
432 polygon.push_back( c->CDPoint( 0 ) );
433 gal->DrawPolyline( polygon );
434 }
435
436 gal->SetLayerDepth( m_depth );
437 gal->SetIsStroke( m_width ? true : false );
438 gal->SetLineWidth( m_width );
439 gal->SetStrokeColor( m_color );
440 gal->DrawPolygon( polygon );
441 break;
442 }
443
444 case SH_ARC:
445 {
446 const SHAPE_ARC* arc = static_cast<const SHAPE_ARC*>( aShape );
447 const int w = arc->GetWidth();
448 EDA_ANGLE start_angle = arc->GetStartAngle();
449 EDA_ANGLE angle = arc->GetCentralAngle();
450
451 gal->SetIsFill( false );
452 gal->SetIsStroke( true );
453
454 if( showClearance && m_clearance > 0 )
455 {
456 gal->SetLineWidth( w + 2 * m_clearance );
457 gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, angle );
458 }
459
460 gal->SetLayerDepth( m_depth );
461 gal->SetStrokeColor( m_color );
462 gal->SetFillColor( m_color );
463 gal->SetLineWidth( w );
464 gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, angle );
465 break;
466 }
467
468 case SH_COMPOUND:
469 wxFAIL_MSG( wxT( "Router preview item: nested compound shapes not supported" ) );
470 break;
471
472 case SH_POLY_SET:
473 wxFAIL_MSG( wxT( "Router preview item: SHAPE_POLY_SET not supported" ) );
474 break;
475
476 case SH_NULL:
477 break;
478 }
479
480 if( m_hole && !holeDrawn )
481 {
482 gal->SetLayerDepth( m_depth );
483 gal->SetIsStroke( true );
484 gal->SetIsFill( false );
485 gal->SetStrokeColor( m_color );
486 gal->SetLineWidth( 1 );
487
488 SHAPE_CIRCLE* circle = dynamic_cast<SHAPE_CIRCLE*>( m_hole );
489 SHAPE_SEGMENT* slot = dynamic_cast<SHAPE_SEGMENT*>( m_hole );
490
491 if( circle )
492 gal->DrawCircle( circle->GetCenter(), circle->GetRadius() );
493 else if( slot )
494 gal->DrawSegment( slot->GetSeg().A, slot->GetSeg().B, slot->GetWidth() );
495 }
496}
497
498
499void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::VIEW* aView ) const
500{
501 GAL* gal = aView->GetGAL();
502 //col.Brighten(0.7);
503
504 if( m_type == PR_SHAPE )
505 {
506 if( !m_shape )
507 return;
508
509 // N.B. The order of draw here is important
510 // Cairo doesn't current support z-ordering, so we need
511 // to draw the clearance first to ensure it is in the background
513
514 //TODO(snh) Add configuration option for the color/alpha here
515 gal->SetStrokeColor( COLOR4D( DARKDARKGRAY ).WithAlpha( 0.9 ) );
516 gal->SetFillColor( COLOR4D( DARKDARKGRAY ).WithAlpha( 0.7 ) );
517 gal->SetIsStroke( m_width ? true : false );
518 gal->SetIsFill( true );
519
520 // Semi-solids (ie: rule areas) which are not in collision are sketched (ie: outline only)
521 if( ( m_flags & PNS_SEMI_SOLID ) > 0 && ( m_flags & PNS_COLLISION ) == 0 )
522 gal->SetIsFill( false );
523
525 {
526 std::vector<const SHAPE*> subshapes;
527 m_shape->GetIndexableSubshapes( subshapes );
528
529 for( const SHAPE* shape : subshapes )
530 drawShape( shape, gal );
531 }
532 else
533 {
534 drawShape( m_shape, gal );
535 }
536 }
537}
538
539
541{
542 auto settings = static_cast<PCB_RENDER_SETTINGS*>( m_view->GetPainter()->GetSettings() );
543
544 COLOR4D color = settings->GetLayerColor( aLayer );
545
546 if( m_flags & PNS_HEAD_TRACE )
547 return color.Saturate( 1.0 );
548 else if( m_flags & PNS_HOVER_ITEM )
549 return color.Brightened( 0.7 );
550
551 return color;
552}
int color
Definition: DXF_plotter.cpp:58
BOX2< VECTOR2I > BOX2I
Definition: box2.h:922
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:79
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Test to see if this object is on the given layer.
Definition: board_item.h:319
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:558
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:658
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:89
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
double a
Alpha component.
Definition: color4d.h:395
Abstract interface for drawing on a 2D-surface.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
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 DrawArc(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle)
Draw an arc.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
float GetLineWidth() const
Get the line width.
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
int GetLayerOrder(int aLayer) const
Return rendering order of a particular layer.
Definition: view.cpp:656
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
Definition: view.h:199
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:217
const SHAPE * Shape(int aLayer) const override
Return the geometrical shape of the item.
Definition: pns_hole.h:69
Base class for PNS router board items.
Definition: pns_item.h:97
virtual const SHAPE * Shape(int aLayer) const
Return the geometrical shape of the item.
Definition: pns_item.h:229
const PNS_LAYER_RANGE & Layers() const
Definition: pns_item.h:199
PnsKind Kind() const
Return the type (kind) of the item.
Definition: pns_item.h:170
@ SEGMENT_T
Definition: pns_item.h:106
virtual HOLE * Hole() const
Definition: pns_item.h:291
virtual BOARD_ITEM * BoardItem() const
Definition: pns_item.h:194
virtual int Marker() const
Definition: pns_item.h:250
Represents a track on a PCB, connecting two non-trivial joints (that is, vias, pads,...
Definition: pns_line.h:62
virtual PCB_LAYER_ID GetBoardLayerFromPNSLayer(int aLayer) const =0
int Start() const
Definition: pns_layerset.h:86
ROUTER_PREVIEW_ITEM(const SHAPE &aShape, PNS::ROUTER_IFACE *aIface, KIGFX::VIEW *aView)
void SetWidth(int aWidth)
static constexpr double LayerDepthFactor
We draw this item on a single layer, but we stack up all the layers from the various components that ...
void Update(const PNS::ITEM *aItem)
const KIGFX::COLOR4D getLayerColor(int aLayer) const
virtual void ViewDraw(int aLayer, KIGFX::VIEW *aView) const override
Draw the parts of the object belonging to layer aLayer.
void drawLineChain(const SHAPE_LINE_CHAIN_BASE *aL, KIGFX::GAL *aGal) const
const BOX2I ViewBBox() const override
Return the bounding box of the item covering all its layers.
void drawShape(const SHAPE *aShape, KIGFX::GAL *aGal) const
PNS::ROUTER_IFACE * m_iface
Definition: seg.h:42
VECTOR2I A
Definition: seg.h:49
VECTOR2I B
Definition: seg.h:50
EDA_ANGLE GetCentralAngle() const
Definition: shape_arc.cpp:538
int GetWidth() const
Definition: shape_arc.h:168
double GetRadius() const
Definition: shape_arc.cpp:554
EDA_ANGLE GetStartAngle() const
Definition: shape_arc.cpp:507
const VECTOR2I & GetCenter() const
Definition: shape_arc.cpp:523
virtual void GetIndexableSubshapes(std::vector< const SHAPE * > &aSubshapes) const
Definition: shape.h:115
virtual bool HasIndexableSubshapes() const
Definition: shape.h:108
SHAPE_TYPE Type() const
Return the type of the shape.
Definition: shape.h:98
int GetRadius() const
Definition: shape_circle.h:118
const VECTOR2I GetCenter() const
Definition: shape_circle.h:123
virtual size_t GetSegmentCount() const =0
virtual bool IsClosed() const =0
virtual const SEG GetSegment(int aIndex) const =0
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
const std::vector< SHAPE_ARC > & CArcs() const
size_t ArcCount() const
const VECTOR2I & GetPosition() const
Definition: shape_rect.h:160
const VECTOR2I GetSize() const
Definition: shape_rect.h:168
const SEG & GetSeg() const
int GetWidth() const
Represent a simple polygon consisting of a zero-thickness closed chain of connected line segments.
Definition: shape_simple.h:42
int PointCount() const
Return the number of points (vertices) in this polygon.
Definition: shape_simple.h:88
const VECTOR2D CDPoint(int aIndex) const
Return a given point as a vector with elements of type double.
Definition: shape_simple.h:113
An abstract shape on 2D plane.
Definition: shape.h:126
virtual SHAPE * Clone() const
Return a dynamically allocated copy of the shape.
Definition: shape.h:148
virtual const BOX2I BBox(int aClearance=0) const =0
Compute a bounding box of the shape, with a margin of aClearance a collision.
@ DARKDARKGRAY
Definition: color4d.h:45
@ LAYER_SELECT_OVERLAY
currently selected items overlay
Definition: layer_ids.h:220
@ LAYER_VIAS
Meta control for all vias opacity/visibility.
Definition: layer_ids.h:194
@ Edge_Cuts
Definition: layer_ids.h:112
@ PCB_LAYER_ID_COUNT
Definition: layer_ids.h:135
The Cairo implementation of the graphics abstraction layer.
Definition: color4d.cpp:247
@ MK_VIOLATION
Definition: pns_item.h:43
#define PNS_HEAD_TRACE
#define PNS_SEMI_SOLID
#define PNS_HOVER_ITEM
#define PNS_COLLISION
@ SH_POLY_SET
set of polygons (with holes, etc.)
Definition: shape.h:52
@ SH_RECT
axis-aligned rectangle
Definition: shape.h:47
@ SH_CIRCLE
circle
Definition: shape.h:50
@ SH_SIMPLE
simple polygon
Definition: shape.h:51
@ SH_NULL
empty shape (no shape...),
Definition: shape.h:55
@ SH_SEGMENT
line segment
Definition: shape.h:48
@ SH_ARC
circular arc
Definition: shape.h:54
@ SH_POLY_SET_TRIANGLE
a single triangle belonging to a POLY_SET triangulation
Definition: shape.h:56
@ SH_LINE_CHAIN
line chain (polyline)
Definition: shape.h:49
@ SH_COMPOUND
compound shape, consisting of multiple simple shapes
Definition: shape.h:53
@ NOT_USED
the 3d code uses this value
Definition: typeinfo.h:79
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:691