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;
147 m_magneticSettings( aMagneticSettings )
187 auto constructionItemsBatch = std::make_unique<CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM_BATCH>();
189 std::vector<VECTOR2I> referenceOnlyPoints;
193 std::vector<KIGFX::CONSTRUCTION_GEOM::DRAWABLE> constructionDrawables;
195 switch( item->
Type() )
203 case SHAPE_T::SEGMENT:
205 if( !aExtensionOnly )
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 )
243 constructionDrawables.push_back( shape.
GetCenter() );
249 constructionDrawables.emplace_back( shape.
GetStart() );
250 constructionDrawables.emplace_back( shape.
GetEnd() );
253 referenceOnlyPoints.emplace_back( shape.
GetStart() );
254 referenceOnlyPoints.emplace_back( shape.
GetEnd() );
259 case SHAPE_T::CIRCLE:
260 case SHAPE_T::RECTANGLE:
262 constructionDrawables.push_back( shape.
GetCenter() );
276 constructionDrawables.push_back( refImg.
GetPosition() );
282 constructionDrawables.push_back( seg );
297 std::move( constructionDrawables ),
301 if( referenceOnlyPoints.size() )
312 const int c_gridSnapEpsilon_sq = 4;
319 std::vector<VECTOR2I> points;
321 const SEG testSegments[] = {
SEG( aligned, aligned +
VECTOR2( 1, 0 ) ),
326 for(
const SEG& seg : testSegments )
331 points.push_back( *vec );
338 for(
const VECTOR2I& pt : { aSeg.
A, aSeg.
B } )
340 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
342 if( d_sq < min_d_sq )
352 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
354 if( d_sq < min_d_sq )
372 std::vector<VECTOR2I> points;
385 SEG::ecoord d_sq = ( pt - aPoint ).SquaredEuclideanNorm();
387 if( d_sq < min_d_sq )
397 SEG::ecoord d_sq = ( pt - aligned ).SquaredEuclideanNorm();
399 if( d_sq < min_d_sq )
416 if( item->
HitTest( aMousePos ) )
420 double minDist = std::numeric_limits<double>::max();
421 ANCHOR* nearestOrigin =
nullptr;
428 double dist = a.
Distance( aMousePos );
437 return nearestOrigin ? nearestOrigin->
pos : aMousePos;
442 std::vector<BOARD_ITEM*>& aItems,
448 computeAnchors( aItems, aMousePos,
true, aSelectionFilter,
nullptr,
true );
456 double minDist = std::numeric_limits<double>::max();
460 minDist = nearestOrigin->
Distance( aMousePos );
461 best = nearestOrigin;
466 double dist = nearestCorner->
Distance( aMousePos );
471 best = nearestCorner;
477 double dist = nearestOutline->
Distance( aMousePos );
479 if( minDist > lineSnapMinCornerDistance && dist < minDist )
480 best = nearestOutline;
483 return best ? best->
pos : aMousePos;
491 std::vector<BOARD_ITEM*> item;
496 item.push_back( aReferenceItem );
509 const std::vector<BOARD_ITEM*>& aSkip )
512 const int snapSize = 25;
525 const BOX2I visibilityHorizon =
531 const std::vector<BOARD_ITEM*> visibleItems =
queryVisible( visibilityHorizon, aSkip );
532 computeAnchors( visibleItems, aOrigin,
false,
nullptr, &aLayers,
false );
542 ad->AddAnchor(
anchor.pos );
544 ad->SetNearest( nearest ?
OPT_VECTOR2I{ nearest->
pos } : std::nullopt );
549 std::optional<int> snapDist;
552 snapDist = nearest->
Distance( aOrigin );
559 const auto ptIsReferenceOnly =
563 return std::find( referenceOnlyPoints.begin(), referenceOnlyPoints.end(), aPt )
564 != referenceOnlyPoints.end();
567 const auto proposeConstructionForItems =
568 [&](
const std::vector<EDA_ITEM*>& aItems )
572 std::vector<BOARD_ITEM*> items;
588 items.push_back( boardItem );
597 bool snapValid =
false;
605 aOrigin, nearestGrid, snapDist, snapRange );
620 if( !ptIsReferenceOnly( *snapLineSnap ) )
621 return *snapLineSnap;
626 if( nearest && nearest->
Distance( aOrigin ) <= snapRange )
632 if( ptIsReferenceOnly( nearest->
pos ) )
645 if( !anchorIsConstructed )
646 proposeConstructionForItems( nearest->
items );
648 const auto shouldAcceptAnchor = [&](
const ANCHOR& aAnchor )
653 if( !haveExtensions )
665 return allRealAreInvolved;
668 if( shouldAcceptAnchor( *nearest ) )
687 if( canActivateByHitTest )
692 const int hoverAccuracy = 0;
696 if( item->
HitTest( aOrigin, hoverAccuracy ) )
698 proposeConstructionForItems( { item } );
715 if( nearestPointOnAnElement && nearestPointOnAnElement->Distance( aOrigin ) <= snapRange )
717 updateSnapPoint( { *nearestPointOnAnElement, POINT_TYPE::PT_ON_ELEMENT } );
722 return *nearestPointOnAnElement;
766 switch( aItem->
Type() )
802 if( !
grid.overrides_enabled )
808 if(
grid.override_connected )
809 idx =
grid.override_connected_idx;
814 if(
grid.override_wires )
815 idx =
grid.override_wires_idx;
820 if(
grid.override_vias )
821 idx =
grid.override_vias_idx;
826 if(
grid.override_text )
827 idx =
grid.override_text_idx;
832 if(
grid.override_graphics )
833 idx =
grid.override_graphics_idx;
841 if( idx >= 0 && idx < (
int)
grid.grids.size() )
848std::vector<BOARD_ITEM*>
851 std::set<BOARD_ITEM*> items;
852 std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR> visibleItems;
860 view->
Query( aArea, visibleItems );
862 for(
const auto& [ viewItem, layer ] : visibleItems )
864 if( !viewItem->IsBOARD_ITEM() )
880 if(
IsPcbLayer( layer ) && parentFP->GetPrivateLayers().test( layer ) )
887 && ( !isHighContrast || activeLayers.count( layer ) )
890 items.insert ( boardItem );
897 items.erase( aItem );
904 RECURSE_MODE::RECURSE );
910 return {items.begin(), items.end()};
929 const VECTOR2I& aRefPos,
bool aFrom,
931 const LSET* aMatchLayers,
bool aForDrag )
933 std::vector<PCB_INTERSECTABLE> intersectables;
937 const bool computeIntersections = !aForDrag;
938 const bool computePointsOnElements = !aForDrag;
939 const bool excludeGraphics = aSelectionFilter && !aSelectionFilter->
graphics;
940 const bool excludeTracks = aSelectionFilter && !aSelectionFilter->
tracks;
942 const auto itemIsSnappable =
952 const auto processItem =
956 if( !itemIsSnappable( item ) )
964 if( computeIntersections || computePointsOnElements )
966 std::optional<INTERSECTABLE_GEOM> intersectableGeom;
971 intersectableGeom = GetBoardIntersectable( item );
975 intersectableGeom = GetBoardIntersectable( item );
978 if( intersectableGeom )
979 intersectables.emplace_back( &item, *intersectableGeom );
985 processItem( *item );
997 [&](
const auto& visited )
999 using ItemType = std::decay_t<
decltype( visited )>;
1001 if constexpr( std::is_same_v<ItemType, LINE>
1002 || std::is_same_v<ItemType, CIRCLE>
1003 || std::is_same_v<ItemType, HALF_LINE>
1004 || std::is_same_v<ItemType, SHAPE_ARC> )
1006 intersectables.emplace_back( involvedItem, visited );
1008 else if constexpr( std::is_same_v<ItemType, VECTOR2I> )
1024 if( computeIntersections )
1026 for( std::size_t ii = 0; ii < intersectables.size(); ++ii )
1030 for( std::size_t jj = ii + 1; jj < intersectables.size(); ++jj )
1036 if( intersectableA.
Item == intersectableB.
Item )
1039 std::vector<VECTOR2I> intersections;
1042 std::visit( visitor, intersectableB.
Geometry );
1045 for(
const VECTOR2I& intersection : intersections )
1047 std::vector<EDA_ITEM*> items = {
1048 intersectableA.
Item,
1049 intersectableB.
Item,
1052 POINT_TYPE::PT_INTERSECTION );
1062 if( computePointsOnElements )
1069 [&](
const auto& geom )
1074 intersectable.Geometry );
1086 switch( aPadStack.
Mode() )
1096 switch( aPadstackUniqueLayer )
1101 return aPadstackUniqueLayer == aRealLayer;
1106 wxFAIL_MSG( wxString::Format(
"Unexpected padstack unique layer %d in FRONT_INNER_BACK mode",
1107 aPadstackUniqueLayer ) );
1115 return aRealLayer == aPadstackUniqueLayer;
1132 auto checkVisibility =
1139 bool onActiveLayer = !isHighContrast;
1140 bool isLODVisible =
false;
1144 if( !onActiveLayer && activeLayers.count( layer ) )
1145 onActiveLayer =
true;
1148 isLODVisible =
true;
1150 if( onActiveLayer && isLODVisible )
1163 auto handlePadShape =
1174 case PAD_SHAPE::CIRCLE:
1183 case PAD_SHAPE::OVAL:
1192 case PAD_SHAPE::RECTANGLE:
1193 case PAD_SHAPE::TRAPEZOID:
1194 case PAD_SHAPE::ROUNDRECT:
1195 case PAD_SHAPE::CHAMFERED_RECT:
1200 if( aPad->
GetShape( aLayer ) == PAD_SHAPE::TRAPEZOID )
1201 trap_delta = aPad->
GetDelta( aLayer ) / 2;
1205 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
1206 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
1207 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
1208 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
1231 if( !outline->IsEmpty() )
1233 for(
const VECTOR2I& pt : outline->Outline( 0 ).CPoints() )
1247 std::vector<TYPED_POINT2I> snap_pts;
1249 if( hole_size.
x == hole_size.
y )
1271 const auto addRectPoints =
1278 const SEG second( topRight, aBox.
GetEnd() );
1279 const SEG third( aBox.
GetEnd(), bottomLeft );
1286 addAnchor( first.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1287 addAnchor( first.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1288 addAnchor( second.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1289 addAnchor( second.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1290 addAnchor( third.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1291 addAnchor( third.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1292 addAnchor( fourth.
A, snapFlags, &aRelatedItem, POINT_TYPE::PT_CORNER );
1293 addAnchor( fourth.
Center(), snapFlags, &aRelatedItem, POINT_TYPE::PT_MID );
1296 const auto handleShape =
1304 case SHAPE_T::CIRCLE:
1306 const int r = ( start -
end ).EuclideanNorm();
1324 case SHAPE_T::RECTANGLE:
1330 case SHAPE_T::SEGMENT:
1340 std::vector<VECTOR2I> poly;
1353 case SHAPE_T::BEZIER:
1364 switch( aItem->
Type() )
1374 if( aSelectionFilter && !aSelectionFilter->
pads )
1383 if( !checkVisibility(
pad ) )
1386 if( !
pad->GetBoundingBox().Contains( aRefPos ) )
1389 pad->Padstack().ForEachUniqueLayer(
1394 activeHighContrastPrimaryLayer ) )
1396 handlePadShape(
pad, aLayer );
1401 if( aFrom && aSelectionFilter && !aSelectionFilter->
footprints )
1413 if( (
center - position ).SquaredEuclideanNorm() >
grid.SquaredEuclideanNorm() )
1422 if( aSelectionFilter && !aSelectionFilter->
pads )
1431 if( checkVisibility( aItem ) )
1435 pad->Padstack().ForEachUniqueLayer(
1440 activeHighContrastPrimaryLayer ) )
1442 handlePadShape(
pad, aLayer );
1452 if( aSelectionFilter && !aSelectionFilter->
text )
1461 if( checkVisibility( aItem ) )
1462 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1469 if( aSelectionFilter && !aSelectionFilter->
text )
1478 if( checkVisibility( aItem ) )
1483 VECTOR2I topLeft =
table->GetCell( 0, 0 )->GetCornersInSequence( drawAngle )[0];
1485 table->GetCell(
table->GetRowCount() - 1, 0 )->GetCornersInSequence( drawAngle )[3];
1486 VECTOR2I topRight =
table->GetCell( 0,
table->GetColCount() - 1 )->GetCornersInSequence( drawAngle )[1];
1488 ->GetCornersInSequence( drawAngle )[2];
1503 if( aSelectionFilter && !aSelectionFilter->
graphics )
1512 if( checkVisibility( aItem ) )
1513 handleShape(
static_cast<PCB_SHAPE*
>( aItem ) );
1521 if( aSelectionFilter && !aSelectionFilter->
tracks )
1530 if( checkVisibility( aItem ) )
1549 if( aSelectionFilter && !aSelectionFilter->
vias )
1558 if( checkVisibility( aItem ) )
1564 if( aFrom && aSelectionFilter && !aSelectionFilter->
zones )
1567 if( checkVisibility( aItem ) )
1587 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1590 if( checkVisibility( aItem ) )
1602 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1605 if( checkVisibility( aItem ) )
1614 for(
int i = 0; i < 2; i++ )
1624 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1627 if( checkVisibility( aItem ) )
1639 if( aFrom && aSelectionFilter && !aSelectionFilter->
dimensions )
1642 if( checkVisibility( aItem ) )
1654 if( aFrom && aSelectionFilter && !aSelectionFilter->
text )
1657 if( checkVisibility( aItem ) )
1665 if( checkVisibility( item ) )
1672 if( aFrom && aSelectionFilter && !aSelectionFilter->
graphics )
1675 if( checkVisibility( aItem ) )
1681 addRectPoints( bbox, *aItem );
1686 aItem, POINT_TYPE::PT_CENTER );
1703 ecoord minDist = std::numeric_limits<ecoord>::max();
1704 std::vector<ANCHOR*> anchorsAtMinDistance;
1710 if( ( aFlags &
anchor.flags ) != aFlags )
1713 if( !anchorsAtMinDistance.empty() &&
anchor.pos == anchorsAtMinDistance.front()->pos )
1716 anchorsAtMinDistance.push_back( &
anchor );
1720 const double dist =
anchor.pos.SquaredDistance( aPos );
1722 if( dist < minDist )
1726 anchorsAtMinDistance.clear();
1727 anchorsAtMinDistance.push_back( &
anchor );
1737 ecoord minDistToItem = std::numeric_limits<ecoord>::max();
1743 ecoord distToNearestItem = std::numeric_limits<ecoord>::max();
1750 std::optional<ecoord> distToThisItem =
1751 FindSquareDistanceToItem(
static_cast<const BOARD_ITEM&
>( *item ), aPos );
1753 if( distToThisItem )
1754 distToNearestItem = std::min( distToNearestItem, *distToThisItem );
1759 distToNearestItem = std::min( distToNearestItem, minDist );
1761 if( distToNearestItem < minDistToItem )
1763 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.
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
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
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.
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