66std::optional<INTERSECTABLE_GEOM> GetBoardIntersectable(
const BOARD_ITEM& aItem )
68 switch( aItem.
Type() )
119std::optional<int64_t> FindSquareDistanceToItem(
const BOARD_ITEM& item,
const VECTOR2I& aPos )
121 std::optional<INTERSECTABLE_GEOM> intersectable = GetBoardIntersectable( item );
122 std::optional<NEARABLE_GEOM> nearable;
128 [&](
const auto& geom )
147 m_magneticSettings( nullptr )
154 m_magneticSettings( aMagneticSettings )
200 auto constructionItemsBatch = std::make_unique<CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM_BATCH>();
202 std::vector<VECTOR2I> referenceOnlyPoints;
206 std::vector<KIGFX::CONSTRUCTION_GEOM::DRAWABLE> constructionDrawables;
208 switch( item->
Type() )
216 case SHAPE_T::SEGMENT:
218 if( !aExtensionOnly )
234 constructionDrawables.emplace_back( shape.
GetStart() );
235 constructionDrawables.emplace_back( shape.
GetEnd() );
238 referenceOnlyPoints.emplace_back( shape.
GetStart() );
239 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
245 if( !aExtensionOnly )
256 constructionDrawables.push_back( shape.
GetCenter() );
262 constructionDrawables.emplace_back( shape.
GetStart() );
263 constructionDrawables.emplace_back( shape.
GetEnd() );
266 referenceOnlyPoints.emplace_back( shape.
GetStart() );
267 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
272 case SHAPE_T::CIRCLE:
273 case SHAPE_T::RECTANGLE:
275 constructionDrawables.push_back( shape.
GetCenter() );
289 constructionDrawables.push_back( refImg.
GetPosition() );
295 constructionDrawables.push_back( seg );
310 std::move( constructionDrawables ),
314 if( referenceOnlyPoints.size() )
325 const int c_gridSnapEpsilon_sq = 4;
332 std::vector<VECTOR2I> points;
334 const SEG testSegments[] = {
SEG( aligned, aligned +
VECTOR2( 1, 0 ) ),
339 for(
const SEG& seg : testSegments )
344 points.push_back( *vec );
351 for(
const VECTOR2I& pt : { aSeg.
A, aSeg.
B } )
353 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
355 if( d_sq < min_d_sq )
365 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
367 if( d_sq < min_d_sq )
385 std::vector<VECTOR2I> points;
398 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
400 if( d_sq < min_d_sq )
410 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
412 if( d_sq < min_d_sq )
429 if( item->
HitTest( aMousePos ) )
433 double minDist = std::numeric_limits<double>::max();
434 ANCHOR* nearestOrigin =
nullptr;
441 double dist = a.
Distance( aMousePos );
450 return nearestOrigin ? nearestOrigin->
pos : aMousePos;
455 std::vector<BOARD_ITEM*>& aItems,
461 computeAnchors( aItems, aMousePos,
true, aSelectionFilter,
nullptr,
true );
469 double minDist = std::numeric_limits<double>::max();
473 minDist = nearestOrigin->
Distance( aMousePos );
474 best = nearestOrigin;
479 double dist = nearestCorner->
Distance( aMousePos );
484 best = nearestCorner;
490 double dist = nearestOutline->
Distance( aMousePos );
492 if( minDist > lineSnapMinCornerDistance && dist < minDist )
493 best = nearestOutline;
496 return best ? best->
pos : aMousePos;
504 std::vector<BOARD_ITEM*> item;
509 item.push_back( aReferenceItem );
522 const std::vector<BOARD_ITEM*>& aSkip )
525 const int snapSize = 25;
538 const BOX2I visibilityHorizon =
544 const std::vector<BOARD_ITEM*> visibleItems =
queryVisible( visibilityHorizon, aSkip );
545 computeAnchors( visibleItems, aOrigin,
false,
nullptr, &aLayers,
false );
555 ad->AddAnchor(
anchor.pos );
557 ad->SetNearest( nearest ?
OPT_VECTOR2I{ nearest->
pos } : std::nullopt );
562 std::optional<int> snapDist;
565 snapDist = nearest->
Distance( aOrigin );
572 const auto ptIsReferenceOnly =
576 return std::find( referenceOnlyPoints.begin(), referenceOnlyPoints.end(), aPt )
577 != referenceOnlyPoints.end();
580 const auto proposeConstructionForItems =
581 [&](
const std::vector<EDA_ITEM*>& aItems )
585 std::vector<BOARD_ITEM*> items;
601 items.push_back( boardItem );
610 bool snapValid =
false;
618 aOrigin, nearestGrid, snapDist, snapRange );
633 if( !ptIsReferenceOnly( *snapLineSnap ) )
634 return *snapLineSnap;
639 if( nearest && nearest->
Distance( aOrigin ) <= snapRange )
645 if( ptIsReferenceOnly( nearest->
pos ) )
658 if( !anchorIsConstructed )
659 proposeConstructionForItems( nearest->
items );
677 if( canActivateByHitTest )
682 const int hoverAccuracy = 0;
686 if( item->
HitTest( aOrigin, hoverAccuracy ) )
688 proposeConstructionForItems( { item } );
705 if( nearestPointOnAnElement && nearestPointOnAnElement->Distance( aOrigin ) <= snapRange )
707 updateSnapPoint( { *nearestPointOnAnElement, POINT_TYPE::PT_ON_ELEMENT } );
712 return *nearestPointOnAnElement;
756 switch( aItem->
Type() )
792 if( !
grid.overrides_enabled )
798 if(
grid.override_connected )
799 idx =
grid.override_connected_idx;
804 if(
grid.override_wires )
805 idx =
grid.override_wires_idx;
810 if(
grid.override_vias )
811 idx =
grid.override_vias_idx;
816 if(
grid.override_text )
817 idx =
grid.override_text_idx;
822 if(
grid.override_graphics )
823 idx =
grid.override_graphics_idx;
831 if( idx >= 0 && idx < (
int)
grid.grids.size() )
838std::vector<BOARD_ITEM*>
841 std::set<BOARD_ITEM*> items;
842 std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> visibleItems;
850 view->
Query( aArea, visibleItems );
852 for(
const auto& [ viewItem, layer ] : visibleItems )
854 if( !viewItem->IsBOARD_ITEM() )
870 if(
IsPcbLayer( layer ) && parentFP->GetPrivateLayers().test( layer ) )
877 && ( !isHighContrast || activeLayers.count( layer ) )
880 items.insert ( boardItem );
887 items.erase( aItem );
894 RECURSE_MODE::RECURSE );
900 return {items.begin(), items.end()};
919 const VECTOR2I& aRefPos,
bool aFrom,
921 const LSET* aMatchLayers,
bool aForDrag )
923 std::vector<PCB_INTERSECTABLE> intersectables;
927 const bool computeIntersections = !aForDrag;
928 const bool computePointsOnElements = !aForDrag;
929 const bool excludeGraphics = aSelectionFilter && !aSelectionFilter->
graphics;
930 const bool excludeTracks = aSelectionFilter && !aSelectionFilter->
tracks;
932 const auto itemIsSnappable =
942 const auto processItem =
946 if( !itemIsSnappable( item ) )
954 if( computeIntersections || computePointsOnElements )
956 std::optional<INTERSECTABLE_GEOM> intersectableGeom;
961 intersectableGeom = GetBoardIntersectable( item );
965 intersectableGeom = GetBoardIntersectable( item );
968 if( intersectableGeom )
969 intersectables.emplace_back( &item, *intersectableGeom );
975 processItem( *item );
987 [&](
const auto& visited )
989 using ItemType = std::decay_t<
decltype( visited )>;
991 if constexpr( std::is_same_v<ItemType, LINE>
992 || std::is_same_v<ItemType, CIRCLE>
993 || std::is_same_v<ItemType, HALF_LINE>
994 || std::is_same_v<ItemType, SHAPE_ARC> )
996 intersectables.emplace_back( involvedItem, visited );
998 else if constexpr( std::is_same_v<ItemType, VECTOR2I> )
1014 if( computeIntersections )
1016 for( std::size_t ii = 0; ii < intersectables.size(); ++ii )
1020 for( std::size_t jj = ii + 1; jj < intersectables.size(); ++jj )
1026 if( intersectableA.
Item == intersectableB.
Item )
1029 std::vector<VECTOR2I> intersections;
1032 std::visit( visitor, intersectableB.
Geometry );
1035 for(
const VECTOR2I& intersection : intersections )
1037 std::vector<EDA_ITEM*> items = {
1038 intersectableA.
Item,
1039 intersectableB.
Item,
1042 POINT_TYPE::PT_INTERSECTION );
1052 if( computePointsOnElements )
1059 [&](
const auto& geom )
1064 intersectable.Geometry );
1076 switch( aPadStack.
Mode() )
1086 switch( aPadstackUniqueLayer )
1091 return aPadstackUniqueLayer == aRealLayer;
1096 wxFAIL_MSG( wxString::Format(
"Unexpected padstack unique layer %d in FRONT_INNER_BACK mode",
1097 aPadstackUniqueLayer ) );
1105 return aRealLayer == aPadstackUniqueLayer;
1122 auto checkVisibility =
1129 bool onActiveLayer = !isHighContrast;
1130 bool isLODVisible =
false;
1134 if( !onActiveLayer && activeLayers.count( layer ) )
1135 onActiveLayer =
true;
1138 isLODVisible =
true;
1140 if( onActiveLayer && isLODVisible )
1153 auto handlePadShape =
1164 case PAD_SHAPE::CIRCLE:
1173 case PAD_SHAPE::OVAL:
1182 case PAD_SHAPE::RECTANGLE:
1183 case PAD_SHAPE::TRAPEZOID:
1184 case PAD_SHAPE::ROUNDRECT:
1185 case PAD_SHAPE::CHAMFERED_RECT:
1190 if( aPad->
GetShape( aLayer ) == PAD_SHAPE::TRAPEZOID )
1191 trap_delta = aPad->
GetDelta( aLayer ) / 2;
1195 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
1196 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
1197 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
1198 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
1221 if( !outline->IsEmpty() )
1223 for(
const VECTOR2I& pt : outline->Outline( 0 ).CPoints() )
1237 std::vector<TYPED_POINT2I> snap_pts;
1239 if( hole_size.
x == hole_size.
y )
1261 const auto addRectPoints =
1268 const SEG second( topRight, aBox.
GetEnd() );
1269 const SEG third( aBox.
GetEnd(), bottomLeft );
1276 addAnchor( first.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1277 addAnchor( first.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1278 addAnchor( second.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1279 addAnchor( second.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1280 addAnchor( third.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1281 addAnchor( third.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1282 addAnchor( fourth.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1283 addAnchor( fourth.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1286 const auto handleShape =
1294 case SHAPE_T::CIRCLE:
1296 const int r = ( start -
end ).EuclideanNorm();
1314 case SHAPE_T::RECTANGLE:
1320 case SHAPE_T::SEGMENT:
1330 std::vector<VECTOR2I> poly;
1343 case SHAPE_T::BEZIER:
1354 switch( aItem->
Type() )
1364 if( aSelectionFilter && !aSelectionFilter->
pads )
1373 if( !checkVisibility(
pad ) )
1376 if( !
pad->GetBoundingBox().Contains( aRefPos ) )
1379 pad->Padstack().ForEachUniqueLayer(
1384 activeHighContrastPrimaryLayer ) )
1386 handlePadShape(
pad, aLayer );
1391 if( aFrom && aSelectionFilter && !aSelectionFilter->
footprints )
1403 if( (
center - position ).SquaredEuclideanNorm() >
grid.SquaredEuclideanNorm() )
1412 if( aSelectionFilter && !aSelectionFilter->
pads )
1421 if( checkVisibility( aItem ) )
1425 pad->Padstack().ForEachUniqueLayer(
1430 activeHighContrastPrimaryLayer ) )
1432 handlePadShape(
pad, aLayer );
1442 if( aSelectionFilter && !aSelectionFilter->
text )
1451 if( checkVisibility( aItem ) )
1452 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1459 if( aSelectionFilter && !aSelectionFilter->
text )
1468 if( checkVisibility( aItem ) )
1473 VECTOR2I topLeft =
table->GetCell( 0, 0 )->GetCornersInSequence( drawAngle )[0];
1475 table->GetCell(
table->GetRowCount() - 1, 0 )->GetCornersInSequence( drawAngle )[3];
1476 VECTOR2I topRight =
table->GetCell( 0,
table->GetColCount() - 1 )->GetCornersInSequence( drawAngle )[1];
1478 ->GetCornersInSequence( drawAngle )[2];
1493 if( aSelectionFilter && !aSelectionFilter->
graphics )
1502 if( checkVisibility( aItem ) )
1503 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1511 if( aSelectionFilter && !aSelectionFilter->
tracks )
1520 if( checkVisibility( aItem ) )
1539 if( aSelectionFilter && !aSelectionFilter->
vias )
1548 if( checkVisibility( aItem ) )
1554 if( aFrom && aSelectionFilter && !aSelectionFilter->
zones )
1557 if( checkVisibility( aItem ) )
1577 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1580 if( checkVisibility( aItem ) )
1592 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1595 if( checkVisibility( aItem ) )
1604 for(
int i = 0; i < 2; i++ )
1614 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1617 if( checkVisibility( aItem ) )
1629 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1632 if( checkVisibility( aItem ) )
1644 if( aFrom && aSelectionFilter && !aSelectionFilter->
text )
1647 if( checkVisibility( aItem ) )
1655 if( checkVisibility( item ) )
1662 if( aFrom && aSelectionFilter && !aSelectionFilter->
graphics )
1665 if( checkVisibility( aItem ) )
1671 addRectPoints( bbox, *aItem );
1676 aItem, POINT_TYPE::PT_CENTER );
1693 ecoord minDist = std::numeric_limits<ecoord>::max();
1694 std::vector<ANCHOR*> anchorsAtMinDistance;
1700 if( ( aFlags &
anchor.flags ) != aFlags )
1703 if( !anchorsAtMinDistance.empty() &&
anchor.pos == anchorsAtMinDistance.front()->pos )
1706 anchorsAtMinDistance.push_back( &
anchor );
1710 const double dist =
anchor.pos.SquaredDistance( aPos );
1712 if( dist < minDist )
1716 anchorsAtMinDistance.clear();
1717 anchorsAtMinDistance.push_back( &
anchor );
1730 const auto noRealItemsInAnchorAreInvolved = [&](
ANCHOR* aAnchor ) ->
bool
1735 if( !haveExtensions )
1743 if( !anchorIsConstructed )
1747 return !allRealAreInvolved;
1751 std::erase_if( anchorsAtMinDistance, noRealItemsInAnchorAreInvolved );
1758 ecoord minDistToItem = std::numeric_limits<ecoord>::max();
1764 ecoord distToNearestItem = std::numeric_limits<ecoord>::max();
1771 std::optional<ecoord> distToThisItem =
1772 FindSquareDistanceToItem(
static_cast<const BOARD_ITEM&
>( *item ), aPos );
1774 if( distToThisItem )
1775 distToNearestItem = std::min( distToNearestItem, *distToThisItem );
1780 distToNearestItem = std::min( distToNearestItem, minDist );
1782 if( distToNearestItem < minDistToItem )
1784 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
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.
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
void SetSnapTypes(int aSnapTypes)
Set a mask of point types that this snap item represents.
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.
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 const LSET & AllLayersMask()
Class that represents an oval shape (rectangle with semicircular end caps)
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).
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.
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 > 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.
static bool PadstackUniqueLayerAppliesToLayer(const PADSTACK &aPadStack, PCB_LAYER_ID aPadstackUniqueLayer, const PCB_LAYER_ID aRealLayer)
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.
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_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