65std::optional<INTERSECTABLE_GEOM> GetBoardIntersectable(
const BOARD_ITEM& aItem )
67 switch( aItem.
Type() )
125std::optional<int64_t> FindSquareDistanceToItem(
const BOARD_ITEM& item,
const VECTOR2I& aPos )
127 std::optional<INTERSECTABLE_GEOM> intersectable = GetBoardIntersectable( item );
128 std::optional<NEARABLE_GEOM> nearable;
194 auto constructionItemsBatch = std::make_unique<CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM_BATCH>();
196 std::vector<VECTOR2I> referenceOnlyPoints;
200 std::vector<KIGFX::CONSTRUCTION_GEOM::DRAWABLE> constructionDrawables;
202 switch( item->
Type() )
210 case SHAPE_T::SEGMENT:
212 if( !aExtensionOnly )
220 constructionDrawables.emplace_back(
222 constructionDrawables.emplace_back(
230 constructionDrawables.emplace_back( shape.
GetStart() );
231 constructionDrawables.emplace_back( shape.
GetEnd() );
234 referenceOnlyPoints.emplace_back( shape.
GetStart() );
235 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
241 if( !aExtensionOnly )
243 constructionDrawables.push_back(
251 constructionDrawables.push_back(
254 constructionDrawables.push_back( shape.
GetCenter() );
260 constructionDrawables.emplace_back( shape.
GetStart() );
261 constructionDrawables.emplace_back( shape.
GetEnd() );
264 referenceOnlyPoints.emplace_back( shape.
GetStart() );
265 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
270 case SHAPE_T::CIRCLE:
271 case SHAPE_T::RECTANGLE:
273 constructionDrawables.push_back( shape.
GetCenter() );
287 constructionDrawables.push_back( refImg.
GetPosition() );
291 constructionDrawables.push_back( refImg.
GetPosition()
297 constructionDrawables.push_back( seg );
312 std::move( constructionDrawables ),
316 if( referenceOnlyPoints.size() )
323 std::move( constructionItemsBatch ), aIsPersistent );
329 const int c_gridSnapEpsilon_sq = 4;
336 std::vector<VECTOR2I> points;
338 const SEG testSegments[] = {
SEG( aligned, aligned +
VECTOR2( 1, 0 ) ),
343 for(
const SEG& seg : testSegments )
348 points.push_back( *vec );
355 for(
const VECTOR2I& pt : { aSeg.
A, aSeg.
B } )
357 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
359 if( d_sq < min_d_sq )
369 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
371 if( d_sq < min_d_sq )
389 std::vector<VECTOR2I> points;
402 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
404 if( d_sq < min_d_sq )
414 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
416 if( d_sq < min_d_sq )
433 if( item->
HitTest( aMousePos ) )
437 double minDist = std::numeric_limits<double>::max();
438 ANCHOR* nearestOrigin =
nullptr;
445 double dist = a.
Distance( aMousePos );
454 return nearestOrigin ? nearestOrigin->
pos : aMousePos;
459 std::vector<BOARD_ITEM*>& aItems,
465 computeAnchors( aItems, aMousePos,
true, aSelectionFilter,
nullptr,
true );
473 double minDist = std::numeric_limits<double>::max();
477 minDist = nearestOrigin->
Distance( aMousePos );
478 best = nearestOrigin;
483 double dist = nearestCorner->
Distance( aMousePos );
488 best = nearestCorner;
494 double dist = nearestOutline->
Distance( aMousePos );
496 if( minDist > lineSnapMinCornerDistance && dist < minDist )
497 best = nearestOutline;
500 return best ? best->
pos : aMousePos;
508 std::vector<BOARD_ITEM*> item;
513 item.push_back( aReferenceItem );
526 const std::vector<BOARD_ITEM*>& aSkip )
529 const int snapSize = 25;
542 const BOX2I visibilityHorizon =
547 const std::vector<BOARD_ITEM*> visibleItems =
queryVisible( visibilityHorizon, aSkip );
548 computeAnchors( visibleItems, aOrigin,
false,
nullptr, &aLayers,
false );
557 ad->AddAnchor(
anchor.pos );
559 ad->SetNearest( nearest ?
OPT_VECTOR2I{ nearest->
pos } : std::nullopt );
564 std::optional<int> snapDist;
566 snapDist = nearest->
Distance( aOrigin );
573 const auto ptIsReferenceOnly = [&](
const VECTOR2I& aPt )
576 return std::find( referenceOnlyPoints.begin(), referenceOnlyPoints.end(), aPt )
577 != referenceOnlyPoints.end();
580 const auto proposeConstructionForItems = [&](
const std::vector<EDA_ITEM*>& aItems )
584 std::vector<BOARD_ITEM*> items;
597 || ( ( aLayers & boardItem->
GetLayerSet() ).any() ) )
599 items.push_back( boardItem );
609 bool snapValid =
false;
617 aOrigin, nearestGrid, snapDist, snapRange );
632 if( !ptIsReferenceOnly( *snapLineSnap ) )
634 return *snapLineSnap;
640 if( nearest && nearest->
Distance( aOrigin ) <= snapRange )
646 if( ptIsReferenceOnly( nearest->
pos ) )
659 if( !anchorIsConstructed )
661 proposeConstructionForItems( nearest->
items );
664 const auto shouldAcceptAnchor = [&](
const ANCHOR& aAnchor )
667 static const bool haveExtensions =
669 if( !haveExtensions )
679 bool allRealAreInvolved =
682 return allRealAreInvolved;
685 if( shouldAcceptAnchor( *nearest ) )
702 static const bool canActivateByHitTest =
704 if( canActivateByHitTest )
709 const int hoverAccuracy = 0;
712 if( item->
HitTest( aOrigin, hoverAccuracy ) )
714 proposeConstructionForItems( { item } );
732 if( nearestPointOnAnElement
733 && nearestPointOnAnElement->Distance( aOrigin ) <= snapRange )
735 updateSnapPoint( { *nearestPointOnAnElement, POINT_TYPE::PT_ON_ELEMENT } );
740 return *nearestPointOnAnElement;
784 switch( aItem->
Type() )
820 if( !
grid.overrides_enabled )
826 if(
grid.override_connected )
827 idx =
grid.override_connected_idx;
832 if(
grid.override_wires )
833 idx =
grid.override_wires_idx;
838 if(
grid.override_vias )
839 idx =
grid.override_vias_idx;
844 if(
grid.override_text )
845 idx =
grid.override_text_idx;
850 if(
grid.override_graphics )
851 idx =
grid.override_graphics_idx;
859 if( idx >= 0 && idx < (
int)
grid.grids.size() )
866std::vector<BOARD_ITEM*>
869 std::set<BOARD_ITEM*> items;
870 std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> selectedItems;
878 view->
Query( aArea, selectedItems );
880 for(
const auto& [ viewItem, layer ] : selectedItems )
895 if(
IsPcbLayer( layer ) && parentFP->GetPrivateLayers().test( layer ) )
902 && ( !isHighContrast || activeLayers.count( layer ) )
905 items.insert ( boardItem );
912 items.erase( aItem );
924 return {items.begin(), items.end()};
942 const VECTOR2I& aRefPos,
bool aFrom,
944 const LSET* aMatchLayers,
bool aForDrag )
946 std::vector<PCB_INTERSECTABLE> intersectables;
950 const bool computeIntersections = !aForDrag;
951 const bool computePointsOnElements = !aForDrag;
952 const bool excludeGraphics = aSelectionFilter && !aSelectionFilter->
graphics;
953 const bool excludeTracks = aSelectionFilter && !aSelectionFilter->
tracks;
955 const auto itemIsSnappable = [&](
const BOARD_ITEM& aItem )
961 || ( ( *aMatchLayers & aItem.
GetLayerSet() ).any() );
966 const auto processItem = [&](
BOARD_ITEM& item )
969 if( !itemIsSnappable( item ) )
979 if( computeIntersections || computePointsOnElements )
981 std::optional<INTERSECTABLE_GEOM> intersectableGeom;
985 intersectableGeom = GetBoardIntersectable( item );
989 intersectableGeom = GetBoardIntersectable( item );
992 if( intersectableGeom )
994 intersectables.emplace_back( &item, *intersectableGeom );
1001 processItem( *item );
1013 constructionItem.Constructions )
1016 [&](
const auto& visited )
1018 using ItemType = std::decay_t<
decltype( visited )>;
1020 if constexpr( std::is_same_v<ItemType, LINE>
1021 || std::is_same_v<ItemType, CIRCLE>
1022 || std::is_same_v<ItemType, HALF_LINE>
1023 || std::is_same_v<ItemType, SHAPE_ARC> )
1025 intersectables.emplace_back( involvedItem, visited );
1027 else if constexpr( std::is_same_v<ItemType, VECTOR2I> )
1031 POINT_TYPE::PT_NONE );
1044 if( computeIntersections )
1046 for( std::size_t ii = 0; ii < intersectables.size(); ++ii )
1050 for( std::size_t jj = ii + 1; jj < intersectables.size(); ++jj )
1056 if( intersectableA.
Item == intersectableB.
Item )
1059 std::vector<VECTOR2I> intersections;
1062 std::visit( visitor, intersectableB.
Geometry );
1065 for(
const VECTOR2I& intersection : intersections )
1067 std::vector<EDA_ITEM*> items = {
1068 intersectableA.
Item,
1069 intersectableB.
Item,
1072 POINT_TYPE::PT_INTERSECTION );
1081 if( computePointsOnElements )
1088 [&](
const auto& geom )
1093 intersectable.Geometry );
1107 auto checkVisibility =
1114 bool onActiveLayer = !isHighContrast;
1115 bool isLODVisible =
false;
1119 if( !onActiveLayer && activeLayers.count( layer ) )
1120 onActiveLayer =
true;
1123 isLODVisible =
true;
1125 if( onActiveLayer && isLODVisible )
1147 case PAD_SHAPE::CIRCLE:
1158 case PAD_SHAPE::OVAL:
1169 case PAD_SHAPE::RECTANGLE:
1170 case PAD_SHAPE::TRAPEZOID:
1171 case PAD_SHAPE::ROUNDRECT:
1172 case PAD_SHAPE::CHAMFERED_RECT:
1177 if( aPad->
GetShape( aLayer ) == PAD_SHAPE::TRAPEZOID )
1178 trap_delta = aPad->
GetDelta( aLayer ) / 2;
1182 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
1183 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
1184 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
1185 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
1208 if( !outline->IsEmpty() )
1210 for(
const VECTOR2I& pt : outline->Outline( 0 ).CPoints() )
1224 std::vector<TYPED_POINT2I> snap_pts;
1226 if( hole_size.
x == hole_size.
y )
1229 const CIRCLE circle( hole_pos, hole_size.
x / 2 );
1248 const auto addRectPoints = [&](
const BOX2I& aBox,
EDA_ITEM& aRelatedItem )
1254 const SEG second( topRight, aBox.
GetEnd() );
1255 const SEG third( aBox.
GetEnd(), bottomLeft );
1262 addAnchor( first.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1263 addAnchor( first.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1264 addAnchor( second.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1265 addAnchor( second.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1266 addAnchor( third.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1267 addAnchor( third.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1268 addAnchor( fourth.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1269 addAnchor( fourth.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1272 const auto handleShape =
1280 case SHAPE_T::CIRCLE:
1282 const int r = ( start -
end ).EuclideanNorm();
1287 POINT_TYPE::PT_QUADRANT );
1289 POINT_TYPE::PT_QUADRANT );
1291 POINT_TYPE::PT_QUADRANT );
1293 POINT_TYPE::PT_QUADRANT );
1299 POINT_TYPE::PT_END );
1301 POINT_TYPE::PT_END );
1303 POINT_TYPE::PT_MID );
1305 POINT_TYPE::PT_CENTER );
1308 case SHAPE_T::RECTANGLE:
1314 case SHAPE_T::SEGMENT:
1318 POINT_TYPE::PT_MID );
1325 std::vector<VECTOR2I> poly;
1338 case SHAPE_T::BEZIER:
1349 switch( aItem->
Type() )
1359 if( aSelectionFilter && !aSelectionFilter->
pads )
1368 if( !checkVisibility(
pad ) )
1371 if( !
pad->GetBoundingBox().Contains( aRefPos ) )
1374 pad->Padstack().ForEachUniqueLayer(
1377 if( !isHighContrast || activeLayers.count( aLayer ) )
1378 handlePadShape(
pad, aLayer );
1382 if( aFrom && aSelectionFilter && !aSelectionFilter->
footprints )
1394 if( (
center - position ).SquaredEuclideanNorm() >
grid.SquaredEuclideanNorm() )
1403 if( aSelectionFilter && !aSelectionFilter->
pads )
1412 if( checkVisibility( aItem ) )
1416 pad->Padstack().ForEachUniqueLayer(
1419 if( !isHighContrast || activeLayers.count( aLayer ) )
1420 handlePadShape(
pad, aLayer );
1429 if( aSelectionFilter && !aSelectionFilter->
text )
1438 if( checkVisibility( aItem ) )
1439 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1446 if( aSelectionFilter && !aSelectionFilter->
graphics )
1455 if( checkVisibility( aItem ) )
1456 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1464 if( aSelectionFilter && !aSelectionFilter->
tracks )
1473 if( checkVisibility( aItem ) )
1487 POINT_TYPE::PT_CENTER );
1493 if( aSelectionFilter && !aSelectionFilter->
vias )
1502 if( checkVisibility( aItem ) )
1504 POINT_TYPE::PT_CENTER );
1509 if( aFrom && aSelectionFilter && !aSelectionFilter->
zones )
1512 if( checkVisibility( aItem ) )
1532 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1535 if( checkVisibility( aItem ) )
1547 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1550 if( checkVisibility( aItem ) )
1559 for(
int i = 0; i < 2; i++ )
1569 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1572 if( checkVisibility( aItem ) )
1584 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1587 if( checkVisibility( aItem ) )
1599 if( aFrom && aSelectionFilter && !aSelectionFilter->
text )
1602 if( checkVisibility( aItem ) )
1610 if( checkVisibility( item ) )
1617 if( aFrom && aSelectionFilter && !aSelectionFilter->
graphics )
1620 if( checkVisibility( aItem ) )
1627 addRectPoints( bbox, *aItem );
1632 aItem, POINT_TYPE::PT_CENTER );
1649 ecoord minDist = std::numeric_limits<ecoord>::max();
1650 std::vector<ANCHOR*> anchorsAtMinDistance;
1656 if( ( aFlags &
anchor.flags ) != aFlags )
1659 if( !anchorsAtMinDistance.empty() &&
anchor.pos == anchorsAtMinDistance.front()->pos )
1662 anchorsAtMinDistance.push_back( &
anchor );
1666 const double dist =
anchor.pos.SquaredDistance( aPos );
1667 if( dist < minDist )
1671 anchorsAtMinDistance.clear();
1672 anchorsAtMinDistance.push_back( &
anchor );
1682 ecoord minDistToItem = std::numeric_limits<ecoord>::max();
1688 ecoord distToNearestItem = std::numeric_limits<ecoord>::max();
1694 std::optional<ecoord> distToThisItem =
1695 FindSquareDistanceToItem(
static_cast<const BOARD_ITEM&
>( *item ), aPos );
1697 if( distToThisItem )
1698 distToNearestItem = std::min( distToNearestItem, *distToThisItem );
1703 distToNearestItem = std::min( distToNearestItem, minDist );
1705 if( distToNearestItem < minDistToItem )
1707 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 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
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, 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.
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
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
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).
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
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
@ 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.
@ 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.
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.
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
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.
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