58#include <api/board/board_types.pb.h>
62#include <magic_enum.hpp>
147 *
this = *
static_cast<const PAD*
>( aOther );
158 pad.set_locked(
IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
159 : kiapi::common::types::LockedState::LS_UNLOCKED );
160 pad.mutable_net()->mutable_code()->set_value(
GetNetCode() );
165 google::protobuf::Any padStackMsg;
167 padStackMsg.UnpackTo(
pad.mutable_pad_stack() );
172 aContainer.PackFrom(
pad );
178 kiapi::board::types::Pad
pad;
180 if( !aContainer.UnpackTo( &
pad ) )
186 SetLocked(
pad.locked() == kiapi::common::types::LockedState::LS_LOCKED );
190 google::protobuf::Any padStackWrapper;
191 padStackWrapper.PackFrom(
pad.pad_stack() );
196 if(
pad.has_copper_clearance_override() )
261 int thisNetTieGroup = padToNetTieGroupMap[
GetNumber() ];
262 int otherNetTieGroup = padToNetTieGroupMap[ aOther->
GetNumber() ];
264 return thisNetTieGroup >= 0 && thisNetTieGroup == otherNetTieGroup;
273 return m_pinType.Contains( wxT(
"no_connect" ) );
376 else if(
GetShape( layer ) == PAD_SHAPE::OVAL
403 && ( aLayer ==
F_Cu || aLayer ==
B_Cu ) )
414 else if( aOnlyCheckIfPermitted )
424 return board->GetConnectivity()->IsConnectedOnLayer(
this, aLayer, nonZoneTypes );
448 if( aShape == PAD_DRILL_SHAPE::CIRCLE )
478 "Set front radius only meaningful for normal padstacks" );
488 const int minSize = std::min( size.
x, size.
y );
489 const double newRatio = aRadius / double(
minSize );
498 const int minSize = std::min( size.
x, size.
y );
529 std::shared_ptr<SHAPE_COMPOUND> effective_compund = std::make_shared<SHAPE_COMPOUND>();
534 return effective_compund;
538 effective_compund->AddShape( std::make_shared<SHAPE_NULL>() );
539 return effective_compund;
546 std::shared_ptr<SHAPE_COMPOUND> effective_compund = std::make_shared<SHAPE_COMPOUND>();
548 if( flashPTHPads == FLASHING::NEVER_FLASHED )
550 else if( flashPTHPads == FLASHING::ALWAYS_FLASHED )
560 return effective_compund;
564 effective_compund->AddShape( std::make_shared<SHAPE_NULL>() );
565 return effective_compund;
576 wxT(
"Null shape in PAD::GetEffectiveShape!" ) );
627 half_width = half_size.
x;
631 half_width = std::min( half_size.
x, half_size.
y );
632 half_len =
VECTOR2I( half_size.
x - half_width, half_size.
y - half_width );
653 auto add = [
this, aLayer](
SHAPE* aShape )
662 if( effectiveShape == PAD_SHAPE::CUSTOM )
665 switch( effectiveShape )
667 case PAD_SHAPE::CIRCLE:
671 case PAD_SHAPE::OVAL:
672 if( size.
x == size.
y )
679 int half_width = std::min( half_size.
x, half_size.
y );
680 VECTOR2I half_len( half_size.
x - half_width, half_size.
y - half_width );
682 add(
new SHAPE_SEGMENT( shapePos - half_len, shapePos + half_len, half_width * 2 ) );
687 case PAD_SHAPE::RECTANGLE:
688 case PAD_SHAPE::TRAPEZOID:
689 case PAD_SHAPE::ROUNDRECT:
703 if( half_size.
x < min_len && half_size.
y < min_len )
709 else if( effectiveShape == PAD_SHAPE::TRAPEZOID )
716 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
717 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
718 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
719 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
722 corners.
Move( shapePos );
762 case PAD_SHAPE::CHAMFERED_RECT:
777 wxFAIL_MSG( wxT(
"PAD::buildEffectiveShapes: Unsupported pad shape: PAD_SHAPE::" )
778 + wxString( std::string( magic_enum::enum_name( effectiveShape ) ) ) );
782 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
786 if( !primitive->IsProxyItem() )
788 for(
SHAPE* shape : primitive->MakeEffectiveShapes() )
791 shape->Move( shapePos );
818 std::shared_ptr<SHAPE_POLY_SET>& effectivePolygon =
821 effectivePolygon = std::make_shared<SHAPE_POLY_SET>();
830 for(
int cnt = 0; cnt < effectivePolygon->OutlineCount(); ++cnt )
834 for(
int ii = 0; ii < poly.
PointCount(); ++ii )
868 case PAD_ATTRIB::PTH:
873 case PAD_ATTRIB::SMD:
874 case PAD_ATTRIB::CONN:
879 if( copperLayers.count() > 1 )
881 layerMask &=
~LSET::AllCuMask();
883 if( copperLayers.test(
B_Cu ) )
886 layerMask.
set( copperLayers.
Seq().front() );
894 case PAD_ATTRIB::NPTH:
915 if( !wasRoundable && isRoundable )
971 auto mirrorBitFlags = [](
int& aBitfield,
int a,
int b )
973 bool temp = aBitfield & a;
989 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
1034 primitive->SetParent(this);
1035 primitive->Flip( VECTOR2I( 0, 0 ), aFlipDirection );
1047 if( loc_offset.
x == 0 && loc_offset.
y == 0 )
1064 bool hasAnnularRing =
true;
1071 case PAD_SHAPE::CIRCLE:
1075 hasAnnularRing = false;
1080 case PAD_SHAPE::OVAL:
1085 hasAnnularRing = false;
1097 if( !hasAnnularRing )
1108 *aSource =
_(
"pad" );
1120 return parentFootprint->GetClearanceOverrides( aSource );
1122 return std::optional<int>();
1169 if( !margin.has_value() )
1172 margin = parentFootprint->GetLocalSolderMaskMargin();
1175 if( !margin.has_value() )
1178 margin = brd->GetDesignSettings().m_SolderMaskExpansion;
1181 int marginValue = margin.value_or( 0 );
1186 if( marginValue < 0 )
1190 if( marginValue < minsize )
1191 marginValue = minsize;
1216 if( !margin.has_value() )
1219 margin = parentFootprint->GetLocalSolderPasteMargin();
1222 if( !margin.has_value() )
1225 margin = board->GetDesignSettings().m_SolderPasteMargin;
1228 if( !mratio.has_value() )
1231 mratio = parentFootprint->GetLocalSolderPasteMarginRatio();
1234 if( !mratio.has_value() )
1237 mratio = board->GetDesignSettings().m_SolderPasteMarginRatio;
1244 pad_margin.
x = margin.value_or( 0 ) +
KiROUND( padSize.
x * mratio.value_or( 0 ) );
1245 pad_margin.
y = margin.value_or( 0 ) +
KiROUND( padSize.
y * mratio.value_or( 0 ) );
1250 if( pad_margin.
x < -padSize.
x / 2 )
1251 pad_margin.
x = -padSize.
x / 2;
1253 if( pad_margin.
y < -padSize.
y / 2 )
1254 pad_margin.
y = -padSize.
y / 2;
1265 if( connection != ZONE_CONNECTION::INHERITED )
1268 *aSource =
_(
"pad" );
1271 if( connection == ZONE_CONNECTION::INHERITED )
1274 connection = parentFootprint->GetZoneConnectionOverrides( aSource );
1284 *aSource =
_(
"pad" );
1293 *aSource =
_(
"pad" );
1306 if( parentFootprint )
1307 aList.emplace_back(
_(
"Footprint" ), parentFootprint->
GetReference() );
1310 aList.emplace_back(
_(
"Pad" ),
m_number );
1316 aList.emplace_back(
_(
"Pin Type" ),
GetPinType() );
1322 aList.emplace_back(
_(
"Resolved Netclass" ),
1326 aList.emplace_back(
_(
"Status" ),
_(
"Locked" ) );
1338 double area = poly->Area();
1352 case PAD_PROP::NONE:
break;
1353 case PAD_PROP::BGA: props +=
_(
"BGA" );
break;
1354 case PAD_PROP::FIDUCIAL_GLBL: props +=
_(
"Fiducial global" );
break;
1355 case PAD_PROP::FIDUCIAL_LOCAL: props +=
_(
"Fiducial local" );
break;
1356 case PAD_PROP::TESTPOINT: props +=
_(
"Test point" );
break;
1357 case PAD_PROP::HEATSINK: props +=
_(
"Heat sink" );
break;
1358 case PAD_PROP::CASTELLATED: props +=
_(
"Castellated" );
break;
1359 case PAD_PROP::MECHANICAL: props +=
_(
"Mechanical" );
break;
1368 if( ( padShape == PAD_SHAPE::CIRCLE || padShape == PAD_SHAPE::OVAL )
1369 && padSize.
x == padSize.
y )
1383 if( !fp_orient.
IsZero() )
1388 aList.emplace_back(
_(
"Rotation" ), msg );
1392 aList.emplace_back(
_(
"Length in Package" ),
1398 if( drill.
x > 0 || drill.
y > 0 )
1402 aList.emplace_back(
_(
"Hole" ),
1403 wxString::Format( wxT(
"%s" ),
1408 aList.emplace_back(
_(
"Hole X / Y" ),
1409 wxString::Format( wxT(
"%s / %s" ),
1418 if( !source.IsEmpty() )
1420 aList.emplace_back( wxString::Format(
_(
"Min Clearance: %s" ),
1422 wxString::Format(
_(
"(from %s)" ),
1440 bool contains =
false;
1458 BOX2I arect = aRect;
1483 const std::shared_ptr<SHAPE_POLY_SET>& poly =
1486 int count = poly->TotalVertices();
1488 for(
int ii = 0; ii < count; ii++ )
1490 VECTOR2I vertex = poly->CVertex( ii );
1491 VECTOR2I vertexNext = poly->CVertex( ( ii + 1 ) % count );
1518 if( ( diff =
static_cast<int>( aPadRef->
m_attribute ) -
1542 case PAD_SHAPE::CIRCLE:
return _(
"Circle" );
1543 case PAD_SHAPE::OVAL:
return _(
"Oval" );
1544 case PAD_SHAPE::RECTANGLE:
return _(
"Rect" );
1545 case PAD_SHAPE::TRAPEZOID:
return _(
"Trap" );
1546 case PAD_SHAPE::ROUNDRECT:
return _(
"Roundrect" );
1547 case PAD_SHAPE::CHAMFERED_RECT:
return _(
"Chamferedrect" );
1548 case PAD_SHAPE::CUSTOM:
return _(
"CustomShape" );
1549 default:
return wxT(
"???" );
1558 case PAD_ATTRIB::PTH:
return _(
"PTH" );
1559 case PAD_ATTRIB::SMD:
return _(
"SMD" );
1560 case PAD_ATTRIB::CONN:
return _(
"Conn" );
1561 case PAD_ATTRIB::NPTH:
return _(
"NPTH" );
1562 default:
return wxT(
"???" );
1579 return wxString::Format(
_(
"NPTH pad of %s" ),
1584 return _(
"NPTH pad" );
1593 return wxString::Format(
_(
"Pad %s of %s on %s" ),
1600 return wxString::Format(
_(
"Pad on %s" ),
1608 return wxString::Format(
_(
"PTH pad %s of %s" ),
1614 return _(
"PTH pad" );
1624 return wxString::Format(
_(
"Pad %s %s of %s on %s" ),
1632 return wxString::Format(
_(
"Pad %s on %s" ),
1641 return wxString::Format(
_(
"PTH pad %s %s of %s" ),
1648 return wxString::Format(
_(
"PTH pad %s" ),
1658 return BITMAPS::pad;
1664 PAD* cloned =
new PAD( *
this );
1672 primitive->SetParent( cloned );
1682 std::vector<int> layers;
1683 layers.reserve( 64 );
1699 cuLayers &= board->GetEnabledLayers();
1701 if( cuLayers.count() > 1 )
1745 layers.push_back( each_layer );
1813 int64_t minSide = std::min( padSize.
x, padSize.
y );
1825 int solderMaskMargin = 0;
1831 solderMaskMargin = std::max( solderMaskMargin,
1834 solderPasteMargin.
x = std::max( solderPasteMargin.
x, layerMargin.
x );
1835 solderPasteMargin.
y = std::max( solderPasteMargin.
y, layerMargin.
y );
1844 if( cfg && cfg->m_Display.m_PadClearance &&
GetBoard() )
1849 int xMargin = std::max( solderMaskMargin, solderPasteMargin.
x ) +
clearance;
1850 int yMargin = std::max( solderMaskMargin, solderPasteMargin.
y ) +
clearance;
1892 if( aMasterPad.
GetShape( aLayer ) == PAD_SHAPE::CIRCLE )
1899 case PAD_ATTRIB::SMD:
1900 case PAD_ATTRIB::CONN:
1932 std::swap( *
this, *
static_cast<PAD*
>( aImage ) );
1941 if( !drillsize.
x || !drillsize.
y )
1947 slot->GetWidth() + aClearance * 2, aError, aErrorLoc );
1954 int aMaxError,
ERROR_LOC aErrorLoc,
bool ignoreLineWidth )
const
1956 wxASSERT_MSG( !ignoreLineWidth, wxT(
"IgnoreLineWidth has no meaning for pads." ) );
1958 wxT(
"UNDEFINED_LAYER is no longer allowed for PAD::TransformShapeToPolygon" ) );
1963 const int pad_min_seg_per_circle_count = 16;
1972 case PAD_SHAPE::CIRCLE:
1973 case PAD_SHAPE::OVAL:
1975 if( dx == dy || ( shape == PAD_SHAPE::CIRCLE ) )
1978 pad_min_seg_per_circle_count );
1982 int half_width = std::min( dx, dy );
1988 ( half_width + aClearance ) * 2, aMaxError, aErrorLoc,
1989 pad_min_seg_per_circle_count );
1994 case PAD_SHAPE::TRAPEZOID:
1995 case PAD_SHAPE::RECTANGLE:
1998 int ddx = shape == PAD_SHAPE::TRAPEZOID ? trapDelta.
x / 2 : 0;
1999 int ddy = shape == PAD_SHAPE::TRAPEZOID ? trapDelta.
y / 2 : 0;
2004 aBuffer.
Append( outline );
2008 case PAD_SHAPE::CHAMFERED_RECT:
2009 case PAD_SHAPE::ROUNDRECT:
2011 bool doChamfer = shape == PAD_SHAPE::CHAMFERED_RECT;
2018 aClearance, aMaxError, aErrorLoc );
2019 aBuffer.
Append( outline );
2023 case PAD_SHAPE::CUSTOM:
2033 aClearance += aMaxError;
2035 outline.
Inflate( aClearance, CORNER_STRATEGY::ROUND_ALL_CORNERS, aMaxError );
2038 else if( aClearance < 0 )
2044 outline.
Inflate( aClearance, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, aMaxError );
2048 aBuffer.
Append( outline );
2053 wxFAIL_MSG( wxT(
"PAD::TransformShapeToPolygon no implementation for " )
2054 + wxString( std::string( magic_enum::enum_name( shape ) ) ) );
2098 [&](
PCB_SHAPE* aShape ) -> std::vector<PCB_SHAPE*>
2100 std::vector<PCB_SHAPE*> matching;
2110 && aShape->Compare( other ) == 0 )
2112 matching.push_back( other );
2120 std::vector<PCB_SHAPE*> mergedShapes;
2133 if( !aIsDryRun &&
findNext( layer ) && origShape != PAD_SHAPE::CUSTOM )
2135 if( origShape == PAD_SHAPE::CIRCLE || origShape == PAD_SHAPE::RECTANGLE )
2139 SetShape( layer, PAD_SHAPE::CUSTOM );
2147 int minExtent = std::min(
GetSize( layer ).x,
GetSize( layer ).y );
2150 SetShape( layer, PAD_SHAPE::CUSTOM );
2166 mergedShapes.push_back( fpShape );
2174 group->RemoveItem( fpShape );
2192 for(
PCB_SHAPE* other : findMatching( fpShape ) )
2195 mergedShapes.push_back( other );
2205 return mergedShapes;
2210 const std::function<
void(
int aErrorCode,
2211 const wxString& aMsg )>& aErrorHandler )
const
2216 doCheckPad( aLayer, aUnitsProvider, aForPadProperties, aErrorHandler );
2222 if( !padlayers_mask[
F_Cu] && !padlayers_mask[
B_Cu] )
2224 if( ( drill_size.
x || drill_size.
y ) &&
GetAttribute() != PAD_ATTRIB::NPTH )
2226 aErrorHandler(
DRCE_PADSTACK,
_(
"(plated through holes normally have a copper pad on "
2227 "at least one outer layer)" ) );
2234 aErrorHandler(
DRCE_PADSTACK,
_(
"('fiducial' property makes no sense on NPTH pads)" ) );
2238 aErrorHandler(
DRCE_PADSTACK,
_(
"('testpoint' property makes no sense on NPTH pads)" ) );
2241 aErrorHandler(
DRCE_PADSTACK,
_(
"('heatsink' property makes no sense of NPTH pads)" ) );
2244 aErrorHandler(
DRCE_PADSTACK,
_(
"('castellated' property is for PTH pads)" ) );
2247 aErrorHandler(
DRCE_PADSTACK,
_(
"('BGA' property is for SMD pads)" ) );
2250 aErrorHandler(
DRCE_PADSTACK,
_(
"('mechanical' property is for PTH pads)" ) );
2254 case PAD_ATTRIB::NPTH:
2255 case PAD_ATTRIB::PTH:
2256 if( drill_size.
x <= 0
2257 || ( drill_size.
y <= 0 &&
GetDrillShape() == PAD_DRILL_SHAPE::OBLONG ) )
2263 case PAD_ATTRIB::CONN:
2266 aErrorHandler(
DRCE_PADSTACK,
_(
"(connector pads normally have no solder paste; use a "
2267 "SMD pad instead)" ) );
2271 case PAD_ATTRIB::SMD:
2273 if( drill_size.
x > 0 || drill_size.
y > 0 )
2280 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper on both sides of the board)" ) );
2286 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and mask layers on different "
2287 "sides of the board)" ) );
2291 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and paste layers on different "
2292 "sides of the board)" ) );
2299 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and mask layers on different "
2300 "sides of the board)" ) );
2304 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and paste layers on different "
2305 "sides of the board)" ) );
2308 else if( innerlayers_mask.count() != 0 )
2310 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has no outer layers)" ) );
2320 const std::function<
void(
int aErrorCode,
2321 const wxString& aMsg )>& aErrorHandler )
const
2327 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
2329 else if( pad_size.
x <= 0 || ( pad_size.
y <= 0 &&
GetShape( aLayer ) != PAD_SHAPE::CIRCLE ) )
2337 const int min_drill_size = 4;
2341 msg.Printf(
_(
"(PTH pad hole size must be larger than %s)" ),
2365 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad hole leaves no copper)" ) );
2367 else if( aForPadProperties )
2375 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad hole not fully inside copper)" ) );
2382 aErrorHandler(
DRCE_PADSTACK,
_(
"(pad hole not inside pad shape)" ) );
2387 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative local clearance values have no effect)" ) );
2394 if( solderMaskMargin.has_value() && solderMaskMargin.value() < 0 )
2396 int absMargin = abs( solderMaskMargin.value() );
2398 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
2400 for(
const std::shared_ptr<PCB_SHAPE>& shape :
GetPrimitives( aLayer ) )
2402 BOX2I shapeBBox = shape->GetBoundingBox();
2406 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder mask clearance is larger "
2407 "than some shape primitives; results may be "
2414 else if( absMargin > pad_size.
x || absMargin > pad_size.
y )
2416 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder mask clearance is larger than pad; "
2417 "no solder mask will be generated)" ) );
2430 paste_size.x = pad_size.
x + paste_margin +
KiROUND( pad_size.
x * paste_ratio );
2431 paste_size.y = pad_size.
y + paste_margin +
KiROUND( pad_size.
y * paste_ratio );
2433 if( paste_size.x <= 0 || paste_size.y <= 0 )
2435 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder paste margin is larger than pad; "
2436 "no solder paste mask will be generated)" ) );
2439 if(
GetShape( aLayer ) == PAD_SHAPE::ROUNDRECT )
2444 aErrorHandler(
DRCE_PADSTACK,
_(
"(corner size will make pad circular)" ) );
2446 else if(
GetShape( aLayer ) == PAD_SHAPE::CHAMFERED_RECT )
2453 else if(
GetShape( aLayer ) == PAD_SHAPE::TRAPEZOID )
2464 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
2483 const PAD& other =
static_cast<const PAD&
>( aBoardItem );
2485 return *
this == other;
2512 const PAD& other =
static_cast<const PAD&
>( aOther );
2514 double similarity = 1.0;
2533 poly_no_hole.
Append( aPoly );
2540 for(
int ii = 0; ii < poly_no_hole.
OutlineCount(); ++ii )
2575 if( aPrimitivesList.size() )
2585 for(
const std::shared_ptr<PCB_SHAPE>& prim : aPrimitivesList )
2634 case PAD_SHAPE::RECTANGLE:
2636 SHAPE_RECT rect( -padSize.
x / 2, -padSize.
y / 2, padSize.
x, padSize.
y );
2642 case PAD_SHAPE::CIRCLE:
2652 if( !primitive->IsProxyItem() )
2653 primitive->TransformShapeToPolygon( polyset,
UNDEFINED_LAYER, 0, maxError, aErrorLoc );
2672 .Map( PAD_ATTRIB::PTH,
_HKI(
"Through-hole" ) )
2673 .Map( PAD_ATTRIB::SMD,
_HKI(
"SMD" ) )
2674 .Map( PAD_ATTRIB::CONN,
_HKI(
"Edge connector" ) )
2675 .Map( PAD_ATTRIB::NPTH,
_HKI(
"NPTH, mechanical" ) );
2678 .Map( PAD_SHAPE::CIRCLE,
_HKI(
"Circle" ) )
2679 .Map( PAD_SHAPE::RECTANGLE,
_HKI(
"Rectangle" ) )
2680 .Map( PAD_SHAPE::OVAL,
_HKI(
"Oval" ) )
2681 .Map( PAD_SHAPE::TRAPEZOID,
_HKI(
"Trapezoid" ) )
2682 .Map( PAD_SHAPE::ROUNDRECT,
_HKI(
"Rounded rectangle" ) )
2683 .Map( PAD_SHAPE::CHAMFERED_RECT,
_HKI(
"Chamfered rectangle" ) )
2684 .Map( PAD_SHAPE::CUSTOM,
_HKI(
"Custom" ) );
2687 .Map( PAD_PROP::NONE,
_HKI(
"None" ) )
2688 .Map( PAD_PROP::BGA,
_HKI(
"BGA pad" ) )
2689 .Map( PAD_PROP::FIDUCIAL_GLBL,
_HKI(
"Fiducial, global to board" ) )
2690 .Map( PAD_PROP::FIDUCIAL_LOCAL,
_HKI(
"Fiducial, local to footprint" ) )
2691 .Map( PAD_PROP::TESTPOINT,
_HKI(
"Test point pad" ) )
2692 .Map( PAD_PROP::HEATSINK,
_HKI(
"Heatsink pad" ) )
2693 .Map( PAD_PROP::CASTELLATED,
_HKI(
"Castellated pad" ) )
2694 .Map( PAD_PROP::MECHANICAL,
_HKI(
"Mechanical pad" ) );
2697 .Map( PAD_DRILL_SHAPE::CIRCLE,
_HKI(
"Round" ) )
2698 .Map( PAD_DRILL_SHAPE::OBLONG,
_HKI(
"Oblong" ) );
2702 if( zcMap.
Choices().GetCount() == 0 )
2704 zcMap.
Undefined( ZONE_CONNECTION::INHERITED );
2705 zcMap.
Map( ZONE_CONNECTION::INHERITED,
_HKI(
"Inherited" ) )
2706 .
Map( ZONE_CONNECTION::NONE,
_HKI(
"None" ) )
2707 .
Map( ZONE_CONNECTION::THERMAL,
_HKI(
"Thermal reliefs" ) )
2708 .
Map( ZONE_CONNECTION::FULL,
_HKI(
"Solid" ) )
2709 .
Map( ZONE_CONNECTION::THT_THERMAL,
_HKI(
"Thermal reliefs for PTH" ) );
2716 _HKI(
"Front, back and connected layers" ) );
2727 PROPERTY_DISPLAY::PT_DEGREE ) );
2732 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2733 return pad->GetAttribute() != PAD_ATTRIB::NPTH;
2738 auto padCanHaveHole =
2741 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2743 return pad->GetAttribute() == PAD_ATTRIB::PTH
2744 ||
pad->GetAttribute() == PAD_ATTRIB::NPTH;
2750 auto hasNormalPadstack =
2753 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2760 _HKI(
"Net" ), isCopperPad );
2762 _HKI(
"Net Class" ), isCopperPad );
2764 const wxString groupPad =
_HKI(
"Pad Properties" );
2777 padNumber->SetAvailableFunc( isCopperPad );
2789 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2793 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2797 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2810 const auto hasRoundRadius = [=](
INSPECTABLE* aItem ) ->
bool
2812 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2826 roundRadiusRatio->SetAvailableFunc( hasRoundRadius );
2827 propMgr.
AddProperty( roundRadiusRatio, groupPad );
2831 PROPERTY_DISPLAY::PT_SIZE );
2832 roundRadiusSize->SetAvailableFunc( hasRoundRadius );
2841 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2847 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2854 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2855 return pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE;
2864 _HKI(
"Copper Layers" ),
2870 PROPERTY_DISPLAY::PT_SIZE );
2871 padToDie->SetAvailableFunc( isCopperPad );
2874 const wxString groupOverrides =
_HKI(
"Overrides" );
2877 _HKI(
"Clearance Override" ),
2879 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2882 _HKI(
"Soldermask Margin Override" ),
2884 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2887 _HKI(
"Solderpaste Margin Override" ),
2889 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2892 _HKI(
"Solderpaste Margin Ratio Override" ),
2894 PROPERTY_DISPLAY::PT_RATIO ),
2898 _HKI(
"Zone Connection Style" ),
2904 _HKI(
"Thermal Relief Spoke Width" ),
2906 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides )
2907 .
SetValidator( PROPERTY_VALIDATORS::RangeIntValidator<minZoneWidth, INT_MAX> );
2910 _HKI(
"Thermal Relief Spoke Angle" ),
2912 PROPERTY_DISPLAY::PT_DEGREE ), groupOverrides );
2915 _HKI(
"Thermal Relief Gap" ),
2917 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides )
ERROR_LOC
When approximating an arc or circle, should the error be placed on the outside or inside of the curve...
constexpr int ARC_HIGH_DEF
constexpr EDA_IU_SCALE pcbIUScale
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
BITMAPS
A list of all bitmap identifiers.
ZONE_LAYER_OVERRIDE
Conditionally flashed vias and pads that interact with zones of different priority can be very squirr...
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
BASE_SET & set(size_t pos)
A base class derived from BOARD_ITEM for items that can be connected and have a net,...
wxString GetNetnameMsg() const
virtual NETCLASS * GetEffectiveNetClass() const
Return the NETCLASS for this item.
bool SetNetCode(int aNetCode, bool aNoAssert)
Set net using a net code.
wxString GetNetname() const
TEARDROP_PARAMETERS m_teardropParams
Not all BOARD_CONNECTED_ITEMs support teardrops, but we want those that do to share a single section ...
const wxString & GetShortNetname() const
Container for design settings for a BOARD object.
std::shared_ptr< DRC_ENGINE > m_DRCEngine
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual PCB_LAYER_ID GetLayer() const
Return the primary layer this item is on.
virtual void SetLocked(bool aLocked)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
FOOTPRINT * GetParentFootprint() const
virtual bool IsLocked() const
BOARD_ITEM_CONTAINER * GetParent() const
virtual int BoardCopperLayerCount() const
Return the total number of copper layers for the board that this item resides on.
virtual wxString layerMaskDescribe() const
Return a string (to be shown to the user) describing a layer mask.
Information pertinent to a Pcbnew printed circuit board.
LSET GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
LSET GetVisibleLayers() const
A proxy function that calls the correspondent function in m_BoardSettings.
int GetMaxClearanceValue() const
Returns the maximum clearance value for any object on the board.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
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 BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
constexpr size_type GetHeight() const
constexpr bool Contains(const Vec &aPoint) const
constexpr const Vec & GetOrigin() const
constexpr const SizeVec & GetSize() const
constexpr bool Intersects(const BOX2< Vec > &aRect) const
MINOPTMAX< int > & Value()
The base class for create windows for drawing purpose.
A base class for most all the KiCad significant classes used in schematics and boards.
virtual VECTOR2I GetPosition() const
EDA_ITEM & operator=(const EDA_ITEM &aItem)
Assign the members of aItem to another object.
KICAD_T Type() const
Returns the type of object.
void ClearFlags(EDA_ITEM_FLAGS aMask=EDA_ITEM_ALL_FLAGS)
virtual void SetParent(EDA_ITEM *aParent)
EDA_ITEM * m_parent
Linked list: Link (parent struct).
EDA_ITEM_FLAGS GetFlags() const
void SetPolyShape(const SHAPE_POLY_SET &aShape)
virtual void SetFilled(bool aFlag)
void SetShape(SHAPE_T aShape)
void SetPolyPoints(const std::vector< VECTOR2I > &aPoints)
void SetFillMode(FILL_T aFill)
ENUM_MAP & Map(T aValue, const wxString &aName)
static ENUM_MAP< T > & Instance()
ENUM_MAP & Undefined(T aValue)
Class that other classes need to inherit from, in order to be inspectable.
double GetZoomFactor() const
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.
PCB specific render settings.
PCB_LAYER_ID GetPrimaryHighContrastLayer() const
Return the board layer which is in high-contrast mode.
bool GetHighContrast() const
static double lodScaleForThreshold(const KIGFX::VIEW *aView, int aWhatIu, int aThresholdIu)
Get the scale at which aWhatIu would be drawn at the same size as aThresholdIu on screen.
static constexpr double LOD_HIDE
Return this constant from ViewGetLOD() to hide the item unconditionally.
static constexpr double LOD_SHOW
Return this constant from ViewGetLOD() to show the item unconditionally.
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
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.
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.
wxString AsString() const
std::string AsStdString() const
LSET is a set of PCB_LAYER_IDs.
LSEQ UIOrder() const
Return the copper, technical and user layers in the order shown in layer widget.
static LSET FrontBoardTechMask()
Return a mask holding technical layers used in a board fabrication (no CU layer) on front side.
static LSET InternalCuMask()
Return a complete set of internal copper layers which is all Cu layers except F_Cu and B_Cu.
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
static LSET PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
static LSET BackBoardTechMask()
Return a mask holding technical layers used in a board fabrication (no CU layer) on Back side.
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
std::optional< int > & Clearance(PCB_LAYER_ID aLayer=F_Cu)
void AddPrimitive(PCB_SHAPE *aShape, PCB_LAYER_ID aLayer)
Adds a custom shape primitive to the padstack.
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
double Similarity(const PADSTACK &aOther) const
Return a measure of how likely the other object is to represent the same object.
int RoundRectRadius(PCB_LAYER_ID aLayer) const
std::optional< double > & SolderPasteMarginRatio(PCB_LAYER_ID aLayer=F_Cu)
void ForEachUniqueLayer(const std::function< void(PCB_LAYER_ID)> &aMethod) const
Runs the given callable for each active unique copper layer in this padstack, meaning F_Cu for MODE::...
void SetRoundRectRadiusRatio(double aRatio, PCB_LAYER_ID aLayer)
void ClearPrimitives(PCB_LAYER_ID aLayer)
std::optional< int > & ThermalSpokeWidth(PCB_LAYER_ID aLayer=F_Cu)
std::optional< int > & SolderPasteMargin(PCB_LAYER_ID aLayer=F_Cu)
void SetOrientation(EDA_ANGLE aAngle)
std::optional< int > & SolderMaskMargin(PCB_LAYER_ID aLayer=F_Cu)
void SetChamferRatio(double aRatio, PCB_LAYER_ID aLayer)
const LSET & LayerSet() const
PCB_LAYER_ID EffectiveLayerFor(PCB_LAYER_ID aLayer) const
Determines which geometry layer should be used for the given input layer.
void SetShape(PAD_SHAPE aShape, PCB_LAYER_ID aLayer)
VECTOR2I & TrapezoidDeltaSize(PCB_LAYER_ID aLayer)
VECTOR2I & Offset(PCB_LAYER_ID aLayer)
void FlipLayers(int aCopperLayerCount)
Flips the padstack layers in the case that the pad's parent footprint is flipped to the other side of...
void SetChamferPositions(int aPositions, PCB_LAYER_ID aLayer)
void SetRoundRectRadius(double aRadius, PCB_LAYER_ID aLayer)
UNCONNECTED_LAYER_MODE UnconnectedLayerMode() const
std::optional< int > & ThermalGap(PCB_LAYER_ID aLayer=F_Cu)
PAD_SHAPE Shape(PCB_LAYER_ID aLayer) const
static int Compare(const PADSTACK *aPadstackRef, const PADSTACK *aPadstackCmp)
Compare two padstacks and return 0 if they are equal.
int & ChamferPositions(PCB_LAYER_ID aLayer)
const VECTOR2I & Size(PCB_LAYER_ID aLayer) const
@ NORMAL
Shape is the same on all layers.
UNCONNECTED_LAYER_MODE
! Whether or not to remove the copper shape for unconnected layers
@ REMOVE_EXCEPT_START_AND_END
PCB_LAYER_ID StartLayer() const
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
void SetSize(const VECTOR2I &aSize, PCB_LAYER_ID aLayer)
static constexpr PCB_LAYER_ID ALL_LAYERS
! Temporary layer identifier to identify code that is not padstack-aware
EDA_ANGLE GetOrientation() const
void SetLayerSet(const LSET &aSet)
std::optional< ZONE_CONNECTION > & ZoneConnection(PCB_LAYER_ID aLayer=F_Cu)
std::vector< std::shared_ptr< PCB_SHAPE > > & Primitives(PCB_LAYER_ID aLayer)
void SetAnchorPadShape(PCB_LAYER_ID aLayer, PAD_SHAPE aShape)
Set the shape of the anchor pad for custom shaped pads.
bool IsAperturePad() const
void SetAttribute(PAD_ATTRIB aAttribute)
int GetOwnClearance(PCB_LAYER_ID aLayer, wxString *aSource=nullptr) const override
Return the pad's "own" clearance in internal units.
void CheckPad(UNITS_PROVIDER *aUnitsProvider, bool aForPadProperties, const std::function< void(int aErrorCode, const wxString &aMsg)> &aErrorHandler) const
virtual void swapData(BOARD_ITEM *aImage) override
PAD_PROP GetProperty() const
void Serialize(google::protobuf::Any &aContainer) const override
Serializes this object to the given Any message.
double GetFrontRoundRectRadiusRatio() const
void doCheckPad(PCB_LAYER_ID aLayer, UNITS_PROVIDER *aUnitsProvider, bool aForPadProperties, const std::function< void(int aErrorCode, const wxString &aMsg)> &aErrorHandler) const
std::optional< int > GetClearanceOverrides(wxString *aSource) const override
Return any clearance overrides set in the "classic" (ie: pre-rule) system.
void SetPinType(const wxString &aType)
Set the pad electrical type.
LSET GetLayerSet() const override
Return a std::bitset of all layers on which the item physically resides.
const std::vector< std::shared_ptr< PCB_SHAPE > > & GetPrimitives(PCB_LAYER_ID aLayer) const
Accessor to the basic shape list for custom-shaped pads.
const ZONE_LAYER_OVERRIDE & GetZoneLayerOverride(PCB_LAYER_ID aLayer) const
void MergePrimitivesAsPolygon(PCB_LAYER_ID aLayer, SHAPE_POLY_SET *aMergedPolygon, ERROR_LOC aErrorLoc=ERROR_INSIDE) const
Merge all basic shapes to a SHAPE_POLY_SET.
int GetRoundRectCornerRadius(PCB_LAYER_ID aLayer) const
bool FlashLayer(int aLayer, bool aOnlyCheckIfPermitted=false) const
Check to see whether the pad should be flashed on the specific layer.
void SetLocalThermalGapOverride(const std::optional< int > &aOverride)
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer, FLASHING flashPTHPads=FLASHING::DEFAULT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
void GetMsgPanelInfo(EDA_DRAW_FRAME *aFrame, std::vector< MSG_PANEL_ITEM > &aList) override
Populate aList of MSG_PANEL_ITEM objects with it's internal state for display purposes.
const BOX2I GetBoundingBox() const override
The bounding box is cached, so this will be efficient most of the time.
bool IsOnLayer(PCB_LAYER_ID aLayer) const override
Test to see if this object is on the given layer.
int GetDrillSizeY() const
void AddPrimitivePoly(PCB_LAYER_ID aLayer, const SHAPE_POLY_SET &aPoly, int aThickness, bool aFilled)
Has meaning only for custom shape pads.
std::optional< double > GetLocalSolderPasteMarginRatio() const
void SetFrontShape(PAD_SHAPE aShape)
const wxString & GetPinType() const
void SetZoneLayerOverride(PCB_LAYER_ID aLayer, ZONE_LAYER_OVERRIDE aOverride)
const VECTOR2I & GetDrillSize() const
PAD_ATTRIB GetAttribute() const
static LSET PTHMask()
layer set for a through hole pad
static int Compare(const PAD *aPadRef, const PAD *aPadCmp)
Compare two pads and return 0 if they are equal.
void SetUnconnectedLayerMode(PADSTACK::UNCONNECTED_LAYER_MODE aMode)
const wxString & GetPinFunction() const
std::mutex m_shapesBuildingLock
bool CanHaveNumber() const
Indicates whether or not the pad can have a number.
void SetThermalSpokeAngle(const EDA_ANGLE &aAngle)
The orientation of the thermal spokes.
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
const wxString & GetNumber() const
double ViewGetLOD(int aLayer, const KIGFX::VIEW *aView) const override
Return the level of detail (LOD) of the item.
const VECTOR2I & GetDelta(PCB_LAYER_ID aLayer) const
void SetFrontRoundRectRadiusRatio(double aRadiusScale)
void BuildEffectiveShapes() const
Rebuild the effective shape cache (and bounding box and radius) for the pad and clears the dirty bit.
PAD_SHAPE GetFrontShape() const
void CopyFrom(const BOARD_ITEM *aOther) override
void SetLocalSolderPasteMarginRatio(std::optional< double > aRatio)
PAD & operator=(const PAD &aOther)
void SetLocalThermalSpokeWidthOverride(std::optional< int > aWidth)
Set the width of the thermal spokes connecting the pad to a zone.
void SetShape(PCB_LAYER_ID aLayer, PAD_SHAPE aShape)
Set the new shape of this pad.
std::shared_ptr< SHAPE_SEGMENT > m_effectiveHoleShape
bool IsLocked() const override
VECTOR2I GetPosition() const override
void SetProperty(PAD_PROP aProperty)
void SetThermalSpokeAngleDegrees(double aAngle)
EDA_ANGLE GetThermalSpokeAngle() const
std::map< PCB_LAYER_ID, ZONE_LAYER_OVERRIDE > m_zoneLayerOverrides
void Flip(const VECTOR2I &VECTOR2I, FLIP_DIRECTION aFlipDirection) override
Flip this object, i.e.
std::vector< PCB_SHAPE * > Recombine(bool aIsDryRun, int aMaxError)
Recombines the pad with other graphical shapes in the footprint.
PCB_LAYER_ID GetPrincipalLayer() const
static LSET UnplatedHoleMask()
layer set for a mechanical unplated through hole pad
EDA_ITEM * Clone() const override
Create a duplicate of this item with linked list members set to NULL.
double GetOrientationDegrees() const
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
void FlipPrimitives(FLIP_DIRECTION aFlipDirection)
Flip (mirror) the primitives left to right or top to bottom, around the anchor position in custom pad...
LAYER_SHAPE_MAP m_effectiveShapes
bool IsNoConnectPad() const
int GetDrillSizeX() const
double GetRoundRectRadiusRatio(PCB_LAYER_ID aLayer) const
void DeletePrimitivesList(PCB_LAYER_ID aLayer=UNDEFINED_LAYER)
Clear the basic shapes list.
PAD_SHAPE GetShape(PCB_LAYER_ID aLayer) const
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aMaxError, ERROR_LOC aErrorLoc=ERROR_INSIDE, bool ignoreLineWidth=false) const override
Convert the pad shape to a closed polygon.
void SetNumber(const wxString &aNumber)
Set the pad number (note that it can be alphanumeric, such as the array reference "AA12").
void SetFrontRoundRectRadiusSize(int aRadius)
wxString ShowPadAttr() const
void AddPrimitive(PCB_LAYER_ID aLayer, PCB_SHAPE *aPrimitive)
Add item to the custom shape primitives list.
void SetDrillShape(PAD_DRILL_SHAPE aShape)
int m_effectiveBoundingRadius
void SetLocalSolderMaskMargin(std::optional< int > aMargin)
void SetLocalZoneConnection(ZONE_CONNECTION aType)
void SetChamferRectRatio(PCB_LAYER_ID aLayer, double aChamferScale)
Has meaning only for chamfered rectangular pads.
int GetSolderMaskExpansion(PCB_LAYER_ID aLayer) const
std::optional< int > GetLocalClearance() const override
Return any local clearances set in the "classic" (ie: pre-rule) system.
void ImportSettingsFrom(const PAD &aMasterPad)
Import the pad settings from aMasterPad.
double Similarity(const BOARD_ITEM &aOther) const override
Return a measure of how likely the other object is to represent the same object.
bool IsOnCopperLayer() const override
void SetDrillSizeX(const int aX)
void SetPadstack(const PADSTACK &aPadstack)
void SetPosition(const VECTOR2I &aPos) override
const SHAPE_COMPOUND & buildEffectiveShape(PCB_LAYER_ID aLayer) const
const PADSTACK & Padstack() const
const VECTOR2I & GetOffset(PCB_LAYER_ID aLayer) const
double m_lastGalZoomLevel
void BuildEffectivePolygon(ERROR_LOC aErrorLoc=ERROR_INSIDE) const
static LSET ConnSMDMask()
layer set for a SMD pad on Front layer used for edge board connectors
void SetDrillSize(const VECTOR2I &aSize)
EDA_ANGLE GetOrientation() const
Return the rotation angle of the pad.
void SetSize(PCB_LAYER_ID aLayer, const VECTOR2I &aSize)
PADSTACK::CUSTOM_SHAPE_ZONE_MODE GetCustomShapeInZoneOpt() const
PAD_DRILL_SHAPE GetDrillShape() const
void ReplacePrimitives(PCB_LAYER_ID aLayer, const std::vector< std::shared_ptr< PCB_SHAPE > > &aPrimitivesList)
Clear the current custom shape primitives list and import a new list.
int GetChamferPositions(PCB_LAYER_ID aLayer) const
static LSET ApertureMask()
layer set for an aperture pad
virtual const BOX2I ViewBBox() const override
Return the bounding box of the item covering all its layers.
std::mutex m_polyBuildingLock
void SetRoundRectCornerRadius(PCB_LAYER_ID aLayer, double aRadius)
Has meaning only for rounded rectangle pads.
static LSET SMDMask()
layer set for a SMD pad on Front layer
std::optional< int > GetLocalSolderPasteMargin() const
int GetFrontRoundRectRadiusSize() const
const std::shared_ptr< SHAPE_POLY_SET > & GetEffectivePolygon(PCB_LAYER_ID aLayer, ERROR_LOC aErrorLoc=ERROR_INSIDE) const
std::optional< int > GetLocalSolderMaskMargin() const
void SetLocalSolderPasteMargin(std::optional< int > aMargin)
std::optional< int > GetLocalThermalGapOverride() const
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
wxString GetItemDescription(UNITS_PROVIDER *aUnitsProvider, bool aFull) const override
Return a user-visible description string of this item.
void SetPinFunction(const wxString &aName)
Set the pad function (pin name in schematic)
EDA_ANGLE GetFPRelativeOrientation() const
double GetChamferRectRatio(PCB_LAYER_ID aLayer) const
bool HitTest(const VECTOR2I &aPosition, int aAccuracy=0) const override
Test if aPosition is inside or on the boundary of this item.
void SetFPRelativeOrientation(const EDA_ANGLE &aAngle)
void SetCustomShapeInZoneOpt(PADSTACK::CUSTOM_SHAPE_ZONE_MODE aOption)
Set the option for the custom pad shape to use as clearance area in copper zones.
int GetBoundingRadius() const
Return the radius of a minimum sized circle which fully encloses this pad.
void ClearZoneLayerOverrides()
void SetOrientation(const EDA_ANGLE &aAngle)
Set the rotation angle of the pad.
std::mutex m_zoneLayerOverridesMutex
std::optional< int > GetLocalThermalSpokeWidthOverride() const
PADSTACK::UNCONNECTED_LAYER_MODE GetUnconnectedLayerMode() const
VECTOR2I GetSolderPasteMargin(PCB_LAYER_ID aLayer) const
Usually < 0 (mask shape smaller than pad)because the margin can be dependent on the pad size,...
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
void AppendPrimitives(PCB_LAYER_ID aLayer, const std::vector< std::shared_ptr< PCB_SHAPE > > &aPrimitivesList)
Import a custom shape primitive list (composed of basic shapes) and add items to the current list.
LAYER_POLYGON_MAP m_effectivePolygons
void SetLocalClearance(std::optional< int > aClearance)
int GetSubRatsnest() const
void SetSizeX(const int aX)
ZONE_CONNECTION GetLocalZoneConnection() const
void SetDrillSizeY(const int aY)
double GetThermalSpokeAngleDegrees() const
VECTOR2I ShapePos(PCB_LAYER_ID aLayer) const
std::shared_ptr< SHAPE_SEGMENT > GetEffectiveHoleShape() const override
Return a SHAPE_SEGMENT object representing the pad's hole.
void SetOrientationDegrees(double aOrientation)
ZONE_CONNECTION GetZoneConnectionOverrides(wxString *aSource=nullptr) const
int GetLocalThermalGapOverride(wxString *aSource) const
void SetLayerSet(const LSET &aLayers) override
bool SharesNetTieGroup(const PAD *aOther) const
PAD_SHAPE GetAnchorPadShape(PCB_LAYER_ID aLayer) const
void SetRoundRectRadiusRatio(PCB_LAYER_ID aLayer, double aRadiusScale)
Has meaning only for rounded rectangle pads.
void SetSubRatsnest(int aSubRatsnest)
int GetLocalSpokeWidthOverride(wxString *aSource=nullptr) const
bool TransformHoleToPolygon(SHAPE_POLY_SET &aBuffer, int aClearance, int aError, ERROR_LOC aErrorLoc=ERROR_INSIDE) const
Build the corner list of the polygonal drill shape in the board coordinate system.
void SetPadToDieLength(int aLength)
bool operator==(const PAD &aOther) const
wxString ShowPadShape(PCB_LAYER_ID aLayer) const
void SetSizeY(const int aY)
int GetPadToDieLength() const
BOX2I m_effectiveBoundingBox
const VECTOR2I & GetSize(PCB_LAYER_ID aLayer) const
virtual std::vector< int > ViewGetLayers() const override
Return the all the layers within the VIEW the object is painted on.
A set of BOARD_ITEMs (i.e., without duplicates).
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
bool IsProxyItem() const override
void TransformShapeToPolygon(SHAPE_POLY_SET &aBuffer, PCB_LAYER_ID aLayer, int aClearance, int aError, ERROR_LOC aErrorLoc, bool ignoreLineWidth=false) const override
Convert the shape to a closed polygon.
void Move(const VECTOR2I &aMoveVector) override
Move this object.
void SetStroke(const STROKE_PARAMS &aStroke) override
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
PROPERTY_BASE & SetAvailableFunc(std::function< bool(INSPECTABLE *)> aFunc)
Set a callback function to determine whether an object provides this property.
PROPERTY_BASE & SetWriteableFunc(std::function< bool(INSPECTABLE *)> aFunc)
PROPERTY_BASE & SetValidator(PROPERTY_VALIDATOR_FN &&aValidator)
PROPERTY_BASE & SetIsHiddenFromLibraryEditors(bool aIsHidden=true)
Provide class metadata.Helper macro to map type hashes to names.
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
void Mask(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName)
Sets a base class property as masked in a derived class.
static PROPERTY_MANAGER & Instance()
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
void OverrideAvailability(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName, std::function< bool(INSPECTABLE *)> aFunc)
Sets an override availability functor for a base class property of a given derived class.
static VALIDATOR_RESULT PositiveIntValidator(const wxAny &&aValue, EDA_ITEM *aItem)
static SEG::ecoord Square(int a)
const BOX2I BBox(int aClearance=0) const override
Compute a bounding box of the shape, with a margin of aClearance a collision.
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
int PointCount() const
Return the number of points (vertices) in this line chain.
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.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
Represent a set of closed polygons.
void Rotate(const EDA_ANGLE &aAngle, const VECTOR2I &aCenter={ 0, 0 }) override
Rotate all vertices by a given angle.
void RemoveAllContours()
Remove all outlines & holes (clears) the polygon set.
bool HasHoles() const
Return true if the polygon set has any holes.
void BooleanAdd(const SHAPE_POLY_SET &b)
Perform boolean polyset union.
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new outline to the set and returns its index.
bool IsEmpty() const
Return true if the set is empty (no polygons at all)
void Fracture()
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
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,...
void Inflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, bool aSimplify=false)
Perform outline inflation/deflation.
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)
void Simplify()
Simplify the polyset (merges overlapping polys, eliminates degeneracy/self-intersections)
void BooleanIntersection(const SHAPE_POLY_SET &b)
Perform boolean polyset intersection.
int OutlineCount() const
Return the number of outlines in the set.
void Move(const VECTOR2I &aVector) override
void BooleanSubtract(const SHAPE_POLY_SET &b)
Perform boolean polyset difference.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
const SHAPE_LINE_CHAIN Outline() const
Represent a simple polygon consisting of a zero-thickness closed chain of connected line segments.
An abstract shape on 2D plane.
Simple container to manage line stroke parameters.
wxString MessageTextFromValue(double aValue, bool aAddUnitLabel=true, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
A lower-precision version of StringFromValue().
wxString StringFromValue(double aValue, bool aAddUnitLabel=false, EDA_DATA_TYPE aType=EDA_DATA_TYPE::DISTANCE) const
Converts aValue in internal units into a united string.
void TransformCircleToPolygon(SHAPE_LINE_CHAIN &aBuffer, const VECTOR2I &aCenter, int aRadius, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
Convert a circle to a polygon, using multiple straight lines.
void TransformRoundChamferedRectToPolygon(SHAPE_POLY_SET &aBuffer, const VECTOR2I &aPosition, const VECTOR2I &aSize, const EDA_ANGLE &aRotation, int aCornerRadius, double aChamferRatio, int aChamferCorners, int aInflate, int aError, ERROR_LOC aErrorLoc)
Convert a rectangle with rounded corners and/or chamfered corners to a polygon.
void TransformOvalToPolygon(SHAPE_POLY_SET &aBuffer, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aWidth, int aError, ERROR_LOC aErrorLoc, int aMinSegCount=0)
Convert a oblong shape to a polygon, using multiple segments.
void TransformTrapezoidToPolygon(SHAPE_POLY_SET &aBuffer, const VECTOR2I &aPosition, const VECTOR2I &aSize, const EDA_ANGLE &aRotation, int aDeltaX, int aDeltaY, int aInflate, int aError, ERROR_LOC aErrorLoc)
Convert a rectangle or trapezoid to a polygon.
@ RECT_CHAMFER_BOTTOM_RIGHT
@ RECT_CHAMFER_BOTTOM_LEFT
static PCB_SHAPE * findNext(PCB_SHAPE *aShape, const VECTOR2I &aPoint, const std::vector< PCB_SHAPE * > &aList, unsigned aLimit)
Search for a PCB_SHAPE matching a given end point or start point in a list.
const int minSize
Push and Shove router track width and via size dialog.
@ DRCE_PAD_TH_WITH_NO_HOLE
@ HOLE_CLEARANCE_CONSTRAINT
static constexpr EDA_ANGLE ANGLE_0
#define FOOTPRINT_EDIT_FRAME_NAME
#define PCB_EDIT_FRAME_NAME
#define ENTERED
indicates a group has been entered
#define SKIP_STRUCT
flag indicating that the structure should be ignored
Some functions to handle hotkeys in KiCad.
PCB_LAYER_ID FlipLayer(PCB_LAYER_ID aLayerId, int aCopperLayersCount)
@ LAYER_PAD_FR_NETNAMES
Additional netnames layers (not associated with a PCB layer).
bool IsFrontLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a front layer.
FLASHING
Enum used during connectivity building to ensure we do not query connectivity while building the data...
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
@ LAYER_PAD_COPPER_START
Virtual layers for pad copper on a given copper layer.
@ LAYER_FOOTPRINTS_FR
Show footprints on front.
@ LAYER_NON_PLATEDHOLES
Draw usual through hole vias.
@ LAYER_PADS
Meta control for all pads opacity/visibility (color ignored).
@ LAYER_PAD_PLATEDHOLES
to draw pad holes (plated)
@ LAYER_CLEARANCE_START
Virtual layers for pad/via/track clearance outlines for a given copper layer.
@ LAYER_FOOTPRINTS_BK
Show footprints on back.
bool IsNetnameLayer(int aLayer)
Test whether a layer is a netname layer.
bool IsHoleLayer(int aLayer)
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 ...
constexpr void MIRROR(T &aPoint, const T &aMirrorRef)
Updates aPoint with the mirror of aPoint relative to the aMirrorRef.
Message panel definition file.
constexpr int Mils2IU(const EDA_IU_SCALE &aIuScale, int mils)
@ REPAINT
Item needs to be redrawn.
bool PadHasMeaningfulRoundingRadius(const PAD &aPad, PCB_LAYER_ID aLayer)
Returns true if the pad's rounding ratio is valid (i.e.
double GetDefaultIpcRoundingRatio(const PAD &aPad, PCB_LAYER_ID aLayer)
Get a sensible default for a rounded rectangle pad's rounding ratio.
KICOMMON_API VECTOR2I UnpackVector2(const types::Vector2 &aInput)
KICOMMON_API void PackVector2(types::Vector2 &aOutput, const VECTOR2I &aInput)
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
static struct PAD_DESC _PAD_DESC
PAD_DRILL_SHAPE
The set of pad drill shapes, used with PAD::{Set,Get}DrillShape()
PAD_ATTRIB
The set of pad shapes, used with PAD::{Set,Get}Attribute().
PAD_SHAPE
The set of pad shapes, used with PAD::{Set,Get}Shape()
PAD_PROP
The set of pad properties used in Gerber files (Draw files, and P&P files) to define some properties ...
Class to handle a set of BOARD_ITEMs.
#define NO_SETTER(owner, type)
#define ENUM_TO_WXANY(type)
Macro to define read-only fields (no setter method available)
wxString UnescapeString(const wxString &aSource)
constexpr int mmToIU(double mm) const
VECTOR2I size
Drill diameter (x == y) or slot dimensions (x != y)
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_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
@ 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_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
VECTOR2< int32_t > VECTOR2I
VECTOR2< int64_t > VECTOR2L
ZONE_CONNECTION
How pads are covered by copper in zone.
#define ZONE_THICKNESS_MIN_VALUE_MM