64std::optional<INTERSECTABLE_GEOM> GetBoardIntersectable(
const BOARD_ITEM& aItem )
66 switch( aItem.
Type() )
118std::optional<int64_t> FindSquareDistanceToItem(
const BOARD_ITEM& item,
const VECTOR2I& aPos )
120 std::optional<INTERSECTABLE_GEOM> intersectable = GetBoardIntersectable( item );
121 std::optional<NEARABLE_GEOM> nearable;
187 auto constructionItemsBatch = std::make_unique<CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM_BATCH>();
189 std::vector<VECTOR2I> referenceOnlyPoints;
193 std::vector<KIGFX::CONSTRUCTION_GEOM::DRAWABLE> constructionDrawables;
201 case SHAPE_T::SEGMENT:
203 if( !aExtensionOnly )
211 constructionDrawables.emplace_back(
213 constructionDrawables.emplace_back(
221 constructionDrawables.emplace_back( shape.
GetStart() );
222 constructionDrawables.emplace_back( shape.
GetEnd() );
225 referenceOnlyPoints.emplace_back( shape.
GetStart() );
226 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
232 if( !aExtensionOnly )
234 constructionDrawables.push_back(
242 constructionDrawables.push_back(
245 constructionDrawables.push_back( shape.
GetCenter() );
251 constructionDrawables.emplace_back( shape.
GetStart() );
252 constructionDrawables.emplace_back( shape.
GetEnd() );
255 referenceOnlyPoints.emplace_back( shape.
GetStart() );
256 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
261 case SHAPE_T::CIRCLE:
262 case SHAPE_T::RECTANGLE:
264 constructionDrawables.push_back( shape.
GetCenter() );
279 std::move( constructionDrawables ),
283 if( referenceOnlyPoints.size() )
290 std::move( constructionItemsBatch ), aIsPersistent );
296 const int c_gridSnapEpsilon_sq = 4;
303 std::vector<VECTOR2I> points;
305 const SEG testSegments[] = {
SEG( aligned, aligned +
VECTOR2( 1, 0 ) ),
310 for(
const SEG& seg : testSegments )
315 points.push_back( *vec );
322 for(
const VECTOR2I& pt : { aSeg.
A, aSeg.
B } )
324 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
326 if( d_sq < min_d_sq )
336 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
338 if( d_sq < min_d_sq )
356 std::vector<VECTOR2I> points;
369 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
371 if( d_sq < min_d_sq )
381 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
383 if( d_sq < min_d_sq )
400 if( item->
HitTest( aMousePos ) )
404 double minDist = std::numeric_limits<double>::max();
405 ANCHOR* nearestOrigin =
nullptr;
412 double dist = a.
Distance( aMousePos );
421 return nearestOrigin ? nearestOrigin->
pos : aMousePos;
426 std::vector<BOARD_ITEM*>& aItems,
432 computeAnchors( aItems, aMousePos,
true, aSelectionFilter,
nullptr,
true );
440 double minDist = std::numeric_limits<double>::max();
444 minDist = nearestOrigin->
Distance( aMousePos );
445 best = nearestOrigin;
450 double dist = nearestCorner->
Distance( aMousePos );
455 best = nearestCorner;
461 double dist = nearestOutline->
Distance( aMousePos );
463 if( minDist > lineSnapMinCornerDistance && dist < minDist )
464 best = nearestOutline;
467 return best ? best->
pos : aMousePos;
475 std::vector<BOARD_ITEM*> item;
480 item.push_back( aReferenceItem );
493 const std::vector<BOARD_ITEM*>& aSkip )
496 const int snapSize = 25;
509 const BOX2I visibilityHorizon =
514 const std::vector<BOARD_ITEM*> visibleItems =
queryVisible( visibilityHorizon, aSkip );
515 computeAnchors( visibleItems, aOrigin,
false,
nullptr, &aLayers,
false );
524 ad->AddAnchor(
anchor.pos );
526 ad->SetNearest( nearest ?
OPT_VECTOR2I{ nearest->
pos } : std::nullopt );
531 std::optional<int> snapDist;
533 snapDist = nearest->
Distance( aOrigin );
540 const auto ptIsReferenceOnly = [&](
const VECTOR2I& aPt )
543 return std::find( referenceOnlyPoints.begin(), referenceOnlyPoints.end(), aPt )
544 != referenceOnlyPoints.end();
547 const auto proposeConstructionForItems = [&](
const std::vector<EDA_ITEM*>& aItems )
551 std::vector<BOARD_ITEM*> items;
564 || ( ( aLayers & boardItem->
GetLayerSet() ).any() ) )
566 items.push_back( boardItem );
576 bool snapValid =
false;
584 aOrigin, nearestGrid, snapDist, snapRange );
599 if( !ptIsReferenceOnly( *snapLineSnap ) )
601 return *snapLineSnap;
607 if( nearest && nearest->
Distance( aOrigin ) <= snapRange )
613 if( ptIsReferenceOnly( nearest->
pos ) )
626 if( !anchorIsConstructed )
628 proposeConstructionForItems( nearest->
items );
631 const auto shouldAcceptAnchor = [&](
const ANCHOR& aAnchor )
634 static const bool haveExtensions =
636 if( !haveExtensions )
646 bool allRealAreInvolved =
649 return allRealAreInvolved;
652 if( shouldAcceptAnchor( *nearest ) )
669 static const bool canActivateByHitTest =
671 if( canActivateByHitTest )
676 const int hoverAccuracy = 0;
679 if( item->
HitTest( aOrigin, hoverAccuracy ) )
681 proposeConstructionForItems( { item } );
699 if( nearestPointOnAnElement
700 && nearestPointOnAnElement->Distance( aOrigin ) <= snapRange )
702 updateSnapPoint( { *nearestPointOnAnElement, POINT_TYPE::PT_ON_ELEMENT } );
707 return *nearestPointOnAnElement;
751 switch( aItem->
Type() )
787 if( !
grid.overrides_enabled )
793 if(
grid.override_connected )
794 idx =
grid.override_connected_idx;
799 if(
grid.override_wires )
800 idx =
grid.override_wires_idx;
805 if(
grid.override_vias )
806 idx =
grid.override_vias_idx;
811 if(
grid.override_text )
812 idx =
grid.override_text_idx;
817 if(
grid.override_graphics )
818 idx =
grid.override_graphics_idx;
826 if( idx >= 0 && idx < (
int)
grid.grids.size() )
833std::vector<BOARD_ITEM*>
836 std::set<BOARD_ITEM*> items;
837 std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> selectedItems;
845 view->
Query( aArea, selectedItems );
847 for(
const auto& [ viewItem, layer ] : selectedItems )
862 if(
IsPcbLayer( layer ) && parentFP->GetPrivateLayers().test( layer ) )
869 && ( !isHighContrast || activeLayers.count( layer ) )
872 items.insert ( boardItem );
879 items.erase( aItem );
891 return {items.begin(), items.end()};
909 const VECTOR2I& aRefPos,
bool aFrom,
911 const LSET* aMatchLayers,
bool aForDrag )
913 std::vector<PCB_INTERSECTABLE> intersectables;
917 const bool computeIntersections = !aForDrag;
918 const bool computePointsOnElements = !aForDrag;
919 const bool excludeGraphics = aSelectionFilter && !aSelectionFilter->
graphics;
920 const bool excludeTracks = aSelectionFilter && !aSelectionFilter->
tracks;
922 const auto itemIsSnappable = [&](
const BOARD_ITEM& aItem )
928 || ( ( *aMatchLayers & aItem.
GetLayerSet() ).any() );
933 const auto processItem = [&](
BOARD_ITEM& item )
936 if( !itemIsSnappable( item ) )
946 if( computeIntersections || computePointsOnElements )
948 std::optional<INTERSECTABLE_GEOM> intersectableGeom;
951 intersectableGeom = GetBoardIntersectable( item );
955 intersectableGeom = GetBoardIntersectable( item );
958 if( intersectableGeom )
960 intersectables.emplace_back( &item, *intersectableGeom );
967 processItem( *item );
979 constructionItem.Constructions )
982 [&](
const auto& visited )
984 using ItemType = std::decay_t<
decltype( visited )>;
986 if constexpr( std::is_same_v<ItemType, LINE>
987 || std::is_same_v<ItemType, CIRCLE>
988 || std::is_same_v<ItemType, HALF_LINE>
989 || std::is_same_v<ItemType, SHAPE_ARC> )
991 intersectables.emplace_back( involvedItem, visited );
993 else if constexpr( std::is_same_v<ItemType, VECTOR2I> )
997 POINT_TYPE::PT_NONE );
1010 if( computeIntersections )
1012 for( std::size_t ii = 0; ii < intersectables.size(); ++ii )
1016 for( std::size_t jj = ii + 1; jj < intersectables.size(); ++jj )
1022 if( intersectableA.
Item == intersectableB.
Item )
1025 std::vector<VECTOR2I> intersections;
1028 std::visit( visitor, intersectableB.
Geometry );
1031 for(
const VECTOR2I& intersection : intersections )
1033 std::vector<EDA_ITEM*> items = {
1034 intersectableA.
Item,
1035 intersectableB.
Item,
1038 POINT_TYPE::PT_INTERSECTION );
1047 if( computePointsOnElements )
1054 [&](
const auto& geom )
1059 intersectable.Geometry );
1073 auto checkVisibility =
1080 bool onActiveLayer = !isHighContrast;
1081 bool isLODVisible =
false;
1085 if( !onActiveLayer && activeLayers.count( layer ) )
1086 onActiveLayer =
true;
1089 isLODVisible =
true;
1091 if( onActiveLayer && isLODVisible )
1113 case PAD_SHAPE::CIRCLE:
1124 case PAD_SHAPE::OVAL:
1135 case PAD_SHAPE::RECTANGLE:
1136 case PAD_SHAPE::TRAPEZOID:
1137 case PAD_SHAPE::ROUNDRECT:
1138 case PAD_SHAPE::CHAMFERED_RECT:
1143 if( aPad->
GetShape( aLayer ) == PAD_SHAPE::TRAPEZOID )
1144 trap_delta = aPad->
GetDelta( aLayer ) / 2;
1148 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
1149 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
1150 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
1151 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
1174 if( !outline->IsEmpty() )
1176 for(
const VECTOR2I& pt : outline->Outline( 0 ).CPoints() )
1190 std::vector<TYPED_POINT2I> snap_pts;
1192 if( hole_size.
x == hole_size.
y )
1195 const CIRCLE circle( hole_pos, hole_size.
x / 2 );
1222 case SHAPE_T::CIRCLE:
1224 const int r = ( start - end ).EuclideanNorm();
1229 POINT_TYPE::PT_QUADRANT );
1231 POINT_TYPE::PT_QUADRANT );
1233 POINT_TYPE::PT_QUADRANT );
1235 POINT_TYPE::PT_QUADRANT );
1241 POINT_TYPE::PT_END );
1243 POINT_TYPE::PT_END );
1245 POINT_TYPE::PT_MID );
1247 POINT_TYPE::PT_CENTER );
1250 case SHAPE_T::RECTANGLE:
1254 SEG first( start, point2 );
1255 SEG second( point2, end );
1256 SEG third( end, point3 );
1257 SEG fourth( point3, start );
1263 addAnchor( first.
A, snapFlags, shape, POINT_TYPE::PT_CORNER );
1265 addAnchor( second.
A, snapFlags, shape, POINT_TYPE::PT_CORNER );
1267 addAnchor( third.
A, snapFlags, shape, POINT_TYPE::PT_CORNER );
1269 addAnchor( fourth.
A, snapFlags, shape, POINT_TYPE::PT_CORNER );
1274 case SHAPE_T::SEGMENT:
1278 POINT_TYPE::PT_MID );
1285 std::vector<VECTOR2I> poly;
1298 case SHAPE_T::BEZIER:
1309 switch( aItem->
Type() )
1319 if( aSelectionFilter && !aSelectionFilter->
pads )
1328 if( !checkVisibility(
pad ) )
1331 if( !
pad->GetBoundingBox().Contains( aRefPos ) )
1334 pad->Padstack().ForEachUniqueLayer(
1337 if( !isHighContrast || activeLayers.count( aLayer ) )
1338 handlePadShape(
pad, aLayer );
1342 if( aFrom && aSelectionFilter && !aSelectionFilter->
footprints )
1354 if( ( center - position ).SquaredEuclideanNorm() >
grid.SquaredEuclideanNorm() )
1363 if( aSelectionFilter && !aSelectionFilter->
pads )
1372 if( checkVisibility( aItem ) )
1376 pad->Padstack().ForEachUniqueLayer(
1379 if( !isHighContrast || activeLayers.count( aLayer ) )
1380 handlePadShape(
pad, aLayer );
1389 if( aSelectionFilter && !aSelectionFilter->
text )
1398 if( checkVisibility( aItem ) )
1399 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1406 if( aSelectionFilter && !aSelectionFilter->
graphics )
1415 if( checkVisibility( aItem ) )
1416 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1424 if( aSelectionFilter && !aSelectionFilter->
tracks )
1433 if( checkVisibility( aItem ) )
1447 POINT_TYPE::PT_CENTER );
1453 if( aSelectionFilter && !aSelectionFilter->
vias )
1462 if( checkVisibility( aItem ) )
1464 POINT_TYPE::PT_CENTER );
1469 if( aFrom && aSelectionFilter && !aSelectionFilter->
zones )
1472 if( checkVisibility( aItem ) )
1492 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1495 if( checkVisibility( aItem ) )
1507 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1510 if( checkVisibility( aItem ) )
1519 for(
int i = 0; i < 2; i++ )
1529 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1532 if( checkVisibility( aItem ) )
1544 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1547 if( checkVisibility( aItem ) )
1559 if( aFrom && aSelectionFilter && !aSelectionFilter->
text )
1562 if( checkVisibility( aItem ) )
1570 if( checkVisibility( item ) )
1587 ecoord minDist = std::numeric_limits<ecoord>::max();
1588 std::vector<ANCHOR*> anchorsAtMinDistance;
1594 if( ( aFlags &
anchor.flags ) != aFlags )
1597 if( !anchorsAtMinDistance.empty() &&
anchor.pos == anchorsAtMinDistance.front()->pos )
1600 anchorsAtMinDistance.push_back( &
anchor );
1604 const double dist =
anchor.pos.SquaredDistance( aPos );
1605 if( dist < minDist )
1609 anchorsAtMinDistance.clear();
1610 anchorsAtMinDistance.push_back( &
anchor );
1620 ecoord minDistToItem = std::numeric_limits<ecoord>::max();
1626 ecoord distToNearestItem = std::numeric_limits<ecoord>::max();
1632 std::optional<ecoord> distToThisItem =
1633 FindSquareDistanceToItem(
static_cast<const BOARD_ITEM&
>( *item ), aPos );
1635 if( distToThisItem )
1636 distToNearestItem = std::min( distToNearestItem, *distToThisItem );
1641 distToNearestItem = std::min( distToNearestItem, minDist );
1643 if( distToNearestItem < minDistToItem )
1645 minDistToItem = distToNearestItem;
constexpr EDA_IU_SCALE pcbIUScale
constexpr BOX2I BOX2ISafe(const BOX2D &aInput)
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual VECTOR2I GetCenter() const
This defaults to the center of the bounding box if not overridden.
FOOTPRINT * GetParentFootprint() const
virtual LSET GetLayerSet() const
Return a std::bitset of all layers on which the item physically resides.
virtual void RunOnDescendants(const std::function< void(BOARD_ITEM *)> &aFunction, int aDepth=0) const
Invoke a function on all descendants.
static constexpr BOX2< VECTOR2I > ByCorners(const VECTOR2I &aCorner1, const VECTOR2I &aCorner2)
constexpr Vec Centre() const
Represent basic circle geometry with utility geometry functions.
void ProposeConstructionItems(std::unique_ptr< CONSTRUCTION_ITEM_BATCH > aBatch, bool aIsPersistent)
Add a batch of construction items to the helper.
void CancelProposal()
Cancel outstanding proposals for new geometry.
std::vector< CONSTRUCTION_ITEM > CONSTRUCTION_ITEM_BATCH
bool InvolvesAllGivenRealItems(const std::vector< EDA_ITEM * > &aItems) const
Check if all 'real' (non-null = constructed) the items in the batch are in the list of items currentl...
A base class for most all the KiCad significant classes used in schematics and boards.
virtual VECTOR2I GetPosition() const
KICAD_T Type() const
Returns the type of object.
virtual bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const
Test if aPosition is inside or on the boundary of this item.
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
void DupPolyPointsList(std::vector< VECTOR2I > &aBuffer) const
Duplicate the list of corners in a std::vector<VECTOR2I>
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
VECTOR2I GetArcMid() const
const VECTOR2I & GetTextPos() const
void addAnchor(const VECTOR2I &aPos, int aFlags, EDA_ITEM *aItem, int aPointTypes=POINT_TYPE::PT_NONE)
SNAP_MANAGER & getSnapManager()
void showConstructionGeometry(bool aShow)
VECTOR2D GetVisibleGrid() const
std::optional< ANCHOR > m_snapItem
KIGFX::ANCHOR_DEBUG * enableAndGetAnchorDebug()
Enable the anchor debug if permitted and return it.
KIGFX::SNAP_INDICATOR m_viewSnapPoint
void updateSnapPoint(const TYPED_POINT2I &aPoint)
KIGFX::ORIGIN_VIEWITEM m_viewAxis
std::vector< ANCHOR > m_anchors
View item to draw debug items for anchors.
A color representation with 4 components: red, green, blue, alpha.
COLOR4D WithAlpha(double aAlpha) const
Return a color with the same color, but the given alpha.
std::variant< SEG, LINE, HALF_LINE, CIRCLE, SHAPE_ARC, VECTOR2I > DRAWABLE
const VECTOR2D & GetGridSize() const
Return the grid size.
void SetColor(const KIGFX::COLOR4D &aColor)
void SetStyle(MARKER_STYLE aStyle)
void SetDrawAtZero(bool aDrawFlag)
Set the draw at zero flag.
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
const std::set< int > GetHighContrastLayers() const
Returns the set of currently high-contrast layers.
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
bool GetHighContrast() const
void SetSnapTypes(int aSnapTypes)
Set a mask of point types that this snap item represents.
virtual double ViewGetLOD(int aLayer, VIEW *aView) const
Return the level of detail (LOD) of the item.
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1)
Add a VIEW_ITEM to the view.
virtual void Remove(VIEW_ITEM *aItem)
Remove a VIEW_ITEM from the view.
int Query(const BOX2I &aRect, std::vector< LAYER_ITEM_PAIR > &aResult) const
Find all visible items that touch or are within the rectangle aRect.
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
VECTOR2D ToWorld(const VECTOR2D &aCoord, bool aAbsolute=true) const
Converts a screen space point/vector to a point/vector in world space coordinates.
bool IsLayerVisible(int aLayer) const
Return information about visibility of a particular layer.
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
bool IsVisible(const VIEW_ITEM *aItem) const
Return information if the item is visible (or not).
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Set the item visibility.
LSET is a set of PCB_LAYER_IDs.
static LSET AllLayersMask()
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
Class that represents an oval shape (rectangle with semicircular end caps)
const VECTOR2I & GetDrillSize() const
const VECTOR2I & GetDelta(PCB_LAYER_ID aLayer) const
VECTOR2I GetPosition() const override
PAD_SHAPE GetShape(PCB_LAYER_ID aLayer) const
EDA_ANGLE GetOrientation() const
Return the rotation angle of the pad.
const std::shared_ptr< SHAPE_POLY_SET > & GetEffectivePolygon(PCB_LAYER_ID aLayer, ERROR_LOC aErrorLoc=ERROR_INSIDE) const
bool HasHole() const override
VECTOR2I ShapePos(PCB_LAYER_ID aLayer) const
const VECTOR2I & GetSize(PCB_LAYER_ID aLayer) const
const VECTOR2I & GetMid() const
virtual const VECTOR2I & GetStart() const
The dimension's origin is the first feature point for the dimension.
virtual const VECTOR2I & GetEnd() const
For better understanding of the points that make a dimension:
const VECTOR2I & GetCrossbarStart() const
const VECTOR2I & GetCrossbarEnd() const
Mark the center of a circle or arc with a cross shape.
A leader is a dimension-like object pointing to a specific point.
A radial dimension indicates either the radius or diameter of an arc or circle.
std::vector< NEARABLE_GEOM > m_pointOnLineCandidates
~PCB_GRID_HELPER() override
VECTOR2I AlignToArc(const VECTOR2I &aPoint, const SHAPE_ARC &aSeg)
VECTOR2I SnapToPad(const VECTOR2I &aMousePos, std::deque< PAD * > &aPads)
BOARD_ITEM * GetSnapped() const
Function GetSnapped If the PCB_GRID_HELPER has highlighted a snap point (target shown),...
VECTOR2D GetGridSize(GRID_HELPER_GRIDS aGrid) const override
Return the size of the specified grid.
VECTOR2I BestSnapAnchor(const VECTOR2I &aOrigin, BOARD_ITEM *aReferenceItem, GRID_HELPER_GRIDS aGrid=GRID_HELPER_GRIDS::GRID_CURRENT)
Chooses the "best" snap anchor around the given point, optionally taking layers from the reference it...
VECTOR2I BestDragOrigin(const VECTOR2I &aMousePos, std::vector< BOARD_ITEM * > &aItem, GRID_HELPER_GRIDS aGrid=GRID_HELPER_GRIDS::GRID_CURRENT, const PCB_SELECTION_FILTER_OPTIONS *aSelectionFilter=nullptr)
void AddConstructionItems(std::vector< BOARD_ITEM * > aItems, bool aExtensionOnly, bool aIsPersistent)
Add construction geometry for a set of board items.
ANCHOR * nearestAnchor(const VECTOR2I &aPos, int aFlags)
Find the nearest anchor point to the given position with matching flags.
MAGNETIC_SETTINGS * m_magneticSettings
GRID_HELPER_GRIDS GetItemGrid(const EDA_ITEM *aItem) const override
Gets the coarsest grid that applies to an item.
VECTOR2I AlignToSegment(const VECTOR2I &aPoint, const SEG &aSeg)
virtual VECTOR2I Align(const VECTOR2I &aPoint, GRID_HELPER_GRIDS aGrid) const
PCB_GRID_HELPER(TOOL_MANAGER *aToolMgr, MAGNETIC_SETTINGS *aMagneticSettings)
void computeAnchors(const std::vector< BOARD_ITEM * > &aItems, const VECTOR2I &aRefPos, bool aFrom, const PCB_SELECTION_FILTER_OPTIONS *aSelectionFilter, const LSET *aLayers, bool aForDrag)
computeAnchors inserts the local anchor points in to the grid helper for the specified container of b...
std::vector< BOARD_ITEM * > queryVisible(const BOX2I &aArea, const std::vector< BOARD_ITEM * > &aSkip) const
A set of BOARD_ITEMs (i.e., without duplicates).
VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
VECTOR2I GetPosition() const override
const VECTOR2I & GetStart() const
const VECTOR2I & GetEnd() const
ecoord SquaredDistance(const SEG &aSeg) const
VECTOR2I::extended_type ecoord
OPT_VECTOR2I IntersectLines(const SEG &aSeg) const
Compute the intersection point of lines passing through ends of (this) and aSeg.
const VECTOR2I & GetP1() const
int IntersectLine(const SEG &aSeg, std::vector< VECTOR2I > *aIpsBuffer) const
Find intersection points between this arc and aSeg, treating aSeg as an infinite line.
const VECTOR2I & GetP0() const
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
void Move(const VECTOR2I &aVector) override
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
void Rotate(const EDA_ANGLE &aAngle, const VECTOR2I &aCenter={ 0, 0 }) override
Rotate all vertices by a given angle.
virtual const SEG GetSegment(int aIndex) const override
const VECTOR2I NearestPoint(const VECTOR2I &aP, bool aAllowInternalShapePoints=true) const
Find a point on the line chain that is closest to point aP.
virtual size_t GetSegmentCount() const override
Represent a set of closed polygons.
CONST_ITERATOR CIterateWithHoles(int aOutline) const
A class that manages the geometry of a "snap line".
void SetSnappedAnchor(const VECTOR2I &aAnchorPos)
Inform this manager that an anchor snap has been made.
OPT_VECTOR2I GetNearestSnapLinePoint(const VECTOR2I &aCursor, const VECTOR2I &aNearestGrid, std::optional< int > aDistToNearest, int snapRange) const
If the snap line is active, return the best snap point that is closest to the cursor.
void ClearSnapLine()
Clear the snap line origin and end points.
void SetSnapLineOrigin(const VECTOR2I &aOrigin)
The snap point is a special point that is located at the last point the cursor snapped to.
void SetSnapLineEnd(const OPT_VECTOR2I &aSnapPoint)
Set the end point of the snap line.
A SNAP_MANAGER glues together the snap line manager and construction manager., along with some other ...
SNAP_LINE_MANAGER & GetSnapLineManager()
CONSTRUCTION_MANAGER & GetConstructionManager()
const std::vector< VECTOR2I > & GetReferenceOnlyPoints() const
void SetReferenceOnlyPoints(std::vector< VECTOR2I > aPoints)
Set the reference-only points - these are points that are not snapped to, but can still be used for c...
constexpr extended_type SquaredDistance(const VECTOR2< T > &aVector) const
Compute the squared distance between two vectors.
static constexpr extended_type ECOORD_MAX
VECTOR2_TRAITS< int32_t >::extended_type extended_type
Handle a list of polygons defining a copper zone.
static constexpr EDA_ANGLE ANGLE_90
@ ARC
use RECTANGLE instead of RECT to avoid collision in a Windows header
bool m_ExtensionSnapActivateOnHover
If extension snaps are enabled, 'activate' items on hover, even if not near a snap point.
bool m_EnableExtensionSnaps
Enable snap anchors based on item line extensions.
std::variant< LINE, HALF_LINE, SEG, CIRCLE, SHAPE_ARC, BOX2I > INTERSECTABLE_GEOM
A variant type that can hold any of the supported geometry types for intersection calculations.
bool IsPcbLayer(int aLayer)
Test whether a layer is a valid layer for Pcbnew.
@ LAYER_AUX_ITEMS
Auxiliary items (guides, rule, etc)
@ LAYER_ANCHOR
anchor of items having an anchor point (texts, footprints)
PCB_LAYER_ID
A quick note on layer IDs:
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
std::vector< TYPED_POINT2I > GetOvalKeyPoints(const OVAL &aOval, OVAL_KEY_POINT_FLAGS aFlags)
Get a list of interesting points on an oval (rectangle with semicircular end caps)
std::vector< TYPED_POINT2I > GetCircleKeyPoints(const CIRCLE &aCircle, bool aIncludeCenter)
Get key points of an CIRCLE.
unsigned int OVAL_KEY_POINT_FLAGS
@ GEOMETRY
Position or shape has changed.
VECTOR2I GetNearestPoint(const NEARABLE_GEOM &aGeom, const VECTOR2I &aPt)
Get the nearest point on a geometry to a given point.
std::variant< LINE, HALF_LINE, SEG, CIRCLE, SHAPE_ARC, BOX2I, VECTOR2I > NEARABLE_GEOM
A variant type that can hold any of the supported geometry types for nearest point calculations.
Class to handle a set of BOARD_ITEMs.
std::optional< VECTOR2I > OPT_VECTOR2I
VECTOR2I::extended_type ecoord
Utility functions for working with shapes.
Items to be used for the construction of "virtual" anchors, for example, when snapping to a point inv...
std::vector< EDA_ITEM * > items
double Distance(const VECTOR2I &aP) const
A visitor that visits INTERSECTABLE_GEOM variant objects with another (which is held as state: m_othe...
PCB_INTERSECTABLE(BOARD_ITEM *aItem, INTERSECTABLE_GEOM aSeg)
INTERSECTABLE_GEOM Geometry
This file contains data structures that are saved in the project file or project local settings file ...
bool vias
Vias (all types>
bool graphics
Graphic lines, shapes, polygons.
bool footprints
Allow selecting entire footprints.
bool text
Text (free or attached to a footprint)
bool tracks
Copper tracks.
bool dimensions
Dimension items.
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
@ PCB_DIM_ORTHOGONAL_T
class PCB_DIM_ORTHOGONAL, a linear dimension constrained to x/y
@ PCB_DIM_LEADER_T
class PCB_DIM_LEADER, a leader dimension (graphic item)
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
@ PCB_DIM_CENTER_T
class PCB_DIM_CENTER, a center point marking (graphic item)
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
@ PCB_TEXTBOX_T
class PCB_TEXTBOX, wrapped text on a layer
@ PCB_ZONE_T
class ZONE, a copper pour area
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
@ PCB_REFERENCE_IMAGE_T
class PCB_REFERENCE_IMAGE, bitmap on a layer
@ PCB_FIELD_T
class PCB_FIELD, text associated with a footprint property
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
@ PCB_TARGET_T
class PCB_TARGET, a target (graphic item)
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
@ PCB_PAD_T
class PAD, a pad in a footprint
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
@ PCB_DIMENSION_T
class PCB_DIMENSION_BASE: abstract dimension meta-type
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
@ PCB_DIM_RADIAL_T
class PCB_DIM_RADIAL, a radius or diameter dimension
VECTOR2< int32_t > VECTOR2I
VECTOR2< double > VECTOR2D