58#include <api/board/board_types.pb.h>
62#include <magic_enum.hpp>
149 *
this = *
static_cast<const PAD*
>( aOther );
160 pad.set_locked(
IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
161 : kiapi::common::types::LockedState::LS_UNLOCKED );
166 google::protobuf::Any padStackMsg;
168 padStackMsg.UnpackTo(
pad.mutable_pad_stack() );
173 aContainer.PackFrom(
pad );
179 kiapi::board::types::Pad
pad;
181 if( !aContainer.UnpackTo( &
pad ) )
187 SetLocked(
pad.locked() == kiapi::common::types::LockedState::LS_LOCKED );
191 google::protobuf::Any padStackWrapper;
192 padStackWrapper.PackFrom(
pad.pad_stack() );
197 if(
pad.has_copper_clearance_override() )
262 int thisNetTieGroup = padToNetTieGroupMap[
GetNumber() ];
263 int otherNetTieGroup = padToNetTieGroupMap[ aOther->
GetNumber() ];
265 return thisNetTieGroup >= 0 && thisNetTieGroup == otherNetTieGroup;
274 return m_pinType.Contains( wxT(
"no_connect" ) );
377 else if(
GetShape( layer ) == PAD_SHAPE::OVAL
415 else if( aOnlyCheckIfPermitted )
425 return board->GetConnectivity()->IsConnectedOnLayer(
this, aLayer, nonZoneTypes );
449 if( aShape == PAD_DRILL_SHAPE::CIRCLE )
479 "Set front radius only meaningful for normal padstacks" );
489 const int minSize = std::min( size.
x, size.
y );
490 const double newRatio = aRadius / double(
minSize );
499 const int minSize = std::min( size.
x, size.
y );
530 std::shared_ptr<SHAPE_COMPOUND> effective_compund = std::make_shared<SHAPE_COMPOUND>();
535 return effective_compund;
539 effective_compund->AddShape( std::make_shared<SHAPE_NULL>() );
540 return effective_compund;
547 std::shared_ptr<SHAPE_COMPOUND> effective_compund = std::make_shared<SHAPE_COMPOUND>();
549 if( flashPTHPads == FLASHING::NEVER_FLASHED )
551 else if( flashPTHPads == FLASHING::ALWAYS_FLASHED )
561 return effective_compund;
565 effective_compund->AddShape( std::make_shared<SHAPE_NULL>() );
566 return effective_compund;
577 wxT(
"Null shape in PAD::GetEffectiveShape!" ) );
628 half_width = half_size.
x;
632 half_width = std::min( half_size.
x, half_size.
y );
633 half_len =
VECTOR2I( half_size.
x - half_width, half_size.
y - half_width );
654 auto add = [
this, aLayer](
SHAPE* aShape )
663 if( effectiveShape == PAD_SHAPE::CUSTOM )
666 switch( effectiveShape )
668 case PAD_SHAPE::CIRCLE:
672 case PAD_SHAPE::OVAL:
673 if( size.
x == size.
y )
680 int half_width = std::min( half_size.
x, half_size.
y );
681 VECTOR2I half_len( half_size.
x - half_width, half_size.
y - half_width );
683 add(
new SHAPE_SEGMENT( shapePos - half_len, shapePos + half_len, half_width * 2 ) );
688 case PAD_SHAPE::RECTANGLE:
689 case PAD_SHAPE::TRAPEZOID:
690 case PAD_SHAPE::ROUNDRECT:
704 if( half_size.
x < min_len && half_size.
y < min_len )
710 else if( effectiveShape == PAD_SHAPE::TRAPEZOID )
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 );
720 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
723 corners.
Move( shapePos );
763 case PAD_SHAPE::CHAMFERED_RECT:
778 wxFAIL_MSG( wxT(
"PAD::buildEffectiveShapes: Unsupported pad shape: PAD_SHAPE::" )
779 + wxString( std::string( magic_enum::enum_name( effectiveShape ) ) ) );
783 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
787 if( !primitive->IsProxyItem() )
789 for(
SHAPE* shape : primitive->MakeEffectiveShapes() )
792 shape->Move( shapePos );
819 std::shared_ptr<SHAPE_POLY_SET>& effectivePolygon =
822 effectivePolygon = std::make_shared<SHAPE_POLY_SET>();
831 for(
int cnt = 0; cnt < effectivePolygon->OutlineCount(); ++cnt )
835 for(
int ii = 0; ii < poly.
PointCount(); ++ii )
876 case PAD_ATTRIB::PTH:
881 case PAD_ATTRIB::SMD:
882 case PAD_ATTRIB::CONN:
887 if( copperLayers.count() > 1 )
889 layerMask &=
~LSET::AllCuMask();
891 if( copperLayers.test(
B_Cu ) )
894 layerMask.
set( copperLayers.
Seq().front() );
902 case PAD_ATTRIB::NPTH:
923 if( !wasRoundable && isRoundable )
979 auto mirrorBitFlags = [](
int& aBitfield,
int a,
int b )
981 bool temp = aBitfield & a;
997 if( aFlipDirection == FLIP_DIRECTION::LEFT_RIGHT )
1042 primitive->SetParent(this);
1043 primitive->Flip( VECTOR2I( 0, 0 ), aFlipDirection );
1055 if( loc_offset.
x == 0 && loc_offset.
y == 0 )
1072 bool hasAnnularRing =
true;
1079 case PAD_SHAPE::CIRCLE:
1083 hasAnnularRing = false;
1088 case PAD_SHAPE::OVAL:
1093 hasAnnularRing = false;
1105 if( !hasAnnularRing )
1116 *aSource =
_(
"pad" );
1128 return parentFootprint->GetClearanceOverrides( aSource );
1130 return std::optional<int>();
1175 std::optional<int> margin;
1191 if( !margin.has_value() )
1194 margin = parentFootprint->GetLocalSolderMaskMargin();
1198 int marginValue = margin.value_or( 0 );
1203 if( marginValue < 0 )
1207 if( marginValue < minsize )
1208 marginValue = minsize;
1230 std::optional<int> margin;
1231 std::optional<double> mratio;
1253 if( !margin.has_value() )
1256 margin = parentFootprint->GetLocalSolderPasteMargin();
1259 if( !mratio.has_value() )
1262 mratio = parentFootprint->GetLocalSolderPasteMarginRatio();
1270 pad_margin.
x = margin.value_or( 0 ) +
KiROUND( padSize.
x * mratio.value_or( 0 ) );
1271 pad_margin.
y = margin.value_or( 0 ) +
KiROUND( padSize.
y * mratio.value_or( 0 ) );
1276 if( pad_margin.
x < -padSize.
x / 2 )
1277 pad_margin.
x = -padSize.
x / 2;
1279 if( pad_margin.
y < -padSize.
y / 2 )
1280 pad_margin.
y = -padSize.
y / 2;
1291 if( connection != ZONE_CONNECTION::INHERITED )
1294 *aSource =
_(
"pad" );
1297 if( connection == ZONE_CONNECTION::INHERITED )
1300 connection = parentFootprint->GetZoneConnectionOverrides( aSource );
1310 *aSource =
_(
"pad" );
1319 *aSource =
_(
"pad" );
1332 if( parentFootprint )
1333 aList.emplace_back(
_(
"Footprint" ), parentFootprint->
GetReference() );
1336 aList.emplace_back(
_(
"Pad" ),
m_number );
1342 aList.emplace_back(
_(
"Pin Type" ),
GetPinType() );
1348 aList.emplace_back(
_(
"Resolved Netclass" ),
1352 aList.emplace_back(
_(
"Status" ),
_(
"Locked" ) );
1364 double area = poly->Area();
1378 case PAD_PROP::NONE:
break;
1379 case PAD_PROP::BGA: props +=
_(
"BGA" );
break;
1380 case PAD_PROP::FIDUCIAL_GLBL: props +=
_(
"Fiducial global" );
break;
1381 case PAD_PROP::FIDUCIAL_LOCAL: props +=
_(
"Fiducial local" );
break;
1382 case PAD_PROP::TESTPOINT: props +=
_(
"Test point" );
break;
1383 case PAD_PROP::HEATSINK: props +=
_(
"Heat sink" );
break;
1384 case PAD_PROP::CASTELLATED: props +=
_(
"Castellated" );
break;
1385 case PAD_PROP::MECHANICAL: props +=
_(
"Mechanical" );
break;
1394 if( ( padShape == PAD_SHAPE::CIRCLE || padShape == PAD_SHAPE::OVAL )
1395 && padSize.
x == padSize.
y )
1409 if( !fp_orient.
IsZero() )
1414 aList.emplace_back(
_(
"Rotation" ), msg );
1418 aList.emplace_back(
_(
"Length in Package" ),
1424 if( drill.
x > 0 || drill.
y > 0 )
1428 aList.emplace_back(
_(
"Hole" ),
1429 wxString::Format( wxT(
"%s" ),
1434 aList.emplace_back(
_(
"Hole X / Y" ),
1435 wxString::Format( wxT(
"%s / %s" ),
1444 if( !source.IsEmpty() )
1446 aList.emplace_back( wxString::Format(
_(
"Min Clearance: %s" ),
1448 wxString::Format(
_(
"(from %s)" ),
1466 bool contains =
false;
1484 BOX2I arect = aRect;
1509 const std::shared_ptr<SHAPE_POLY_SET>& poly =
1512 int count = poly->TotalVertices();
1514 for(
int ii = 0; ii < count; ii++ )
1516 VECTOR2I vertex = poly->CVertex( ii );
1517 VECTOR2I vertexNext = poly->CVertex( ( ii + 1 ) % count );
1544 if( ( diff =
static_cast<int>( aPadRef->
m_attribute ) -
1568 case PAD_SHAPE::CIRCLE:
return _(
"Circle" );
1569 case PAD_SHAPE::OVAL:
return _(
"Oval" );
1570 case PAD_SHAPE::RECTANGLE:
return _(
"Rect" );
1571 case PAD_SHAPE::TRAPEZOID:
return _(
"Trap" );
1572 case PAD_SHAPE::ROUNDRECT:
return _(
"Roundrect" );
1573 case PAD_SHAPE::CHAMFERED_RECT:
return _(
"Chamferedrect" );
1574 case PAD_SHAPE::CUSTOM:
return _(
"CustomShape" );
1575 default:
return wxT(
"???" );
1584 case PAD_ATTRIB::PTH:
return _(
"PTH" );
1585 case PAD_ATTRIB::SMD:
return _(
"SMD" );
1586 case PAD_ATTRIB::CONN:
return _(
"Conn" );
1587 case PAD_ATTRIB::NPTH:
return _(
"NPTH" );
1588 default:
return wxT(
"???" );
1605 return wxString::Format(
_(
"NPTH pad of %s" ),
1610 return _(
"NPTH pad" );
1619 return wxString::Format(
_(
"Pad %s of %s on %s" ),
1626 return wxString::Format(
_(
"Pad on %s" ),
1634 return wxString::Format(
_(
"PTH pad %s of %s" ),
1640 return _(
"PTH pad" );
1650 return wxString::Format(
_(
"Pad %s %s of %s on %s" ),
1658 return wxString::Format(
_(
"Pad %s on %s" ),
1667 return wxString::Format(
_(
"PTH pad %s %s of %s" ),
1674 return wxString::Format(
_(
"PTH pad %s" ),
1684 return BITMAPS::pad;
1690 PAD* cloned =
new PAD( *
this );
1698 primitive->SetParent( cloned );
1708 std::vector<int> layers;
1709 layers.reserve( 64 );
1729 cuLayers &= board->GetEnabledLayers();
1731 if( cuLayers.count() > 1 )
1775 layers.push_back( each_layer );
1807 if( !visiblePhysical.any() )
1846 int64_t minSide = std::min( padSize.
x, padSize.
y );
1858 int solderMaskMargin = 0;
1864 solderMaskMargin = std::max( solderMaskMargin,
1867 solderPasteMargin.
x = std::max( solderPasteMargin.
x, layerMargin.
x );
1868 solderPasteMargin.
y = std::max( solderPasteMargin.
y, layerMargin.
y );
1877 if( cfg && cfg->m_Display.m_PadClearance &&
GetBoard() )
1882 int xMargin = std::max( solderMaskMargin, solderPasteMargin.
x ) +
clearance;
1883 int yMargin = std::max( solderMaskMargin, solderPasteMargin.
y ) +
clearance;
1927 if( aMasterPad.
GetShape( aLayer ) == PAD_SHAPE::CIRCLE )
1933 case PAD_ATTRIB::SMD:
1934 case PAD_ATTRIB::CONN:
1966 std::swap( *
this, *
static_cast<PAD*
>( aImage ) );
1975 if( !drillsize.
x || !drillsize.
y )
1981 slot->GetWidth() + aClearance * 2, aError, aErrorLoc );
1988 int aMaxError,
ERROR_LOC aErrorLoc,
bool ignoreLineWidth )
const
1990 wxASSERT_MSG( !ignoreLineWidth, wxT(
"IgnoreLineWidth has no meaning for pads." ) );
1992 wxT(
"UNDEFINED_LAYER is no longer allowed for PAD::TransformShapeToPolygon" ) );
1997 const int pad_min_seg_per_circle_count = 16;
2006 case PAD_SHAPE::CIRCLE:
2007 case PAD_SHAPE::OVAL:
2009 if( dx == dy || ( shape == PAD_SHAPE::CIRCLE ) )
2012 pad_min_seg_per_circle_count );
2016 int half_width = std::min( dx, dy );
2022 ( half_width + aClearance ) * 2, aMaxError, aErrorLoc,
2023 pad_min_seg_per_circle_count );
2028 case PAD_SHAPE::TRAPEZOID:
2029 case PAD_SHAPE::RECTANGLE:
2032 int ddx = shape == PAD_SHAPE::TRAPEZOID ? trapDelta.
x / 2 : 0;
2033 int ddy = shape == PAD_SHAPE::TRAPEZOID ? trapDelta.
y / 2 : 0;
2038 aBuffer.
Append( outline );
2042 case PAD_SHAPE::CHAMFERED_RECT:
2043 case PAD_SHAPE::ROUNDRECT:
2045 bool doChamfer = shape == PAD_SHAPE::CHAMFERED_RECT;
2052 aClearance, aMaxError, aErrorLoc );
2053 aBuffer.
Append( outline );
2057 case PAD_SHAPE::CUSTOM:
2067 aClearance += aMaxError;
2069 outline.
Inflate( aClearance, CORNER_STRATEGY::ROUND_ALL_CORNERS, aMaxError );
2072 else if( aClearance < 0 )
2078 outline.
Inflate( aClearance, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, aMaxError );
2082 aBuffer.
Append( outline );
2087 wxFAIL_MSG( wxT(
"PAD::TransformShapeToPolygon no implementation for " )
2088 + wxString( std::string( magic_enum::enum_name( shape ) ) ) );
2132 [&](
PCB_SHAPE* aShape ) -> std::vector<PCB_SHAPE*>
2134 std::vector<PCB_SHAPE*> matching;
2144 && aShape->Compare( other ) == 0 )
2146 matching.push_back( other );
2154 std::vector<PCB_SHAPE*> mergedShapes;
2167 if( !aIsDryRun &&
findNext( layer ) && origShape != PAD_SHAPE::CUSTOM )
2169 if( origShape == PAD_SHAPE::CIRCLE || origShape == PAD_SHAPE::RECTANGLE )
2173 SetShape( layer, PAD_SHAPE::CUSTOM );
2181 int minExtent = std::min(
GetSize( layer ).x,
GetSize( layer ).y );
2184 SetShape( layer, PAD_SHAPE::CUSTOM );
2200 mergedShapes.push_back( fpShape );
2208 group->RemoveItem( fpShape );
2226 for(
PCB_SHAPE* other : findMatching( fpShape ) )
2229 mergedShapes.push_back( other );
2239 return mergedShapes;
2244 const std::function<
void(
int aErrorCode,
2245 const wxString& aMsg )>& aErrorHandler )
const
2250 doCheckPad( aLayer, aUnitsProvider, aForPadProperties, aErrorHandler );
2256 if( !padlayers_mask[
F_Cu] && !padlayers_mask[
B_Cu] )
2258 if( ( drill_size.
x || drill_size.
y ) &&
GetAttribute() != PAD_ATTRIB::NPTH )
2260 aErrorHandler(
DRCE_PADSTACK,
_(
"(plated through holes normally have a copper pad on "
2261 "at least one outer layer)" ) );
2268 aErrorHandler(
DRCE_PADSTACK,
_(
"('fiducial' property makes no sense on NPTH pads)" ) );
2272 aErrorHandler(
DRCE_PADSTACK,
_(
"('testpoint' property makes no sense on NPTH pads)" ) );
2275 aErrorHandler(
DRCE_PADSTACK,
_(
"('heatsink' property makes no sense of NPTH pads)" ) );
2278 aErrorHandler(
DRCE_PADSTACK,
_(
"('castellated' property is for PTH pads)" ) );
2281 aErrorHandler(
DRCE_PADSTACK,
_(
"('BGA' property is for SMD pads)" ) );
2284 aErrorHandler(
DRCE_PADSTACK,
_(
"('mechanical' property is for PTH pads)" ) );
2288 case PAD_ATTRIB::NPTH:
2289 case PAD_ATTRIB::PTH:
2290 if( drill_size.
x <= 0
2291 || ( drill_size.
y <= 0 &&
GetDrillShape() == PAD_DRILL_SHAPE::OBLONG ) )
2297 case PAD_ATTRIB::CONN:
2300 aErrorHandler(
DRCE_PADSTACK,
_(
"(connector pads normally have no solder paste; use a "
2301 "SMD pad instead)" ) );
2305 case PAD_ATTRIB::SMD:
2307 if( drill_size.
x > 0 || drill_size.
y > 0 )
2314 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper on both sides of the board)" ) );
2320 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and mask layers on different "
2321 "sides of the board)" ) );
2325 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and paste layers on different "
2326 "sides of the board)" ) );
2333 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and mask layers on different "
2334 "sides of the board)" ) );
2338 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and paste layers on different "
2339 "sides of the board)" ) );
2342 else if( innerlayers_mask.count() != 0 )
2344 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has no outer layers)" ) );
2354 const std::function<
void(
int aErrorCode,
2355 const wxString& aMsg )>& aErrorHandler )
const
2361 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
2363 else if( pad_size.
x <= 0 || ( pad_size.
y <= 0 &&
GetShape( aLayer ) != PAD_SHAPE::CIRCLE ) )
2371 const int min_drill_size = 4;
2375 msg.Printf(
_(
"(PTH pad hole size must be larger than %s)" ),
2399 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad hole leaves no copper)" ) );
2401 else if( aForPadProperties )
2409 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad hole not fully inside copper)" ) );
2416 aErrorHandler(
DRCE_PADSTACK,
_(
"(pad hole not inside pad shape)" ) );
2421 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative local clearance values have no effect)" ) );
2428 if( solderMaskMargin.has_value() && solderMaskMargin.value() < 0 )
2430 int absMargin = abs( solderMaskMargin.value() );
2432 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
2434 for(
const std::shared_ptr<PCB_SHAPE>& shape :
GetPrimitives( aLayer ) )
2436 BOX2I shapeBBox = shape->GetBoundingBox();
2440 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder mask clearance is larger "
2441 "than some shape primitives; results may be "
2448 else if( absMargin > pad_size.
x || absMargin > pad_size.
y )
2450 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder mask clearance is larger than pad; "
2451 "no solder mask will be generated)" ) );
2464 paste_size.x = pad_size.
x + paste_margin +
KiROUND( pad_size.
x * paste_ratio );
2465 paste_size.y = pad_size.
y + paste_margin +
KiROUND( pad_size.
y * paste_ratio );
2467 if( paste_size.x <= 0 || paste_size.y <= 0 )
2469 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder paste margin is larger than pad; "
2470 "no solder paste mask will be generated)" ) );
2473 if(
GetShape( aLayer ) == PAD_SHAPE::ROUNDRECT )
2478 aErrorHandler(
DRCE_PADSTACK,
_(
"(corner size will make pad circular)" ) );
2480 else if(
GetShape( aLayer ) == PAD_SHAPE::CHAMFERED_RECT )
2487 else if(
GetShape( aLayer ) == PAD_SHAPE::TRAPEZOID )
2498 if(
GetShape( aLayer ) == PAD_SHAPE::CUSTOM )
2517 const PAD& other =
static_cast<const PAD&
>( aBoardItem );
2519 return *
this == other;
2546 const PAD& other =
static_cast<const PAD&
>( aOther );
2548 double similarity = 1.0;
2567 poly_no_hole.
Append( aPoly );
2574 for(
int ii = 0; ii < poly_no_hole.
OutlineCount(); ++ii )
2609 if( aPrimitivesList.size() )
2619 for(
const std::shared_ptr<PCB_SHAPE>& prim : aPrimitivesList )
2668 case PAD_SHAPE::RECTANGLE:
2670 SHAPE_RECT rect( -padSize.
x / 2, -padSize.
y / 2, padSize.
x, padSize.
y );
2676 case PAD_SHAPE::CIRCLE:
2686 if( !primitive->IsProxyItem() )
2687 primitive->TransformShapeToPolygon( polyset,
UNDEFINED_LAYER, 0, maxError, aErrorLoc );
2706 .Map( PAD_ATTRIB::PTH,
_HKI(
"Through-hole" ) )
2707 .Map( PAD_ATTRIB::SMD,
_HKI(
"SMD" ) )
2708 .Map( PAD_ATTRIB::CONN,
_HKI(
"Edge connector" ) )
2709 .Map( PAD_ATTRIB::NPTH,
_HKI(
"NPTH, mechanical" ) );
2712 .Map( PAD_SHAPE::CIRCLE,
_HKI(
"Circle" ) )
2713 .Map( PAD_SHAPE::RECTANGLE,
_HKI(
"Rectangle" ) )
2714 .Map( PAD_SHAPE::OVAL,
_HKI(
"Oval" ) )
2715 .Map( PAD_SHAPE::TRAPEZOID,
_HKI(
"Trapezoid" ) )
2716 .Map( PAD_SHAPE::ROUNDRECT,
_HKI(
"Rounded rectangle" ) )
2717 .Map( PAD_SHAPE::CHAMFERED_RECT,
_HKI(
"Chamfered rectangle" ) )
2718 .Map( PAD_SHAPE::CUSTOM,
_HKI(
"Custom" ) );
2721 .Map( PAD_PROP::NONE,
_HKI(
"None" ) )
2722 .Map( PAD_PROP::BGA,
_HKI(
"BGA pad" ) )
2723 .Map( PAD_PROP::FIDUCIAL_GLBL,
_HKI(
"Fiducial, global to board" ) )
2724 .Map( PAD_PROP::FIDUCIAL_LOCAL,
_HKI(
"Fiducial, local to footprint" ) )
2725 .Map( PAD_PROP::TESTPOINT,
_HKI(
"Test point pad" ) )
2726 .Map( PAD_PROP::HEATSINK,
_HKI(
"Heatsink pad" ) )
2727 .Map( PAD_PROP::CASTELLATED,
_HKI(
"Castellated pad" ) )
2728 .Map( PAD_PROP::MECHANICAL,
_HKI(
"Mechanical pad" ) );
2731 .Map( PAD_DRILL_SHAPE::CIRCLE,
_HKI(
"Round" ) )
2732 .Map( PAD_DRILL_SHAPE::OBLONG,
_HKI(
"Oblong" ) );
2736 if( zcMap.
Choices().GetCount() == 0 )
2738 zcMap.
Undefined( ZONE_CONNECTION::INHERITED );
2739 zcMap.
Map( ZONE_CONNECTION::INHERITED,
_HKI(
"Inherited" ) )
2740 .
Map( ZONE_CONNECTION::NONE,
_HKI(
"None" ) )
2741 .
Map( ZONE_CONNECTION::THERMAL,
_HKI(
"Thermal reliefs" ) )
2742 .
Map( ZONE_CONNECTION::FULL,
_HKI(
"Solid" ) )
2743 .
Map( ZONE_CONNECTION::THT_THERMAL,
_HKI(
"Thermal reliefs for PTH" ) );
2750 _HKI(
"Front, back and connected layers" ) );
2761 PROPERTY_DISPLAY::PT_DEGREE ) );
2766 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2767 return pad->GetAttribute() != PAD_ATTRIB::NPTH;
2772 auto padCanHaveHole =
2775 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2777 return pad->GetAttribute() == PAD_ATTRIB::PTH
2778 ||
pad->GetAttribute() == PAD_ATTRIB::NPTH;
2784 auto hasNormalPadstack =
2787 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2794 _HKI(
"Net" ), isCopperPad );
2796 _HKI(
"Net Class" ), isCopperPad );
2798 const wxString groupPad =
_HKI(
"Pad Properties" );
2811 padNumber->SetAvailableFunc( isCopperPad );
2823 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2827 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2831 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2844 const auto hasRoundRadius = [=](
INSPECTABLE* aItem ) ->
bool
2846 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2860 roundRadiusRatio->SetAvailableFunc( hasRoundRadius );
2861 propMgr.
AddProperty( roundRadiusRatio, groupPad );
2865 PROPERTY_DISPLAY::PT_SIZE );
2866 roundRadiusSize->SetAvailableFunc( hasRoundRadius );
2875 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2881 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2888 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2889 return pad->GetDrillShape() != PAD_DRILL_SHAPE::CIRCLE;
2898 _HKI(
"Copper Layers" ),
2904 PROPERTY_DISPLAY::PT_SIZE );
2905 padToDie->SetAvailableFunc( isCopperPad );
2910 padToDieDelay->SetAvailableFunc( isCopperPad );
2913 const wxString groupOverrides =
_HKI(
"Overrides" );
2916 _HKI(
"Clearance Override" ),
2918 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2921 _HKI(
"Soldermask Margin Override" ),
2923 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2926 _HKI(
"Solderpaste Margin Override" ),
2928 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2931 _HKI(
"Solderpaste Margin Ratio Override" ),
2933 PROPERTY_DISPLAY::PT_RATIO ),
2937 _HKI(
"Zone Connection Style" ),
2943 _HKI(
"Thermal Relief Spoke Width" ),
2945 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides )
2946 .
SetValidator( PROPERTY_VALIDATORS::RangeIntValidator<minZoneWidth, INT_MAX> );
2949 _HKI(
"Thermal Relief Spoke Angle" ),
2951 PROPERTY_DISPLAY::PT_DEGREE ), groupOverrides );
2954 _HKI(
"Thermal Relief Gap" ),
2956 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
void PackNet(kiapi::board::types::Net *aProto) 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
void UnpackNet(const kiapi::board::types::Net &aProto)
Assigns a net to this item from an API message.
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.
void SetLocked(bool aLocked) override
bool IsLocked() const override
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
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.
const 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
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
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 set of EDA_ITEMs (i.e., without duplicates).
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
Owner.
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.
static const LSET & FrontBoardTechMask()
Return a mask holding technical layers used in a board fabrication (no CU layer) on front side.
LSEQ UIOrder() const
Return the copper, technical and user layers in the order shown in layer widget.
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Return a mask holding the requested number of Cu PCB_LAYER_IDs.
LSEQ Seq(const LSEQ &aSequence) const
Return an LSEQ from the union of this LSET and a desired sequence.
static const LSET & PhysicalLayersMask()
Return a mask holding all layers which are physically realized.
static const LSET & BackBoardTechMask()
Return a mask holding technical layers used in a board fabrication (no CU layer) on Back side.
static const LSET & InternalCuMask()
Return a complete set of internal copper layers which is all Cu layers except F_Cu and B_Cu.
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 SetPadToDieDelay(int aDelay)
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
int GetPadToDieDelay() 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.
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
@ SOLDER_PASTE_ABS_MARGIN_CONSTRAINT
@ SOLDER_MASK_EXPANSION_CONSTRAINT
@ SOLDER_PASTE_REL_MARGIN_CONSTRAINT
static constexpr EDA_ANGLE ANGLE_0
#define FOOTPRINT_EDIT_FRAME_NAME
#define PCB_EDIT_FRAME_NAME
#define IGNORE_PARENT_GROUP
#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_LOCKED_ITEM_SHADOW
Shadow layer for locked items.
@ 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)
bool IsExternalCopperLayer(int aLayerId)
Test whether a layer is an external (F_Cu or B_Cu) copper layer.
PCB_LAYER_ID
A quick note on layer IDs:
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
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
ZONE_CONNECTION
How pads are covered by copper in zone.
#define ZONE_THICKNESS_MIN_VALUE_MM