68std::optional<INTERSECTABLE_GEOM> GetBoardIntersectable(
const BOARD_ITEM& aItem )
70 switch( aItem.
Type() )
121std::optional<int64_t> FindSquareDistanceToItem(
const BOARD_ITEM& item,
const VECTOR2I& aPos )
123 std::optional<INTERSECTABLE_GEOM> intersectable = GetBoardIntersectable( item );
124 std::optional<NEARABLE_GEOM> nearable;
130 [&](
const auto& geom )
202 auto constructionItemsBatch = std::make_unique<CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM_BATCH>();
204 std::vector<VECTOR2I> referenceOnlyPoints;
208 std::vector<KIGFX::CONSTRUCTION_GEOM::DRAWABLE> constructionDrawables;
210 switch( item->
Type() )
220 if( !aExtensionOnly )
236 constructionDrawables.emplace_back( shape.
GetStart() );
237 constructionDrawables.emplace_back( shape.
GetEnd() );
240 referenceOnlyPoints.emplace_back( shape.
GetStart() );
241 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
247 if( !aExtensionOnly )
258 constructionDrawables.push_back( shape.
GetCenter() );
264 constructionDrawables.emplace_back( shape.
GetStart() );
265 constructionDrawables.emplace_back( shape.
GetEnd() );
268 referenceOnlyPoints.emplace_back( shape.
GetStart() );
269 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
277 constructionDrawables.push_back( shape.
GetCenter() );
291 constructionDrawables.push_back( refImg.
GetPosition() );
297 constructionDrawables.push_back( seg );
312 std::move( constructionDrawables ),
316 if( referenceOnlyPoints.size() )
327 const int c_gridSnapEpsilon_sq = 4;
334 std::vector<VECTOR2I> points;
336 const SEG testSegments[] = {
SEG( aligned, aligned +
VECTOR2( 1, 0 ) ),
341 for(
const SEG& seg : testSegments )
346 points.push_back( *vec );
353 for(
const VECTOR2I& pt : { aSeg.
A, aSeg.
B } )
355 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
357 if( d_sq < min_d_sq )
367 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
369 if( d_sq < min_d_sq )
387 std::vector<VECTOR2I> points;
400 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
402 if( d_sq < min_d_sq )
412 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
414 if( d_sq < min_d_sq )
431 if( item->
HitTest( aMousePos ) )
435 double minDist = std::numeric_limits<double>::max();
436 ANCHOR* nearestOrigin =
nullptr;
443 double dist = a.Distance( aMousePos );
452 return nearestOrigin ? nearestOrigin->
pos : aMousePos;
457 std::vector<BOARD_ITEM*>& aItems,
463 computeAnchors( aItems, aMousePos,
true, aSelectionFilter,
nullptr,
true );
465 double lineSnapMinCornerDistance =
m_toolMgr->GetView()->ToWorld( 50 );
471 double minDist = std::numeric_limits<double>::max();
475 minDist = nearestOrigin->
Distance( aMousePos );
476 best = nearestOrigin;
481 double dist = nearestCorner->
Distance( aMousePos );
486 best = nearestCorner;
492 double dist = nearestOutline->
Distance( aMousePos );
494 if( minDist > lineSnapMinCornerDistance && dist < minDist )
495 best = nearestOutline;
498 return best ? best->
pos : aMousePos;
506 std::vector<BOARD_ITEM*> item;
511 item.push_back( aReferenceItem );
524 const std::vector<BOARD_ITEM*>& aSkip )
527 const int snapSize = 25;
534 double snapScale =
m_toolMgr->GetView()->ToWorld( snapSize );
540 const BOX2I visibilityHorizon =
545 const std::vector<BOARD_ITEM*> visibleItems =
queryVisible( visibilityHorizon, aSkip );
546 computeAnchors( visibleItems, aOrigin,
false,
nullptr, &aLayers,
false );
551 const int hysteresisWorld =
553 const int snapIn = std::max( 0, snapRange - hysteresisWorld );
554 const int snapOut = snapRange + hysteresisWorld;
561 ad->AddAnchor(
anchor.pos );
563 ad->SetNearest( nearest ?
OPT_VECTOR2I{ nearest->
pos } : std::nullopt );
568 std::optional<int> snapDist;
571 snapDist = nearest->
Distance( aOrigin );
575 int existingDist =
m_snapItem->Distance( aOrigin );
576 if( !snapDist || existingDist < *snapDist )
577 snapDist = existingDist;
585 const auto ptIsReferenceOnly =
589 return std::find( referenceOnlyPoints.begin(), referenceOnlyPoints.end(), aPt )
590 != referenceOnlyPoints.end();
593 const auto proposeConstructionForItems =
594 [&](
const std::vector<EDA_ITEM*>& aItems )
598 std::vector<BOARD_ITEM*> items;
614 items.push_back( boardItem );
623 bool snapValid =
false;
631 aOrigin, nearestGrid, snapDist, snapRange );
646 if( !ptIsReferenceOnly( *snapLineSnap ) )
647 return *snapLineSnap;
655 if( dist <= snapOut )
657 if( nearest && ptIsReferenceOnly( nearest->
pos ) &&
658 nearest->
Distance( aOrigin ) <= snapRange )
671 if( nearest && nearest->
Distance( aOrigin ) <= snapIn )
677 if( ptIsReferenceOnly( nearest->
pos ) )
690 if( !anchorIsConstructed )
691 proposeConstructionForItems( nearest->
items );
709 if( canActivateByHitTest )
714 const int hoverAccuracy = 0;
718 if( item->
HitTest( aOrigin, hoverAccuracy ) )
720 proposeConstructionForItems( { item } );
737 if( nearestPointOnAnElement && nearestPointOnAnElement->Distance( aOrigin ) <= snapRange )
744 return *nearestPointOnAnElement;
788 switch( aItem->
Type() )
824 if( !
grid.overrides_enabled )
830 if(
grid.override_connected )
831 idx =
grid.override_connected_idx;
836 if(
grid.override_wires )
837 idx =
grid.override_wires_idx;
842 if(
grid.override_vias )
843 idx =
grid.override_vias_idx;
848 if(
grid.override_text )
849 idx =
grid.override_text_idx;
854 if(
grid.override_graphics )
855 idx =
grid.override_graphics_idx;
863 if( idx >= 0 && idx < (
int)
grid.grids.size() )
870std::vector<BOARD_ITEM*>
873 std::set<BOARD_ITEM*> items;
874 std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> visibleItems;
882 view->
Query( aArea, visibleItems );
884 for(
const auto& [ viewItem, layer ] : visibleItems )
886 if( !viewItem->IsBOARD_ITEM() )
902 if(
IsPcbLayer( layer ) && parentFP->GetPrivateLayers().test( layer ) )
909 && ( !isHighContrast || activeLayers.count( layer ) )
912 items.insert ( boardItem );
919 items.erase( aItem );
932 return {items.begin(), items.end()};
951 const VECTOR2I& aRefPos,
bool aFrom,
953 const LSET* aMatchLayers,
bool aForDrag )
955 std::vector<PCB_INTERSECTABLE> intersectables;
959 const bool computeIntersections = !aForDrag;
960 const bool computePointsOnElements = !aForDrag;
961 const bool excludeGraphics = aSelectionFilter && !aSelectionFilter->
graphics;
962 const bool excludeTracks = aSelectionFilter && !aSelectionFilter->
tracks;
964 const auto itemIsSnappable =
974 const auto processItem =
978 if( !itemIsSnappable( item ) )
986 if( computeIntersections || computePointsOnElements )
988 std::optional<INTERSECTABLE_GEOM> intersectableGeom;
993 intersectableGeom = GetBoardIntersectable( item );
997 intersectableGeom = GetBoardIntersectable( item );
1000 if( intersectableGeom )
1001 intersectables.emplace_back( &item, *intersectableGeom );
1007 processItem( *item );
1019 [&](
const auto& visited )
1021 using ItemType = std::decay_t<
decltype( visited )>;
1023 if constexpr( std::is_same_v<ItemType, LINE>
1024 || std::is_same_v<ItemType, CIRCLE>
1025 || std::is_same_v<ItemType, HALF_LINE>
1026 || std::is_same_v<ItemType, SHAPE_ARC> )
1028 intersectables.emplace_back( involvedItem, visited );
1030 else if constexpr( std::is_same_v<ItemType, VECTOR2I> )
1046 if( computeIntersections )
1048 for( std::size_t ii = 0; ii < intersectables.size(); ++ii )
1052 for( std::size_t jj = ii + 1; jj < intersectables.size(); ++jj )
1058 if( intersectableA.
Item == intersectableB.
Item )
1061 std::vector<VECTOR2I> intersections;
1064 std::visit( visitor, intersectableB.
Geometry );
1067 for(
const VECTOR2I& intersection : intersections )
1069 std::vector<EDA_ITEM*> items = {
1070 intersectableA.
Item,
1071 intersectableB.
Item,
1084 if( computePointsOnElements )
1091 [&](
const auto& geom )
1096 intersectable.Geometry );
1108 switch( aPadStack.
Mode() )
1118 switch( aPadstackUniqueLayer )
1123 return aPadstackUniqueLayer == aRealLayer;
1128 wxFAIL_MSG( wxString::Format(
"Unexpected padstack unique layer %d in FRONT_INNER_BACK mode",
1129 aPadstackUniqueLayer ) );
1137 return aRealLayer == aPadstackUniqueLayer;
1154 const auto checkVisibility =
1161 bool onActiveLayer = !isHighContrast;
1162 bool isLODVisible =
false;
1166 if( !onActiveLayer && activeLayers.count( layer ) )
1167 onActiveLayer =
true;
1170 isLODVisible =
true;
1172 if( onActiveLayer && isLODVisible )
1185 auto handlePadShape =
1224 trap_delta = aPad->
GetDelta( aLayer ) / 2;
1228 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
1229 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
1230 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
1231 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
1254 if( !outline->IsEmpty() )
1256 for(
const VECTOR2I& pt : outline->Outline( 0 ).CPoints() )
1270 std::vector<TYPED_POINT2I> snap_pts;
1272 if( hole_size.
x == hole_size.
y )
1295 const auto addRectPoints =
1302 const SEG second( topRight, aBox.
GetEnd() );
1303 const SEG third( aBox.
GetEnd(), bottomLeft );
1320 const auto handleShape =
1330 const int r = ( start -
end ).EuclideanNorm();
1364 std::vector<VECTOR2I> poly;
1388 switch( aItem->
Type() )
1398 if( aSelectionFilter && !aSelectionFilter->
pads )
1407 if( !checkVisibility(
pad ) )
1410 if( !
pad->GetBoundingBox().Contains( aRefPos ) )
1413 pad->Padstack().ForEachUniqueLayer(
1418 activeHighContrastPrimaryLayer ) )
1420 handlePadShape(
pad, aLayer );
1428 if( aSelectionFilter && !aSelectionFilter->
points )
1431 if( !checkVisibility( pt ) )
1437 if( aFrom && aSelectionFilter && !aSelectionFilter->
footprints )
1449 if( (
center - position ).SquaredEuclideanNorm() >
grid.SquaredEuclideanNorm() )
1458 if( aSelectionFilter && !aSelectionFilter->
pads )
1467 if( checkVisibility( aItem ) )
1471 pad->Padstack().ForEachUniqueLayer(
1476 activeHighContrastPrimaryLayer ) )
1478 handlePadShape(
pad, aLayer );
1488 if( aSelectionFilter && !aSelectionFilter->
text )
1497 if( checkVisibility( aItem ) )
1498 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1505 if( aSelectionFilter && !aSelectionFilter->
text )
1514 if( checkVisibility( aItem ) )
1519 VECTOR2I topLeft =
table->GetCell( 0, 0 )->GetCornersInSequence( drawAngle )[0];
1521 table->GetCell(
table->GetRowCount() - 1, 0 )->GetCornersInSequence( drawAngle )[3];
1522 VECTOR2I topRight =
table->GetCell( 0,
table->GetColCount() - 1 )->GetCornersInSequence( drawAngle )[1];
1524 ->GetCornersInSequence( drawAngle )[2];
1539 if( aSelectionFilter && !aSelectionFilter->
graphics )
1548 if( checkVisibility( aItem ) )
1549 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1557 if( aSelectionFilter && !aSelectionFilter->
tracks )
1566 if( checkVisibility( aItem ) )
1583 if( aSelectionFilter && !aSelectionFilter->
points )
1586 if( checkVisibility( aItem ) )
1594 if( aSelectionFilter && !aSelectionFilter->
vias )
1603 if( checkVisibility( aItem ) )
1609 if( aFrom && aSelectionFilter && !aSelectionFilter->
zones )
1612 if( checkVisibility( aItem ) )
1632 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1635 if( checkVisibility( aItem ) )
1647 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1650 if( checkVisibility( aItem ) )
1659 for(
int i = 0; i < 2; i++ )
1669 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1672 if( checkVisibility( aItem ) )
1684 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1687 if( checkVisibility( aItem ) )
1699 if( aFrom && aSelectionFilter && !aSelectionFilter->
text )
1702 if( checkVisibility( aItem ) )
1710 if( checkVisibility( item ) )
1717 if( aFrom && aSelectionFilter && !aSelectionFilter->
graphics )
1720 if( checkVisibility( aItem ) )
1726 addRectPoints( bbox, *aItem );
1748 ecoord minDist = std::numeric_limits<ecoord>::max();
1749 std::vector<ANCHOR*> anchorsAtMinDistance;
1755 if( ( aFlags &
anchor.flags ) != aFlags )
1758 if( !anchorsAtMinDistance.empty() &&
anchor.pos == anchorsAtMinDistance.front()->pos )
1761 anchorsAtMinDistance.push_back( &
anchor );
1765 const double dist =
anchor.pos.SquaredDistance( aPos );
1767 if( dist < minDist )
1771 anchorsAtMinDistance.clear();
1772 anchorsAtMinDistance.push_back( &
anchor );
1785 const auto noRealItemsInAnchorAreInvolved = [&](
ANCHOR* aAnchor ) ->
bool
1790 if( !haveExtensions )
1798 if( !anchorIsConstructed )
1802 return !allRealAreInvolved;
1806 std::erase_if( anchorsAtMinDistance, noRealItemsInAnchorAreInvolved );
1813 ecoord minDistToItem = std::numeric_limits<ecoord>::max();
1819 ecoord distToNearestItem = std::numeric_limits<ecoord>::max();
1826 std::optional<ecoord> distToThisItem =
1827 FindSquareDistanceToItem(
static_cast<const BOARD_ITEM&
>( *item ), aPos );
1829 if( distToThisItem )
1830 distToNearestItem = std::min( distToNearestItem, *distToThisItem );
1835 distToNearestItem = std::min( distToNearestItem, minDist );
1837 if( distToNearestItem < minDistToItem )
1839 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 RunOnChildren(const std::function< void(BOARD_ITEM *)> &aFunction, RECURSE_MODE aMode) const
Invoke a function on all children.
static constexpr BOX2< VECTOR2I > ByCorners(const VECTOR2I &aCorner1, const VECTOR2I &aCorner2)
constexpr const Vec GetEnd() const
constexpr Vec Centre() const
constexpr const Vec GetCenter() const
constexpr coord_type GetLeft() const
constexpr const Vec & GetOrigin() const
constexpr coord_type GetRight() const
constexpr coord_type GetTop() const
constexpr coord_type GetBottom() 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
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.
PCB_LAYER_ID GetPrimaryHighContrastLayer() const
Return the board layer which is in high-contrast mode.
const COLOR4D & GetLayerColor(int aLayer) const
Return the color used to draw a layer.
bool GetHighContrast() const
bool IsBOARD_ITEM() const
virtual double ViewGetLOD(int aLayer, const 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.
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 const LSET & AllLayersMask()
A PADSTACK defines the characteristics of a single or multi-layer pad, in the IPC sense of the word.
@ NORMAL
Shape is the same on all layers.
@ CUSTOM
Shapes can be defined on arbitrary layers.
@ FRONT_INNER_BACK
Up to three shapes can be defined (F_Cu, inner copper layers, B_Cu)
static constexpr PCB_LAYER_ID INNER_LAYERS
! The layer identifier to use for "inner layers" on top/inner/bottom padstacks
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
Get 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
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).
A PCB_POINT is a 0-dimensional point that is used to mark a position on a PCB, or more usually a foot...
Object to handle a bitmap image that can be inserted in a PCB.
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
REFERENCE_IMAGE & GetReferenceImage()
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
A REFERENCE_IMAGE is a wrapper around a BITMAP_IMAGE that is displayed in an editor as a reference fo...
VECTOR2I GetTransformOriginOffset() const
Get the center of scaling, etc, relative to the image center (GetPosition()).
VECTOR2I GetPosition() const
BOX2I GetBoundingBox() 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
static SHAPE_SEGMENT BySizeAndCenter(const VECTOR2I &aSize, const VECTOR2I &aCenter, const EDA_ANGLE &aRotation)
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...
Define a general 2D-vector/point.
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.
A type-safe container of any type.
static constexpr EDA_ANGLE ANGLE_90
@ RECTANGLE
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.
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
@ LAYER_AUX_ITEMS
Auxiliary items (guides, rule, etc).
@ LAYER_ANCHOR
Anchor of items having an anchor point (texts, footprints).
bool IsInnerCopperLayer(int aLayerId)
Test whether a layer is an inner (In1_Cu to In30_Cu) copper layer.
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 > GetCircleKeyPoints(const CIRCLE &aCircle, bool aIncludeCenter)
Get key points of an CIRCLE.
std::vector< TYPED_POINT2I > GetOvalKeyPoints(const SHAPE_SEGMENT &aOval, OVAL_KEY_POINT_FLAGS aFlags)
Get a list of interesting points on an oval (rectangle with semicircular end caps)
std::array< SEG, 4 > BoxToSegs(const BOX2I &aBox)
Decompose a BOX2 into four segments.
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.
static bool PadstackUniqueLayerAppliesToLayer(const PADSTACK &aPadStack, PCB_LAYER_ID aPadstackUniqueLayer, const PCB_LAYER_ID aRealLayer)
Class to handle a set of BOARD_ITEMs.
@ PT_INTERSECTION
The point is an intersection of two (or more) items.
@ PT_CENTER
The point is the center of something.
@ PT_CORNER
The point is a corner of a polygon, rectangle, etc (you may want to infer PT_END from this)
@ PT_NONE
No specific point type.
@ PT_QUADRANT
The point is on a quadrant of a circle (N, E, S, W points).
@ PT_END
The point is at the end of a segment, arc, etc.
@ PT_MID
The point is at the middle of a segment, arc, etc.
@ PT_ON_ELEMENT
The point is somewhere on another element, but not some specific point.
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
Items that are associated with this anchor (can be more than one, e.g.
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.
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)
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_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
@ PCB_POINT_T
class PCB_POINT, a 0-dimensional point
@ 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