27using namespace std::placeholders;
69#include <wx/modalhook.h>
164 if( oldA && oldA->
m_Uuid == newId )
165 itemA->Enable(
false );
167 if( oldB && oldB->
m_Uuid == newId )
168 itemB->Enable(
false );
273 std::shared_ptr<SELECT_MENU> selectMenu = std::make_shared<SELECT_MENU>();
274 selectMenu->SetTool(
this );
275 m_menu->RegisterSubMenu( selectMenu );
277 std::shared_ptr<NET_CHAINS_MENU> netChainsMenu = std::make_shared<NET_CHAINS_MENU>();
278 netChainsMenu->SetTool(
this );
279 m_menu->RegisterSubMenu( netChainsMenu );
283 auto& menu =
m_menu->GetMenu();
285 auto activeToolCondition =
300 auto groupEnterCondition =
303 auto applyDesignBlockLayoutCondition = [](
const SELECTION& aSel )
316 auto inGroupCondition =
332 if( aSel.GetSize() != 1 )
342 menu.AddMenu( netChainsMenu.get(), netItemSelection );
343 menu.AddSeparator( 1000 );
355 menu.AddSeparator( haveHighlight, 1 );
361 menu.AddSeparator( 1 );
406 wxMouseState keyboardState = wxGetMouseState();
408 setModifiersState( keyboardState.ShiftDown(), keyboardState.ControlDown(), keyboardState.AltDown() );
433 trackDragAction = cfg->m_TrackDragAction;
447 else if( evt->IsMouseDown(
BUT_LEFT ) )
473 if( constraintTool->SelectConstraintAt( evt->Position() ) )
479 constraintTool->ClearConstraintSelection();
512 bool selectionCancelled =
false;
516 selectPoint( evt->Position(),
false, &selectionCancelled );
521 m_frame->GetCanvas()->ForceRefresh();
523 if( !selectionCancelled )
537 if( !item->IsBOARD_ITEM() )
539 allSameParent =
false;
547 allSameParent =
false;
555 else if( sharedParent != gen )
557 allSameParent =
false;
562 if( allSameParent && sharedParent )
623 const int delta = evt->Parameter<
int>();
674 wxASSERT_MSG(
false, wxT(
"Unknown selection mode" ) );
681 auto zoneFilledAreaFilter =
684 int accuracy = aCollector.GetGuide()->Accuracy();
685 std::set<EDA_ITEM*> remove;
691 ZONE* zone =
static_cast<ZONE*
>( item );
696 remove.insert( zone );
702 aCollector.Remove( item );
708 if( evt->HasPosition() )
711 &&
selectPoint( evt->DragOrigin(),
false,
nullptr, zoneFilledAreaFilter ) )
729 bool routable = ( segs >= 1 || arcs >= 1 || vias == 1 )
730 && ( segs + arcs + vias ==
m_selection.GetSize() );
740 if( !item->IsBOARD_ITEM() )
780 else if( evt->IsCancel() )
795 else if( evt->FirstResponder() ==
this && evt->GetCommandId() == (
int) WXK_ESCAPE )
807 if( controller &&
m_frame->GetPcbNewSettings()->m_ESCClearsNetHighlight )
810 catch(
const std::runtime_error& e )
812 wxCHECK_MSG(
false, 0, e.what() );
835 wxT(
"EnterGroup called when selection is not a single group" ) );
870 if( settings->IsGroupEditModeActive() == aActive )
875 if( settings->GetOutsideGroupOpacity() < 1.0 )
924 enum DISPOSITION { BEFORE = 1, AFTER,
BOTH };
926 std::map<EDA_ITEM*, DISPOSITION> itemDispositions;
935 itemDispositions[ item ] = BEFORE;
938 aClientFilter(
VECTOR2I(), collector,
this );
944 m_frame->GetCanvas()->ForceRefresh();
951 if( itemDispositions.count( item ) )
952 itemDispositions[ item ] =
BOTH;
954 itemDispositions[ item ] = AFTER;
962 for( std::pair<EDA_ITEM* const, DISPOSITION> itemDisposition : itemDispositions )
964 EDA_ITEM* item = itemDisposition.first;
965 DISPOSITION disposition = itemDisposition.second;
967 if( disposition == BEFORE )
971 for( std::pair<EDA_ITEM* const, DISPOSITION> itemDisposition : itemDispositions )
973 EDA_ITEM* item = itemDisposition.first;
974 DISPOSITION disposition = itemDisposition.second;
978 if( disposition == AFTER || disposition ==
BOTH )
982 m_frame->GetCanvas()->ForceRefresh();
1028 rejected.
SetAll(
false );
1038 if( !
collectAtPoint( aWhere, collector, options, aClientFilter ) )
1046 editFrame->HighlightSelectionFilter( rejected );
1064 if( aSelectionCancelledFlag )
1065 *aSelectionCancelledFlag =
true;
1072 bool anySubtracted =
false;
1079 anySubtracted =
true;
1085 for(
int i = 0; i < collector.
GetCount(); ++i )
1090 anySubtracted =
true;
1100 if( addedCount == 1 )
1105 else if( addedCount > 1 )
1110 else if( anySubtracted )
1147 for(
int i = 0; aAllowedActions[i]; ++i )
1149 if( aEvent->
IsAction( aAllowedActions[i] ) )
1162 if( cell->IsSelected() )
1173 BOX2I selectionRect( aStart, aEnd );
1179 return ( aItem->GetFlags() &
CANDIDATE ) > 0;
1184 bool doSelect =
false;
1186 if( cell->HitTest( selectionRect,
false ) )
1191 doSelect = !wasSelected( cell );
1195 else if( wasSelected( cell ) )
1200 if( doSelect && !cell->IsSelected() )
1202 else if( !doSelect && cell->IsSelected() )
1250 std::set<EDA_ITEM*> previousSelection;
1253 previousSelection.insert( item );
1265 VECTOR2D topLeft( std::min( start.
x,
end.x ), std::min( start.
y,
end.y ) );
1266 VECTOR2D bottomRight( std::max( start.
x,
end.x ), std::max( start.
y,
end.y ) );
1270 bool anyAdded =
false;
1271 bool anySubtracted =
false;
1275 bool wasInPrevious = previousSelection.count( cell ) > 0;
1277 if( cell->IsSelected() && !wasInPrevious )
1279 else if( wasInPrevious && !cell->IsSelected() )
1280 anySubtracted =
true;
1331 if( !cell || cell->
GetParent() != selectedTable )
1343 if( clickedCell->
GetParent() != selectedTable )
1366 bool cancelled =
false;
1372 bool haveAnchorStart =
false;
1379 haveAnchorStart =
true;
1391 return ( aItem->GetFlags() &
CANDIDATE ) > 0;
1396 if( evt->IsCancelInteractive() || evt->IsActivate() )
1405 VECTOR2D start = haveAnchorStart ? anchorStart :
VECTOR2D( evt->DragOrigin() );
1410 else if( evt->IsMouseUp(
BUT_LEFT ) )
1414 bool anyAdded =
false;
1415 bool anySubtracted =
false;
1419 if( cell->IsSelected() && !wasSelected( cell ) )
1421 else if( wasSelected( cell ) && !cell->IsSelected() )
1422 anySubtracted =
true;
1460 bool cancelled =
false;
1473 if( &aTool !=
this )
1482 if(
view->IsMirroredX() )
1483 greedySelection = !greedySelection;
1488 if( evt->IsCancelInteractive() || evt->IsActivate() )
1507 area.
SetEnd( evt->Position() );
1513 view->SetVisible( &area,
true );
1514 view->Update( &area );
1526 view->SetVisible( &area,
false );
1540 view->Remove( &area );
1581 bool cancelled =
false;
1599 bool isClockwise = shapeArea > 0 ? true :
false;
1601 if(
getView()->IsMirroredX() && shapeArea != 0 )
1602 isClockwise = !isClockwise;
1606 if( evt->IsCancelInteractive() || evt->IsActivate() )
1609 evt->SetPassEvent(
false );
1616 points.
Append( evt->Position() );
1618 else if( evt->IsDblClick(
BUT_LEFT )
1624 evt->SetPassEvent(
false );
1660 area.
SetMode( selectionMode );
1692 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
1694 if( !
Selectable( aCollector[i] ) || ( aOptions.
m_OnDrag && aCollector[i]->IsLocked() ) )
1705 aClientFilter( aWhere, aCollector,
this );
1712 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
1714 if( !aCollector[i]->IsSelected() )
1726 catch(
const std::exception& exc )
1728 wxLogWarning( wxS(
"Exception '%s' occurred attempting to guess selection candidates." ),
1747 std::vector<BOARD_ITEM*> items;
1749 for(
int i = 0; i < collector.
GetCount(); ++i )
1750 items.push_back( collector[i] );
1766 std::vector<KIGFX::VIEW::LAYER_ITEM_PAIR>
candidates;
1772 std::set<EDA_ITEM*> group_items;
1780 std::unordered_set<EDA_ITEM*>& newset =
group->GetItems();
1783 [&](
const BOX2I& aBox )
1785 return boxMode ? selectionBox.
Contains( aBox )
1791 if( containedMode && boxContained(
group->GetBoundingBox() ) && newset.size() )
1793 for(
EDA_ITEM* group_item : newset )
1795 if( !group_item->IsBOARD_ITEM() )
1799 collector.
Append( *newset.begin() );
1803 for(
EDA_ITEM* group_item : newset )
1804 group_items.emplace( group_item );
1810 return boxMode ? aItem->HitTest( selectionBox, containedMode )
1811 : aItem->HitTest( aArea.
GetPoly(), containedMode );
1814 for(
const auto& [item, layer] :
candidates )
1816 if( !item->IsBOARD_ITEM() )
1821 if(
Selectable( boardItem ) && hitTest( boardItem )
1822 && ( !containedMode || !group_items.count( boardItem ) ) )
1825 padsCollector.
Append( boardItem );
1827 collector.
Append( boardItem );
1839 collector = padsCollector;
1846 std::sort( collector.
begin(), collector.
end(),
1849 VECTOR2I aPos = a->GetPosition();
1850 VECTOR2I bPos = b->GetPosition();
1852 if( aPos.y == bPos.y )
1853 return aPos.x < bPos.x;
1855 return aPos.y < bPos.y;
1858 std::vector<BOARD_ITEM*> items;
1862 if( i->IsBOARD_ITEM() )
1863 items.push_back(
static_cast<BOARD_ITEM*
>( i ) );
1873 bool anyAdded =
false;
1874 bool anySubtracted =
false;
1878 if( aSubtractive || ( aExclusiveOr && item->IsSelected() ) )
1881 anySubtracted =
true;
1895 else if( anySubtracted )
1902 wxMouseState keyboardState = wxGetMouseState();
1904 setModifiersState( keyboardState.ShiftDown(), keyboardState.ControlDown(), keyboardState.AltDown() );
1948 collection.
Append( item );
1961 m_frame->GetCanvas()->ForceRefresh();
1989 m_frame->GetCanvas()->ForceRefresh();
1999 std::set<int> representedNets;
2001 for(
int i = aCollector.
GetCount() - 1; i >= 0; i-- )
2007 else if ( representedNets.count( item->
GetNetCode() ) )
2010 representedNets.insert( item->
GetNetCode() );
2017 std::deque<EDA_ITEM*> selectedItems =
m_selection.GetItems();
2020 std::vector<BOARD_CONNECTED_ITEM*> toUnroute;
2021 std::set<EDA_ITEM*> toDelete;
2023 for(
EDA_ITEM* item : selectedItems )
2028 toUnroute.push_back(
pad );
2032 toDelete.insert( item );
2048 std::set<int> selectedNets;
2051 if( item->GetNetCode() > 0 )
2052 selectedNets.insert( item->GetNetCode() );
2054 std::set<VECTOR2I> endpointSet;
2060 endpointSet.insert( track->GetStart() );
2061 endpointSet.insert( track->GetEnd() );
2065 endpointSet.insert( item->GetPosition() );
2069 endpointSet.insert( item->GetPosition() );
2073 bool expanded =
true;
2081 if( toDelete.count( gen ) )
2085 std::map<VECTOR2I, int> epCount;
2087 for(
BOARD_ITEM* child : gen->GetBoardItems() )
2091 if( track && selectedNets.count( track->
GetNetCode() ) )
2094 epCount[track->
GetEnd()]++;
2099 bool connected =
false;
2101 for(
auto& [pt, count] : epCount )
2103 if( count == 1 && endpointSet.count( pt ) )
2112 toDelete.insert( gen );
2126 endpointSet.insert( track->GetStart() );
2127 endpointSet.insert( track->GetEnd() );
2150 std::set<BOARD_ITEM*> removed;
2154 if( !item->IsBOARD_ITEM() )
2160 toDelete.insert( bi );
2163 removed.insert( bi );
2169 for(
BOARD_ITEM* child : gen->GetBoardItems() )
2171 if( removed.count( child ) )
2173 toDelete.insert( gen );
2181 if( !item->IsBOARD_ITEM() )
2189 if( removed.find( aItem ) == removed.end() )
2192 removed.insert( aItem );
2197 if( removed.find( boardItem ) == removed.end() )
2198 commit.
Remove( boardItem );
2202 commit.
Push(
_(
"Unroute Selected" ) );
2207 for(
EDA_ITEM* item : selectedItems )
2219 std::deque<EDA_ITEM*> selectedItems =
m_selection.GetItems();
2222 std::vector<BOARD_CONNECTED_ITEM*> toUnroute;
2224 std::set<EDA_ITEM*> toDelete;
2226 for(
EDA_ITEM* item : selectedItems )
2237 if( !toDelete.count( gen ) )
2239 toDelete.insert( gen );
2243 toDelete.insert( generatedItem );
2253 toDelete.insert( item );
2258 toDelete.insert( item );
2262 toDelete.insert( generatedItem );
2273 std::deque<EDA_ITEM*> toSelectAfter;
2277 if( !item->IsBOARD_ITEM() )
2280 if( toDelete.find( item ) == toDelete.end() )
2281 toSelectAfter.push_back( item );
2285 std::set<BOARD_ITEM*> removed;
2289 if( !item->IsBOARD_ITEM() )
2299 if( removed.insert( aItem ).second )
2304 if( removed.insert( boardItem ).second )
2305 commit.
Remove( boardItem );
2309 if( removed.insert( boardItem ).second )
2310 commit.
Remove( boardItem );
2314 commit.
Push(
_(
"Unroute Segment" ) );
2319 for(
EDA_ITEM* item : toSelectAfter )
2321 if( !toDelete.count( item ) )
2334 unsigned initialCount = 0;
2346 if( initialCount == 0 )
2349 std::vector<PCB_SHAPE*> startShapes;
2354 startShapes.push_back(
static_cast<PCB_SHAPE*
>( item ) );
2358 if( !startShapes.empty() )
2364 m_frame->SetStatusText(
_(
"Select/Expand Connection..." ) );
2368 std::deque<EDA_ITEM*> selectedItems =
m_selection.GetItems();
2370 for(
EDA_ITEM* item : selectedItems )
2371 item->ClearTempFlags();
2373 std::vector<BOARD_CONNECTED_ITEM*> startItems;
2375 for(
EDA_ITEM* item : selectedItems )
2382 startItems.push_back(
pad );
2400 if(
m_selection.GetItems().size() > initialCount )
2404 m_frame->SetStatusText( wxEmptyString );
2417 double refreshIntervalMs = 500;
2418 int lastSelectionSize = (int)
m_selection.GetSize();
2423 const auto inScope = [
this](
BOARD_ITEM* aItem )
2428 std::set<PAD*> startPadSet;
2429 std::vector<BOARD_CONNECTED_ITEM*> cleanupItems;
2435 startPadSet.insert(
static_cast<PAD*
>( startItem ) );
2438 if( startItem->IsType( { PCB_TRACE_T, PCB_ARC_T, PCB_VIA_T } ) )
2447 std::map<VECTOR2I, std::vector<PCB_TRACK*>> trackMap;
2448 std::map<VECTOR2I, std::vector<PCB_VIA*>> viaMap;
2449 std::map<VECTOR2I, PAD*> padMap;
2450 std::map<VECTOR2I, std::vector<PCB_SHAPE*>> shapeMap;
2451 std::vector<std::pair<VECTOR2I, LSET>> activePts;
2461 switch( item->Type() )
2467 trackMap[track->
GetStart()].push_back( track );
2468 trackMap[track->
GetEnd()].push_back( track );
2478 viaMap[
via->GetStart()].push_back(
via );
2485 padMap[
pad->GetPosition()] =
pad;
2494 shapeMap[point].push_back( shape );
2505 switch( startItem->Type() )
2518 activePts.push_back( { startItem->GetPosition(), startItem->GetLayerSet() } );
2522 activePts.push_back( { startItem->GetPosition(), startItem->GetLayerSet() } );
2530 activePts.push_back( { point, startItem->GetLayerSet() } );
2543 while( expand && failSafe++ < 100000 )
2547 for(
int i = (
int) activePts.size() - 1; i >= 0; --i )
2555 auto better = [&](
PCB_VIA* aCandidate )
2561 auto settled = [&]()
2567 auto exactIt = viaMap.find( pt );
2569 if( exactIt != viaMap.end() )
2573 if( (
via->GetLayerSet() & layerSetCu ).any() && better(
via ) )
2584 for(
auto& [pos, vias] : viaMap )
2588 if( !(
via->GetLayerSet() & layerSetCu ).any() || !better(
via ) )
2593 int radius =
via->GetWidth( layer ) / 2;
2594 int64_t radiusSq =
static_cast<int64_t
>(
radius ) *
radius;
2596 if( ( pt - pos ).SquaredEuclideanNorm() <= radiusSq )
2614 auto padIt = padMap.find( pt );
2616 bool gotVia = hitVia !=
nullptr;
2617 bool gotPad = padIt != padMap.end() && ( padIt->second->GetLayerSet() & layerSetCu ).any();
2618 bool gotNonStartPad = gotPad && ( startPadSet.find( padIt->second ) == startPadSet.end() );
2622 activePts.erase( activePts.begin() + i );
2628 activePts.erase( activePts.begin() + i );
2634 size_t pt_count = 0;
2638 if( track->GetStart() != track->GetEnd() && layerSetCu.
Contains( track->GetLayer() ) )
2642 if( pt_count > 2 || gotVia || gotNonStartPad )
2644 activePts.erase( activePts.begin() + i );
2650 if( gotNonStartPad )
2652 activePts.erase( activePts.begin() + i );
2659 PAD*
pad = padIt->second;
2664 cleanupItems.push_back(
pad );
2666 activePts.push_back( {
pad->GetPosition(),
pad->GetLayerSet() } );
2673 if( !layerSetCu.
Contains( track->GetLayer() ) )
2679 if( !track->IsSelected() && inScope( track ) )
2685 cleanupItems.push_back( track );
2687 if( track->GetStart() == pt )
2688 activePts.push_back( { track->GetEnd(), track->GetLayerSet() } );
2690 activePts.push_back( { track->GetStart(), track->GetLayerSet() } );
2699 if( !layerSetCu.
Contains( shape->GetLayer() ) )
2705 if( !shape->IsSelected() && inScope( shape ) )
2711 cleanupItems.push_back( shape );
2713 for(
const VECTOR2I& newPoint : shape->GetConnectionPoints() )
2715 if( newPoint == pt )
2718 activePts.push_back( { newPoint, shape->GetLayerSet() } );
2728 if( !hitVia->
IsSelected() && inScope( hitVia ) )
2734 cleanupItems.push_back( hitVia );
2741 maxRadius = std::max( maxRadius, hitVia->
GetWidth( layer ) / 2 );
2743 int64_t maxRadiusSq =
static_cast<int64_t
>( maxRadius ) * maxRadius;
2745 for(
auto& [trkPt, tracks] : trackMap )
2747 if( ( trkPt - viaPos ).SquaredEuclideanNorm() > maxRadiusSq )
2751 bool inside =
false;
2760 int r = hitVia->
GetWidth( trkLayer ) / 2;
2761 int64_t rSq =
static_cast<int64_t
>( r ) * r;
2763 if( ( trkPt - viaPos ).SquaredEuclideanNorm() <= rSq )
2771 activePts.push_back( { trkPt, hitVia->
GetLayerSet() } );
2775 activePts.push_back( { viaPos, hitVia->
GetLayerSet() } );
2782 activePts.erase( activePts.begin() + i );
2786 if( refreshTimer.
msecs() >= refreshIntervalMs )
2790 m_frame->GetCanvas()->ForceRefresh();
2794 refreshTimer.
Start();
2799 std::set<EDA_ITEM*> toDeselect;
2800 std::set<EDA_ITEM*> toSelect;
2806 if( !item->IsBOARD_ITEM() )
2819 toDeselect.insert( item );
2864 std::stack<PCB_SHAPE*> toSearch;
2865 std::set<PCB_SHAPE*> toCleanup;
2867 for(
PCB_SHAPE* startItem : aStartItems )
2868 toSearch.push( startItem );
2881 toSearch.push(
static_cast<PCB_SHAPE*
>( item ) );
2885 while( !toSearch.empty() )
2894 toCleanup.insert( shape );
2903 searchPoint( shape->
GetEnd() );
2914 std::vector<PAD*> pads;
2921 pads.push_back(
pad );
2925 pads.push_back(
static_cast<PAD*
>( item ) );
2934 for(
const CN_EDGE& edge : conn->GetRatsnestForPad(
pad ) )
2936 wxCHECK2( edge.GetSourceNode() && !edge.GetSourceNode()->Dirty(),
continue );
2937 wxCHECK2( edge.GetTargetNode() && !edge.GetTargetNode()->Dirty(),
continue );
2942 if( sourceParent ==
pad )
2945 select(
static_cast<PAD*
>( targetParent )->GetParent() );
2947 else if( targetParent ==
pad )
2950 select(
static_cast<PAD*
>( sourceParent )->GetParent() );
2962 std::vector<BOARD_CONNECTED_ITEM*> sourceItems;
2963 std::vector<FOOTPRINT*> nearestFootprints;
2970 sourceItems.push_back(
pad );
2974 sourceItems.push_back( connItem );
2979 std::shared_ptr<CN_CONNECTIVITY_ALGO> connAlgo = conn->GetConnectivityAlgo();
2983 RN_NET* net = conn->GetRatsnestForNet( sourceItem->GetNetCode() );
2986 if( !net || net->
GetEdges().empty() || !connAlgo->ItemExists( sourceItem ) )
2989 std::vector<std::shared_ptr<CN_CLUSTER>> sourceClusters;
2991 for(
CN_ITEM* cnItem : connAlgo->ItemEntry( sourceItem ).GetItems() )
2993 for(
const std::shared_ptr<CN_ANCHOR>&
anchor : cnItem->Anchors() )
2995 if(
anchor->GetCluster() )
2996 sourceClusters.push_back(
anchor->GetCluster() );
3000 if( sourceClusters.empty() )
3003 auto isSourceAnchor =
3004 [&](
const std::shared_ptr<const CN_ANCHOR>& aAnchor )
3006 if( aAnchor->Parent() == sourceItem )
3009 return std::find( sourceClusters.begin(), sourceClusters.end(),
3010 aAnchor->GetCluster() ) != sourceClusters.end();
3013 double currentDistance = DBL_MAX;
3019 const std::shared_ptr<const CN_ANCHOR>&
source = edge.GetSourceNode();
3020 const std::shared_ptr<const CN_ANCHOR>& target = edge.GetTargetNode();
3022 wxCHECK2(
source && !
source->Dirty() && target && !target->Dirty(),
continue );
3024 if(
source->Parent()->GetParentFootprint() == target->Parent()->GetParentFootprint() )
3029 bool sourceMatches = isSourceAnchor(
source );
3030 bool targetMatches = isSourceAnchor( target );
3032 if( sourceMatches == targetMatches )
3041 if( edge.GetLength() < currentDistance )
3043 currentDistance = edge.GetLength();
3048 if( nearest !=
nullptr )
3049 nearestFootprints.push_back( nearest );
3052 if( nearestFootprints.empty() )
3057 for(
FOOTPRINT* footprint : nearestFootprints )
3070 for(
BOARD_ITEM* item : conn->GetNetItems( aNetCode, { PCB_TRACE_T,
3144 const wxString& chainName = netInfo->
GetNetChain();
3146 if( chainName.IsEmpty() )
3155 if( candidate && candidate->GetNetChain() == chainName )
3171 std::vector<BOARD_ITEM*> footprints;
3176 if( footprint ==
nullptr )
3179 wxString footprint_path = footprint->GetPath().AsString().BeforeLast(
'/' );
3181 if( footprint_path.IsEmpty() )
3182 footprint_path +=
'/';
3184 if( footprint_path == aSheetPath )
3185 footprints.push_back( footprint );
3201 std::list<int> netcodeList;
3202 std::vector<BOARD_CONNECTED_ITEM*> padList;
3206 switch( item->Type() )
3212 if(
pad->IsConnected() )
3214 netcodeList.push_back(
pad->GetNetCode() );
3215 padList.push_back(
pad );
3226 if(
pad->IsConnected() )
3228 netcodeList.push_back(
pad->GetNetCode() );
3229 padList.push_back(
pad );
3241 std::sort( padList.begin(), padList.end() );
3245 netcodeList.unique();
3251 std::vector<int> removeCodeList;
3254 for(
int netCode : netcodeList )
3258 if( !std::binary_search( padList.begin(), padList.end(),
pad ) )
3262 removeCodeList.push_back( netCode );
3268 for(
int removeCode : removeCodeList )
3269 netcodeList.remove( removeCode );
3271 std::unordered_set<BOARD_ITEM*> localConnectionList;
3273 for(
int netCode : netcodeList )
3275 for(
BOARD_ITEM* item : conn->GetNetItems( netCode, { PCB_TRACE_T,
3280 localConnectionList.insert( item );
3284 for(
BOARD_ITEM* item : localConnectionList )
3291 std::vector<BOARD_ITEM*>* items = aEvent.
Parameter<std::vector<BOARD_ITEM*>*>();
3302 std::vector<BOARD_ITEM*>* items = aEvent.
Parameter<std::vector<BOARD_ITEM*>*>();
3320 if( item->IsMoving() )
3337 if(
m_frame->GetPcbNewSettings()->m_CrossProbing.center_on_items )
3339 if(
m_frame->GetPcbNewSettings()->m_CrossProbing.zoom_to_fit )
3346 m_frame->GetCanvas()->ForceRefresh();
3356 wxString sheetPath = *aEvent.
Parameter<wxString*>();
3382 if( !footprint || footprint->
GetPath().empty() )
3388 wxString sheetPath = footprint->
GetPath().
AsString().BeforeLast(
'/' );
3390 if( sheetPath.IsEmpty() )
3411 screenSize.
x = std::max( 10.0, screenSize.
x );
3412 screenSize.
y = std::max( 10.0, screenSize.
y );
3417 double scale =
view->GetScale() / std::max( fabs( vsize.
x / screenSize.
x ),
3418 fabs( vsize.
y / screenSize.
y ) );
3424 m_frame->GetCanvas()->ForceRefresh();
3440#ifdef DEFAULT_PCBNEW_CODE
3442 auto screenSize =
view->ToWorld( GetCanvas()->GetClientSize(),
false );
3445 screenSize.x = std::max( 10.0, fabs( screenSize.x ) );
3446 screenSize.y = std::max( 10.0, screenSize.y );
3447 double ratio = std::max( fabs( bbSize.x / screenSize.x ), fabs( bbSize.y / screenSize.y ) );
3450 if( crossProbingSettings.zoom_to_fit && ( ratio < 0.5 || ratio > 1.0 ) )
3451 view->SetScale(
view->GetScale() / ratio );
3454#ifndef DEFAULT_PCBNEW_CODE
3471 double compRatio = bbSize.y / currTextHeight;
3474 double compRatioBent = 1.0;
3485 screenSize.
x = std::max( 10.0, fabs( screenSize.
x ) );
3486 screenSize.
y = std::max( 10.0, screenSize.
y );
3487 double ratio = std::max( -1.0, fabs( bbSize.y / screenSize.
y ) );
3490 double kicadRatio = std::max( fabs( bbSize.x / screenSize.
x ),
3491 fabs( bbSize.y / screenSize.
y ) );
3499 std::vector<std::pair<double, double>> lut {
3512 std::vector<std::pair<double, double>>::iterator it;
3514 compRatioBent = lut.back().second;
3516 if( compRatio >= lut.front().first )
3522 for( it = lut.begin(); it < lut.end() - 1; it++ )
3524 if( it->first <= compRatio &&
next( it )->first >= compRatio )
3526 double diffx = compRatio - it->first;
3527 double diffn =
next( it )->first - it->first;
3529 compRatioBent = it->second + (
next( it )->second - it->second ) * diffx / diffn;
3536 compRatioBent = lut.front().second;
3544 if( bbSize.x > screenSize.
x * ratio * compRatioBent )
3548 compRatioBent = 1.0;
3549 wxLogTrace(
"CROSS_PROBE_SCALE",
"Part TOO WIDE for screen. Using normal KiCad zoom ratio: %1.5f", ratio );
3554 ratio *= compRatioBent;
3556 bool alwaysZoom =
false;
3559 if( ( ratio < 0.5 || ratio > 1.0 ) || alwaysZoom )
3560 view->SetScale(
view->GetScale() / ratio );
3567 bool cleared =
false;
3579 switch( aItem->
Type() )
3583 int netCode =
static_cast<NETINFO_ITEM*
>( aItem )->GetNetCode();
3602 double marginFactor = 2;
3611 double scaleX = screenSize.
x /
static_cast<double>( aItem->
GetBoundingBox().GetWidth() );
3612 double scaleY = screenSize.
y /
static_cast<double>( aItem->
GetBoundingBox().GetHeight() );
3614 scaleX /= marginFactor;
3615 scaleY /= marginFactor;
3617 double scale = scaleX > scaleY ? scaleY : scaleX;
3636 m_frame->GetCanvas()->ForceRefresh();
3648 switch( aItem.
Type() )
3709 if( cmd != wxID_OK )
3720 if( !i->IsBOARD_ITEM() )
3742 std::set<BOARD_ITEM*> rejected;
3746 if( !i->IsBOARD_ITEM() )
3752 rejected.insert( item );
3756 aCollector.
Remove( item );
3821 aRejected->
pads =
true;
3833 aRejected->
tracks =
true;
3844 aRejected->
vias =
true;
3853 ZONE* zone =
static_cast<ZONE*
>( aItem );
3863 aRejected->
zones =
true;
3872 if( zone ==
m_frame->GetBoard()->m_SolderMaskBridges )
3903 aRejected->
text =
true;
3941 aRejected->
points =
true;
4012 if( cell->HitTest( aPosition, 0 ) )
4021 if( !clicked || !
table->IsDataRow( clicked->
GetRow() ) )
4028 if( cell->GetRow() == clicked->
GetRow() )
4046 bool enteredGroupFound =
false;
4049 [&](
EDA_ITEM* item,
void* testData )
4067 enteredGroupFound =
true;
4081 if( !enteredGroupFound )
4092 const LSET& aEnabledLayers )
4094 return aVisibleLayers & aEnabledLayers;
4107 return ( aPad.
GetLayerSet() & aVisibleLayers ).any();
4112 bool aBackVisible,
bool aIsFootprintEditor )
4116 if( aIsFootprintEditor || !parentFP )
4120 switch( aItem.
Type() )
4142 if( !onFront && !onBack )
4152 return ( onFront && aFrontVisible ) || ( onBack && aBackVisible );
4161 auto visibleLayers =
4169 set.
set( layer,
view()->IsLayerVisible( layer ) );
4176 board()->GetEnabledLayers() );
4201 bool onActiveLayer =
false;
4203 for(
int layer : activeLayers )
4206 if( layer < PCB_LAYER_ID_COUNT && aItem->IsOnLayer(
ToLAYER_ID( layer ) ) )
4208 onActiveLayer =
true;
4231 && footprint->
Pads().empty()
4232 && footprint->
Zones().empty()
4233 && footprint->
Points().empty() )
4250 for(
const ZONE* zone : footprint->
Zones() )
4287 const ZONE* zone =
nullptr;
4289 const PAD*
pad =
nullptr;
4302 switch( aItem->
Type() )
4308 zone =
static_cast<const ZONE*
>( aItem );
4326 if( !layerVisible( aItem->
GetLayer() ) )
4338 if( !( visibleLayers() &
via->GetLayerSet() ).any() )
4344 field =
static_cast<const PCB_FIELD*
>( aItem );
4360 if( !layerVisible(
text->GetLayer() ) )
4371 if(
text->GetText() == wxT(
"${REFERENCE}" ) )
4373 else if(
text->GetText() == wxT(
"${VALUE}" ) )
4376 if( !
view()->IsLayerVisible( controlLayer ) )
4390 if( !layerVisible( aItem->
GetLayer() ) )
4399 if( !layerVisible( aItem->
GetLayer() ) )
4405 if( !layerVisible( aItem->
GetLayer() ) )
4414 if( !layerVisible( aItem->
GetLayer() ) )
4422 if( !layerVisible( aItem->
GetLayer() ) )
4435 if( !layerVisible( aItem->
GetLayer() ) )
4444 pad =
static_cast<const PAD*
>( aItem );
4452 marker =
static_cast<const PCB_MARKER*
>( aItem );
4460 if( !layerVisible( aItem->
GetLayer() ) )
4521 aGroup->
Add( aItem );
4598 const unsigned GRIP_MARGIN = 20;
4604 if( !item->IsBOARD_ITEM() )
4607 BOX2I itemBox = item->ViewBBox();
4612 if( item->HitTest( aPoint, margin ) )
4619 group->RunOnChildren(
4622 if( aItem->
HitTest( aPoint, margin ) )
4642 SEG loc( aWhere, aWhere );
4644 switch( aItem->
Type() )
4652 if(
text->GetEffectiveTextShape()->Collide( loc, aMaxDistance, &
distance ) )
4674 shape->Collide( loc, aMaxDistance, &
distance );
4696 ZONE* zone =
static_cast<ZONE*
>( aItem );
4718 catch(
const std::exception& e )
4720 wxFAIL_MSG( wxString::Format( wxT(
"Clipper exception occurred: %s" ), e.what() ) );
4750 int actual = aMaxDistance;
4752 if( poly->Outline().Collide( loc, aMaxDistance, &
actual ) )
4768 static_cast<PAD*
>( aItem )->Padstack().ForEachUniqueLayer(
4771 int layerDistance = INT_MAX;
4797 wxCHECK( settings, );
4800 LSET visibleLayers =
m_frame->GetBoard()->GetVisibleLayers();
4801 LSET enabledLayers =
m_frame->GetBoard()->GetEnabledLayers();
4804 wxCHECK( !enabledLayerStack.empty(), );
4806 auto isZoneFillKeepout =
4811 const ZONE* zone =
static_cast<const ZONE*
>( aItem );
4820 std::vector<LAYER_OPACITY_ITEM> opacityStackup;
4822 for(
int i = 0; i < aCollector.
GetCount(); i++ )
4826 LSET itemLayers = item->
GetLayerSet() & enabledLayers & visibleLayers;
4827 LSEQ itemLayerSeq = itemLayers.
Seq( enabledLayerStack );
4840 opacityItem.
m_Item = item;
4842 if( isZoneFillKeepout( item ) )
4845 opacityStackup.emplace_back( opacityItem );
4849 std::sort( opacityStackup.begin(), opacityStackup.end(),
4852 int retv = enabledLayerStack.TestLayers( aLhs.m_Layer, aRhs.m_Layer );
4857 return aLhs.m_Opacity > aRhs.m_Opacity;
4860 std::set<const BOARD_ITEM*> visibleItems;
4861 std::set<const BOARD_ITEM*> itemsToRemove;
4863 double currentStackupOpacity = 0.0;
4870 currentStackupOpacity = opacityItem.m_Opacity;
4871 lastVisibleLayer = opacityItem.m_Layer;
4872 visibleItems.emplace( opacityItem.m_Item );
4882 wxCHECK( item,
false );
4885 if( visibleItems.count( item ) )
4891 && visibleItems.count( item->
GetParent() ) )
4898 if( isZoneFillKeepout( item ) )
4905 if( opacityItem.m_Layer == enabledLayerStack[0] )
4907 visibleItems.emplace( opacityItem.m_Item );
4911 double itemVisibility = opacityItem.m_Opacity * ( 1.0 - currentStackupOpacity );
4913 if( ( itemVisibility <= minAlphaLimit ) && !ignoreItem() )
4914 itemsToRemove.emplace( opacityItem.m_Item );
4916 visibleItems.emplace( opacityItem.m_Item );
4919 if( opacityItem.m_Layer != lastVisibleLayer )
4921 currentStackupOpacity += opacityItem.m_Opacity * ( 1.0 - currentStackupOpacity );
4922 currentStackupOpacity = std::min( currentStackupOpacity, 1.0 );
4923 lastVisibleLayer = opacityItem.m_Layer;
4927 for(
const BOARD_ITEM* itemToRemove : itemsToRemove )
4929 wxCHECK( aCollector.
GetCount() > 1, );
4930 aCollector.
Remove( itemToRemove );
4953 static std::vector<KICAD_T> singleLayerSilkTypes = {
PCB_FIELD_T,
4965 std::set<BOARD_ITEM*> preferred;
4966 std::set<BOARD_ITEM*> rejected;
4973 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
4978 if( aCollector[i]->GetLayer() == activeLayer )
4979 preferred.insert( aCollector[i] );
4980 else if( aCollector.
GetCount() > 1 )
4986 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
4996 if( silkLayers[activeLayer] )
4998 for(
int i = 0; i < aCollector.
GetCount(); ++i )
5002 if( item->
IsType( singleLayerSilkTypes ) && silkLayers[ item->
GetLayer() ] )
5003 preferred.insert( item );
5008 else if( courtyardLayers[activeLayer] && settings->
GetHighContrast() )
5010 for(
int i = 0; i < aCollector.
GetCount(); ++i )
5015 preferred.insert( item );
5019 if( preferred.size() > 0 )
5024 aCollector.
Append( item );
5026 if( preferred.size() == 1 )
5031 constexpr int MAX_SLOP = 5;
5035 int minSlop = INT_MAX;
5037 std::map<BOARD_ITEM*, int> itemsBySloppiness;
5039 for(
int i = 0; i < aCollector.
GetCount(); ++i )
5044 itemsBySloppiness[ item ] = itemSlop;
5046 if( itemSlop < minSlop )
5051 if( minSlop < INT_MAX )
5053 for( std::pair<BOARD_ITEM*, int> pair : itemsBySloppiness )
5055 if( pair.second > minSlop + singlePixel )
5062 constexpr double sizeRatio = 1.5;
5064 std::vector<std::pair<BOARD_ITEM*, double>> itemsByArea;
5066 for(
int i = 0; i < aCollector.
GetCount(); ++i )
5075 area = (double)
SEG::Square( singlePixel ) * MAX_SLOP;
5094 catch(
const std::exception& e )
5096 wxFAIL_MSG( wxString::Format( wxT(
"Clipper exception occurred: %s" ), e.what() ) );
5100 itemsByArea.emplace_back( item, area );
5103 std::sort( itemsByArea.begin(), itemsByArea.end(),
5104 [](
const std::pair<BOARD_ITEM*, double>& lhs,
5105 const std::pair<BOARD_ITEM*, double>& rhs ) ->
bool
5107 return lhs.second < rhs.second;
5110 bool rejecting =
false;
5112 for(
int i = 1; i < (int) itemsByArea.size(); ++i )
5114 if( itemsByArea[i].second > itemsByArea[i-1].second * sizeRatio )
5118 rejected.insert( itemsByArea[i].first );
5123 constexpr double maxCoverRatio = 0.70;
5125 for(
int i = 0; i < aCollector.
GetCount(); ++i )
5129 if( footprint->CoverageRatio( aCollector ) > maxCoverRatio )
5130 rejected.erase( footprint );
5135 if( (
unsigned) aCollector.
GetCount() > rejected.size() )
5147 bool haveItemOnActive =
false;
5150 for(
int i = 0; i < aCollector.
GetCount(); ++i )
5152 if( !aCollector[i]->IsOnLayer( activeLayer ) )
5153 rejected.insert( aCollector[i] );
5155 haveItemOnActive =
true;
5158 if( haveItemOnActive )
5171 m_frame->ShowInfoBarWarning(
_(
"Selection contains locked items. "
5172 "Enable 'Override locks' to operate on them." ),
5182 bool lockedDescendant =
false;
5188 lockedDescendant =
true;
5192 return lockedDescendant;
5197 bool aIsFootprintEditor )
5233 for(
int i = (
int) aCollector.
GetCount() - 1; i >= 0; --i )
5239 aCollector.
Remove( &item );
5249 std::unordered_set<EDA_ITEM*> toAddSet;
5252 std::vector<EDA_ITEM*> toAdd;
5257 if( toAddSet.insert( aGroup ).second )
5258 toAdd.push_back( aGroup );
5263 for(
int j = 0; j < aCollector.
GetCount(); j++ )
5265 if( aCollector[j]->GetParent() )
5266 aCollector[j]->GetParent()->ClearFlags(
CANDIDATE );
5268 if( aCollector[j]->GetParentFootprint() )
5269 aCollector[j]->GetParentFootprint()->ClearFlags(
CANDIDATE );
5274 for(
int j = 0; j < aCollector.
GetCount(); j++ )
5278 for(
int j = 0; j < aCollector.
GetCount(); )
5290 aCollector.
Remove( item );
5307 selectableParent = gen;
5311 if( !selectableParent )
5315 if(
top->AsEdaItem() != item )
5317 queueGroup(
top->AsEdaItem() );
5320 aCollector.
Remove( item );
5327 for(
int k = aCollector.
GetCount() - 1; k >= 0; --k )
5329 if( aCollector[k] == selectableParent )
5345 aCollector.
Remove( item );
5354 if( !aCollector.
HasItem( item ) )
5355 aCollector.
Append( item );
5362 std::set<BOARD_ITEM*> to_add;
5365 for(
int i = (
int) aCollector.
GetCount() - 1; i >= 0; --i )
5374 aCollector.
Remove( item );
5379 aCollector.
Append( item );
5384 bool aForcePromotion )
const
5386 std::set<BOARD_ITEM*> to_add;
5389 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
5394 && ( !
frame()->GetPcbNewSettings()->m_AllowFreePads || aForcePromotion ) )
5399 aCollector.
Remove( item );
5404 aCollector.
Append( item );
5411 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
5416 aCollector.
Remove( item );
5428 bool need_direct_hit =
false;
5436 need_direct_hit =
true;
5444 else if( item->IsBOARD_ITEM() )
5445 fp =
static_cast<BOARD_ITEM*
>( item )->GetParentFootprint();
5451 single_fp =
nullptr;
5454 else if( !single_fp )
5460 else if( single_fp != fp )
5462 single_fp =
nullptr;
5468 auto visibleLayers =
5476 set.
set( layer,
view()->IsLayerVisible( layer ) );
5488 LSET layers = visibleLayers();
5496 for(
int layer : activeLayers )
5499 layers.
set( layer );
5504 for(
int i = aCollector.
GetCount() - 1; i >= 0; --i )
5520 aCollector.
Remove( item );
5522 bool has_hit =
false;
5536 aCollector.
Remove( item );
5541 else if( single_fp )
5543 if( fp == single_fp )
5546 else if( need_direct_hit )
5560 aCollector.
Remove( item );
5577 std::set<std::pair<PCB_TABLE*, int>> columns;
5585 columns.insert( std::make_pair(
table, cell->GetColumn() ) );
5589 for(
auto& [
table, col ] : columns )
5591 for(
int row = 0; row <
table->GetRowCount(); ++row )
5612 std::set<std::pair<PCB_TABLE*, int>>
rows;
5620 rows.insert( std::make_pair(
table, cell->GetRow() ) );
5626 for(
int col = 0; col <
table->GetColCount(); ++col )
5647 std::set<PCB_TABLE*> tables;
5653 tables.insert(
static_cast<PCB_TABLE*
>( cell->GetParent() ) );
5660 if( !
table->IsSelected() )
std::function< void(const VECTOR2I &, GENERAL_COLLECTOR &, PCB_SELECTION_TOOL *)> CLIENT_SELECTION_FILTER
constexpr EDA_IU_SCALE pcbIUScale
constexpr BOX2I BOX2ISafe(const BOX2D &aInput)
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
static TOOL_ACTION cancelInteractive
static TOOL_ACTION unselectAll
static TOOL_ACTION selectItem
Select an item (specified as the event parameter).
static TOOL_ACTION cursorLeft
static TOOL_ACTION zoomOutCenter
static TOOL_ACTION unselectItem
static TOOL_ACTION zoomIn
static TOOL_ACTION cursorLeftFast
static TOOL_ACTION selectionCursor
Select a single item under the cursor position.
static TOOL_ACTION selectSetLasso
static TOOL_ACTION selectSetRect
Set lasso selection mode.
static TOOL_ACTION groupEnter
static TOOL_ACTION selectColumns
static TOOL_ACTION cursorDown
static TOOL_ACTION zoomOut
static TOOL_ACTION cursorRightFast
static TOOL_ACTION deleteLastPoint
static TOOL_ACTION zoomCenter
static TOOL_ACTION panDown
static TOOL_ACTION cursorDblClick
static TOOL_ACTION selectionActivate
Activation of the selection tool.
static TOOL_ACTION cursorDownFast
static TOOL_ACTION selectionMenu
Run a selection menu to select from a list of items.
static TOOL_ACTION reselectItem
static TOOL_ACTION selectRows
static TOOL_ACTION cursorUpFast
static TOOL_ACTION panLeft
static TOOL_ACTION updateMenu
static TOOL_ACTION doDelete
static TOOL_ACTION selectionTool
static TOOL_ACTION cursorClick
static TOOL_ACTION zoomFitScreen
static TOOL_ACTION increment
static TOOL_ACTION selectionClear
Clear the current selection.
static TOOL_ACTION zoomFitObjects
static TOOL_ACTION zoomInCenter
static TOOL_ACTION panRight
static TOOL_ACTION selectTable
static TOOL_ACTION cursorUp
Cursor control with keyboard.
static TOOL_ACTION groupLeave
static TOOL_ACTION finishInteractive
static TOOL_ACTION cursorRight
static TOOL_ACTION selectAll
static TOOL_ACTION unselectItems
static TOOL_ACTION selectItems
Select a list of items (specified as the event parameter)
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
BASE_SET & reset(size_t pos)
BASE_SET & set(size_t pos)
void Push(const wxString &aMessage=wxEmptyString, int aCommitFlags=0) override
Execute the changes.
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
static bool ClassOf(const EDA_ITEM *aItem)
NETINFO_ITEM * GetNet() const
Return NETINFO_ITEM object for a given item.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual bool IsConnected() const
Returns information if the object is derived from BOARD_CONNECTED_ITEM.
bool IsLocked() const override
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
virtual VECTOR2I GetCenter() const
This defaults to the center of the bounding box if not overridden.
virtual double GetCoverageArea(int aTextMargin) const
Return the board area this item covers, used to rank candidates under the cursor so a click on a smal...
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.
BOARD_ITEM_CONTAINER * GetParent() const
virtual bool IsOnCopperLayer() const
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT, DRC_CONSTRAINT_T aUsage=NULL_CONSTRAINT) const
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
Information pertinent to a Pcbnew printed circuit board.
INSPECT_RESULT Visit(INSPECTOR inspector, void *testData, const std::vector< KICAD_T > &scanTypes) override
May be re-implemented for each derived class in order to handle all the types given by its member dat...
bool IsFootprintLayerVisible(PCB_LAYER_ID aLayer) const
Expect either of the two layers on which a footprint can reside, and returns whether that layer is vi...
bool IsElementVisible(GAL_LAYER_ID aLayer) const
Test whether a given element category is visible.
const LSET & GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
FOOTPRINT * GetFirstFootprint() const
Get the first footprint on the board or nullptr.
bool IsLayerVisible(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
std::shared_ptr< CONNECTIVITY_DATA > GetConnectivity() const
Return a list of missing connections between components/tracks.
constexpr void SetMaximum()
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
constexpr BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
constexpr size_type GetWidth() const
constexpr Vec Centre() const
constexpr size_type GetHeight() const
constexpr bool Contains(const Vec &aPoint) const
constexpr const Vec & GetOrigin() const
constexpr const SizeVec & GetSize() const
CN_ANCHOR represents a physical location that can be connected: a pad or a track/arc/via endpoint.
BOARD_CONNECTED_ITEM * Parent() const
CN_EDGE represents a point-to-point connection, whether realized or unrealized (ie: tracks etc.
CN_ITEM represents a BOARD_CONNECTED_ITEM in the connectivity system (ie: a pad, track/arc/via,...
virtual double OnePixelInIU() const =0
virtual int Accuracy() const =0
void Transfer(int aIndex)
Move the item at aIndex (first position is 0) to the backup list.
void Empty()
Clear the list.
int GetCount() const
Return the number of objects in the list.
bool HasItem(const EDA_ITEM *aItem) const
Tests if aItem has already been collected.
void Remove(int aIndex)
Remove the item at aIndex (first position is 0).
void Append(EDA_ITEM *item)
Add an item to the end of the list.
COMMIT & Remove(EDA_ITEM *aItem, BASE_SCREEN *aScreen=nullptr)
Remove a new item from the model.
A set of EDA_ITEMs (i.e., without duplicates).
std::unordered_set< EDA_ITEM * > & GetItems()
bool HasDesignBlockLink() const
virtual EDA_ITEM * AsEdaItem()=0
A base class for most all the KiCad significant classes used in schematics and boards.
virtual VECTOR2I GetPosition() const
virtual const BOX2I GetBoundingBox() const
Return the orthogonal bounding box of this object for display purposes.
void SetFlags(EDA_ITEM_FLAGS aMask)
virtual EDA_GROUP * GetParentGroup() const
KICAD_T Type() const
Returns the type of object.
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
virtual bool IsType(const std::vector< KICAD_T > &aScanTypes) const
Check whether the item is one of the listed types.
virtual bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const
Test if aPosition is inside or on the boundary of this item.
EDA_ITEM * GetParent() const
bool HasFlag(EDA_ITEM_FLAGS aFlag) const
EDA_ITEM_FLAGS GetFlags() const
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
virtual std::vector< SHAPE * > MakeEffectiveShapesForHitTesting() const
virtual bool IsVisible() const
std::shared_ptr< SHAPE_COMPOUND > GetEffectiveTextShape(bool aTriangulate=true, const BOX2I &aBBox=BOX2I(), const EDA_ANGLE &aAngle=ANGLE_0) const
Build a list of segments (SHAPE_SEGMENT) to describe a text shape.
static const TOOL_EVENT DisambiguatePoint
Used to inform tool that it should display the disambiguation menu.
static const TOOL_EVENT ClearedEvent
static const TOOL_EVENT InhibitSelectionEditing
Used to inform tools that the selection should temporarily be non-editable.
static const TOOL_EVENT SelectedEvent
static const TOOL_EVENT SelectedItemsModified
Selected item had a property changed (except movement)
static const TOOL_EVENT UninhibitSelectionEditing
static const TOOL_EVENT PointSelectedEvent
static const TOOL_EVENT SelectedItemsMoved
Selected items were moved, this can be very high frequency on the canvas, use with care.
static const TOOL_EVENT UnselectedEvent
A general implementation of a COLLECTORS_GUIDE.
void SetIgnoreBlindBuriedVias(bool ignore)
void SetIgnoreTracks(bool ignore)
void SetIgnoreFootprintsOnFront(bool ignore)
void SetIgnoreFPTextOnFront(bool ignore)
void SetIgnoreMicroVias(bool ignore)
void SetIgnoreZoneFills(bool ignore)
void SetIgnorePadsOnBack(bool ignore)
void SetIgnoreFPTextOnBack(bool ignore)
void SetLayerVisibleBits(const LSET &aLayerBits)
void SetIgnoreThroughVias(bool ignore)
void SetIgnoreThroughHolePads(bool ignore)
void SetIgnoreFPReferences(bool ignore)
void SetIgnoreFPValues(bool ignore)
void SetIgnorePadsOnFront(bool ignore)
void SetIgnoreFootprintsOnBack(bool ignore)
Used when the right click button is pressed, or when the select tool is in effect.
void SetGuide(const COLLECTORS_GUIDE *aGuide)
Record which COLLECTORS_GUIDE to use.
const COLLECTORS_GUIDE * GetGuide() const
static const std::vector< KICAD_T > AllBoardItems
A scan list for all editable board items.
void Collect(BOARD_ITEM *aItem, const std::vector< KICAD_T > &aScanList, const VECTOR2I &aRefPos, const COLLECTORS_GUIDE &aGuide)
Scan a BOARD_ITEM using this class's Inspector method, which does the collection.
static const std::vector< KICAD_T > FootprintItems
A scan list for primary footprint items.
A color representation with 4 components: red, green, blue, alpha.
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
Contains methods for drawing PCB-specific items.
virtual PCB_RENDER_SETTINGS * GetSettings() override
Return a pointer to current settings that are going to be used when drawing items.
void SetGroupEditModeActive(bool aActive)
virtual void Update(const VIEW_ITEM *aItem, int aUpdateFlags) const override
For dynamic VIEWs, inform the associated VIEW that the graphical representation of this item has chan...
virtual void Add(VIEW_ITEM *aItem, int aDrawPriority=-1) override
Add a VIEW_ITEM to the view.
virtual void Remove(VIEW_ITEM *aItem) override
Remove a VIEW_ITEM from the view.
Represent a selection area (currently a rectangle) in a VIEW, drawn corner-to-corner between two poin...
VECTOR2I GetOrigin() const
void SetMode(SELECTION_MODE aMode)
void SetSubtractive(bool aSubtractive)
SELECTION_MODE GetMode() const
void SetAdditive(bool aAdditive)
void SetPoly(SHAPE_LINE_CHAIN &aPoly)
void SetOrigin(const VECTOR2I &aOrigin)
Set the origin of the rectangle (the fixed corner)
const BOX2I ViewBBox() const override
Return the bounding box of the item covering all its layers.
SHAPE_LINE_CHAIN & GetPoly()
void SetExclusiveOr(bool aExclusiveOr)
void SetEnd(const VECTOR2I &aEnd)
Set the current end of the rectangle (the corner that moves with the cursor.
Container for all the knowledge about how graphical objects are drawn on any output surface/device.
const std::set< int > & GetHighlightNetCodes() const
Return the netcode of currently highlighted net.
const std::set< int > GetHighContrastLayers() const
Returns the set of currently high-contrast layers.
virtual COLOR4D GetColor(const VIEW_ITEM *aItem, int aLayer) const =0
Returns the color that should be used to draw the specific VIEW_ITEM on the specific layer using curr...
bool GetHighContrast() const
void SetHighlight(bool aEnabled, int aNetcode=-1, bool aMulti=false)
Turns on/off highlighting.
virtual void SetCursorPosition(const VECTOR2D &aPosition, bool aWarpView=true, bool aTriggeredByArrows=false, long aArrowCommand=0)=0
Move cursor to the requested position expressed in world coordinates.
virtual void SetAutoPan(bool aEnabled)
Turn on/off auto panning (this feature is used when there is a tool active (eg.
An abstract base class for deriving all objects that can be added to a VIEW.
bool IsBOARD_ITEM() const
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
BOX2D GetViewport() const
Return the current viewport visible area rectangle.
virtual void SetScale(double aScale, VECTOR2D aAnchor={ 0, 0 })
Set the scaling factor, zooming around a given anchor point.
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...
void UpdateAllItems(int aUpdateFlags)
Update all items in the view according to the given flags.
void Hide(VIEW_ITEM *aItem, bool aHide=true, bool aHideOverlay=false)
Temporarily hide the item in the view (e.g.
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_ITEM objects.
void MarkTargetDirty(int aTarget)
Set or clear target 'dirty' flag.
void SetVisible(VIEW_ITEM *aItem, bool aIsVisible=true)
Set the item visibility.
wxString AsString() const
LSEQ is a sequence (and therefore also a set) of PCB_LAYER_IDs.
LSET is a set of PCB_LAYER_IDs.
static const LSET & FrontMask()
Return a mask holding all technical layers and the external CU layer on front side.
static const LSET & AllCuMask()
return AllCuMask( MAX_CU_LAYERS );
static const LSET & BackMask()
Return a mask holding all technical layers and the external CU layer on back side.
LSEQ CuStack() const
Return a sequence of copper layers in starting from the front/top and extending to the back/bottom.
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
LSEQ SeqStackupTop2Bottom(PCB_LAYER_ID aSelectedLayer=UNDEFINED_LAYER) const
Generate a sequence of layers that represent a top to bottom stack of this set of layers.
static const LSET & AllLayersMask()
static const LSET & PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
bool Contains(PCB_LAYER_ID aLayer) const
See if the layer set contains a PCB layer.
const VECTOR2I & GetPos() const
void ShapeToPolygon(SHAPE_LINE_CHAIN &aPolygon, int aScale=-1) const
Return the shape polygon in internal units in a SHAPE_LINE_CHAIN the coordinates are relatives to the...
Handle the data for a net.
const wxString & GetNetChain() const
PAD * GetTerminalPad(int aIndex) const
LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
PAD_ATTRIB GetAttribute() const
static TOOL_ACTION drag45Degree
static TOOL_ACTION selectNetChain
Select all connections belonging to every net in the current item's net chain.
static TOOL_ACTION unrouteSelected
Removes all tracks from the selected items to the first pad.
static TOOL_ACTION saveToLinkedDesignBlock
static TOOL_ACTION grabUnconnected
Select and move nearest unconnected footprint from ratsnest of selection.
static TOOL_ACTION filterSelection
Filter the items in the current selection (invokes dialog)
static TOOL_ACTION setTerminalPad
static TOOL_ACTION highlightNet
static TOOL_ACTION hideLocalRatsnest
static TOOL_ACTION properties
Activation of the edit tool.
static TOOL_ACTION highlightNetChain
static TOOL_ACTION selectOnSheetFromEeschema
Select all components on sheet from Eeschema crossprobing.
static TOOL_ACTION selectConnection
Select tracks between junctions or expands an existing selection to pads or the entire connection.
static TOOL_ACTION applyDesignBlockLayout
static TOOL_ACTION dragFreeAngle
static TOOL_ACTION clearHighlight
static TOOL_ACTION convertImageToOutlines
static TOOL_ACTION selectUnconnected
Select unconnected footprints from ratsnest of selection.
static TOOL_ACTION unrouteSegment
Removes track segment from the selected item to the next segment.
static TOOL_ACTION moveIndividually
move items one-by-one
static TOOL_ACTION syncSelection
Sets selection to specified items, zooms to fit, if enabled.
static TOOL_ACTION selectSameSheet
Select all components on the same sheet as the selected footprint.
static TOOL_ACTION selectNet
Select all connections belonging to a single net.
static TOOL_ACTION move
move or drag an item
static TOOL_ACTION syncSelectionWithNets
Sets selection to specified items with connected nets, zooms to fit, if enabled.
static TOOL_ACTION deselectNet
Remove all connections belonging to a single net from the active selection.
static TOOL_ACTION placeLinkedDesignBlock
static TOOL_ACTION selectOnSchematic
Select symbols/pins on schematic corresponding to selected footprints/pads.
Common, abstract interface for edit frames.
Base PCB main window class for Pcbnew, Gerbview, and CvPcb footprint viewer.
const PCB_DISPLAY_OPTIONS & GetDisplayOptions() const
Display options control the way tracks, vias, outlines and other things are shown (for instance solid...
double m_TrackOpacity
Opacity override for all tracks.
double m_FilledShapeOpacity
Opacity override for graphic shapes.
double m_ZoneOpacity
Opacity override for filled zone areas.
double m_ImageOpacity
Opacity override for user images.
double m_PadOpacity
Opacity override for SMD pads and PTHs.
double m_ViaOpacity
Opacity override for all types of via.
ZONE_DISPLAY_MODE m_ZoneDisplayMode
virtual KIGFX::PCB_VIEW * GetView() const override
Return a pointer to the KIGFX::VIEW instance used in the panel.
The main frame for Pcbnew.
A table whose cell text is derived from the board and rebuilt whenever it goes stale.
virtual ACTION_MENU * GetChildContextMenu(TOOL_INTERACTIVE *aTool) const
Get a context menu when interacting with a generator child.
virtual bool IsSelectableAsConnected() const
Indicates whether the generator can be selected as a connected entity.
virtual bool ChildrenAreIndividuallySelectable() const
A set of BOARD_ITEMs (i.e., without duplicates).
static EDA_GROUP * TopLevelGroup(const BOARD_ITEM &aItem, const EDA_GROUP *aScope, bool isFootprintEditor)
Search for highest level group inside of aScope, containing item.
std::unordered_set< BOARD_ITEM * > GetBoardItems() const
static bool WithinScope(const BOARD_ITEM &aItem, const PCB_GROUP *aScope, bool isFootprintEditor)
Tool that displays edit points allowing to modify items by dragging the points.
bool HasBlockHandle() const
True when the cursor sits on a handle the user can pick.
bool HasPoint()
Indicate the cursor is over an edit point.
bool HasBlockHandles() const
True while handles are shown for the members of a multi-selection or group.
A PCB_POINT is a 0-dimensional point that is used to mark a position on a PCB, or more usually a foot...
VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
std::vector< VECTOR2I > GetConnectionPoints() const
std::vector< PCB_TABLECELL * > GetCells() const
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
const VECTOR2I & GetStart() const
const VECTOR2I & GetEnd() const
VECTOR2I GetPosition() const override
int GetWidth() const override
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
A small class to help profiling.
void Start()
Start or restart the counter.
double msecs(bool aSinceLast=false)
Describe ratsnest for a single net.
const std::vector< CN_EDGE > & GetEdges() const
static SEG::ecoord Square(int a)
static SELECTION_CONDITION HasType(KICAD_T aType)
Create a functor that tests if among the selected items there is at least one of a given type.
static bool NotEmpty(const SELECTION &aSelection)
Test if there are any items selected.
static SELECTION_CONDITION MoreThan(int aNumber)
Create a functor that tests if the number of selected items is greater than the value given as parame...
static SELECTION_CONDITION Count(int aNumber)
Create a functor that tests if the number of selected items is equal to the value given as parameter.
static SELECTION_CONDITION OnlyTypes(std::vector< KICAD_T > aTypes)
Create a functor that tests if the selected items are only of given types.
virtual void Add(EDA_ITEM *aItem)
A null aItem is ignored; the selection never holds null members.
virtual void Remove(EDA_ITEM *aItem)
void ClearReferencePoint()
bool Empty() const
Checks if there is anything selected.
bool Collide(const SEG &aSeg, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
Check if the boundary of shape (this) lies closer to the segment aSeg than aClearance,...
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
void GenerateBBoxCache() const
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
int PointCount() const
Return the number of points (vertices) in this line chain.
double Area(bool aAbsolute=true) const
Return the area of this chain.
virtual size_t GetPointCount() const override
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CLastPoint() const
Return the last point in the line chain.
void Remove(int aStartIndex, int aEndIndex)
Remove the range of points [start_index, end_index] from the line chain.
bool Collide(const SHAPE *aShape, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const override
Check if the boundary of shape (this) lies closer to the shape aShape than aClearance,...
virtual bool Collide(const VECTOR2I &aP, int aClearance=0, int *aActual=nullptr, VECTOR2I *aLocation=nullptr) const
Check if the boundary of shape (this) lies closer to the point aP than aClearance,...
Handle a list of polygons defining a copper zone.
bool GetIsRuleArea() const
Accessors to parameters used in Rule Area zones:
bool HitTestForCorner(const VECTOR2I &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX *aCornerHit=nullptr) const
Test if the given VECTOR2I is near a corner.
bool HitTestForEdge(const VECTOR2I &refPos, int aAccuracy, SHAPE_POLY_SET::VERTEX_INDEX *aCornerHit=nullptr) const
Test if the given VECTOR2I is near a segment defined by 2 corners.
bool IsTeardropArea() const
virtual LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
bool GetDoNotAllowZoneFills() const
A type-safe container of any type.
#define IGNORE_NETS
Return a list of items connected to a source item aItem.
#define DEFAULT_TEXT_SIZE
The default text size in mils. (can be changed in preference menu)
static bool empty(const wxTextEntryBase *aCtrl)
std::function< INSPECT_RESULT(EDA_ITEM *aItem, void *aTestData) > INSPECTOR_FUNC
Used to inspect and possibly collect the (search) results of iterating over a list or tree of KICAD_T...
#define BRIGHTENED
item is drawn with a bright contour
#define IS_NEW
New item, just created.
#define SELECTED
Item was manually selected by the user.
#define ENTERED
indicates a group has been entered
#define SKIP_STRUCT
flag indicating that the structure should be ignored
#define CANDIDATE
flag indicating that the structure is connected
#define IS_MOVING
Item being moved.
a few functions useful in geometry calculations.
double m_PcbSelectionVisibilityRatio
Board object selection visibility limit.
@ LAYER_POINTS
PCB reference/manual snap points visibility.
@ LAYER_FOOTPRINTS_FR
Show footprints on front.
@ LAYER_DRAW_BITMAPS
Draw images.
@ LAYER_FP_REFERENCES
Show footprints references (when texts are visible).
@ LAYER_DRC_EXCLUSION
Layer for DRC markers which have been individually excluded.
@ LAYER_ZONES
Control for copper zone opacity/visibility (color ignored).
@ LAYER_PADS
Meta control for all pads opacity/visibility (color ignored).
@ LAYER_FOOTPRINTS_BK
Show footprints on back.
@ LAYER_FP_VALUES
Show footprints values (when texts are visible).
@ LAYER_SUBGRIDS
Routing/placement subgrids (PCB_GRID_ITEM) visibility and color.
@ LAYER_VIAS
Meta control for all vias opacity/visibility.
PCB_LAYER_ID
A quick note on layer IDs:
PCB_LAYER_ID ToLAYER_ID(int aLayer)
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 ...
bool BoxHitTest(const VECTOR2I &aHitPoint, const BOX2I &aHittee, int aAccuracy)
Perform a point-to-box hit test.
@ COLOR
Color has changed.
@ REPAINT
Item needs to be redrawn.
@ TARGET_OVERLAY
Items that may change while the view stays the same (noncached)
@ NPTH
like PAD_PTH, but not plated mechanical use only, no connection allowed
@ PTH
Plated through hole pad.
Class to handle a set of BOARD_ITEMs.
bool IsGeneratedTableCell(const EDA_ITEM *aItem)
True for a cell whose text is generated from the board, so only its formatting is the user's.
Class that computes missing connections on a PCB.
static float distance(const SFVEC2UI &a, const SFVEC2UI &b)
std::function< bool(const SELECTION &)> SELECTION_CONDITION
Functor type that checks a specific condition for selected items.
Increment event parameters.
Struct that will be set with the result of the user choices in the dialog.
bool includeLockedFootprints
bool includeItemsOnTechLayers
bool includeBoardOutlineLayer
const BOARD_ITEM * m_Item
This file contains data structures that are saved in the project file or project local settings file ...
bool otherItems
Anything not fitting one of the above categories.
bool vias
Vias (all types>
bool gridItems
Grid Items.
bool keepouts
Keepout zones.
bool graphics
Graphic lines, shapes, polygons.
bool footprints
Allow selecting entire footprints.
bool text
Text (free or attached to a footprint)
bool lockedItems
Allow selecting locked items.
bool tracks
Copper tracks.
bool dimensions
Dimension items.
std::vector< DATABASE_CONNECTION::ROW > rows
KIBIS top(path, &reporter)
static std::vector< int > candidates(const SEGMENT_INDEX &aIndex, const SEG &aQuery, int aPadding)
wxLogTrace helper definitions.
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
@ PCB_CONSTRAINT_T
a geometric constraint between board items
@ 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_GENERATOR_T
class PCB_GENERATOR, generator on a layer
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
@ PCB_DRILL_MAP_T
class PCB_DRILL_MAP, drill symbols drawn at the holes
@ 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
@ NOT_USED
the 3d code uses this value
@ PCB_MARKER_T
class PCB_MARKER, a marker used to show something
@ PCB_BARCODE_T
class PCB_BARCODE, a barcode (graphic item)
@ PCB_TARGET_T
class PCB_TARGET, a target (graphic item)
@ PCB_TABLECELL_T
class PCB_TABLECELL, PCB_TEXTBOX for use in tables
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
@ PCB_GRID_ITEM_T
a subgrid placed on a board
@ 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_TABLE_T
class PCB_TABLE, table of PCB_TABLECELLs
@ PCB_NETINFO_T
class NETINFO_ITEM, a description of a net
@ PCB_STACKUP_TABLE_T
class PCB_STACKUP_TABLE, a live stackup table derived from PCB_TABLE
@ 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
@ PCB_DRILL_CHART_T
class PCB_DRILL_CHART, a live drill chart derived from PCB_TABLE
constexpr bool IsGeneratedTableType(const KICAD_T aType)
A PCB_TABLE subclass whose cells are generated from the board rather than typed by the user.
Casted dyn_cast(From aObject)
A lightweight dynamic downcast.
VECTOR2< int32_t > VECTOR2I
VECTOR2< double > VECTOR2D
VECTOR2D ToVECTOR2D(const wxPoint &aPoint)
static PIECE polygon(std::vector< VIA_CROSS_SECTION_GEOMETRY::POINT > aPoints, bool aMixed=false)