57#include <api/board/board_types.pb.h>
61#include <magic_enum.hpp>
138 using namespace kiapi::board::types;
143 pad.set_locked(
IsLocked() ? kiapi::common::types::LockedState::LS_LOCKED
144 : kiapi::common::types::LockedState::LS_UNLOCKED );
145 pad.mutable_net()->mutable_code()->set_value(
GetNetCode() );
149 google::protobuf::Any padStackMsg;
151 padStackMsg.UnpackTo(
pad.mutable_pad_stack() );
153 DesignRuleOverrides* overrides =
pad.mutable_overrides();
167 overrides->set_zone_connection(
170 ThermalSpokeSettings* thermals =
pad.mutable_thermal_spokes();
176 aContainer.PackFrom(
pad );
182 kiapi::board::types::Pad
pad;
184 if( !aContainer.UnpackTo( &
pad ) )
190 SetLocked(
pad.locked() == kiapi::common::types::LockedState::LS_LOCKED );
193 google::protobuf::Any padStackWrapper;
194 padStackWrapper.PackFrom(
pad.pad_stack() );
199 const kiapi::board::types::DesignRuleOverrides& overrides =
pad.overrides();
201 if( overrides.has_clearance() )
206 if( overrides.has_solder_mask_margin() )
211 if( overrides.has_solder_paste_margin() )
216 if( overrides.has_solder_paste_margin_ratio() )
223 const kiapi::board::types::ThermalSpokeSettings& thermals =
pad.thermal_spokes();
263 int thisNetTieGroup = padToNetTieGroupMap[
GetNumber() ];
264 int otherNetTieGroup = padToNetTieGroupMap[ aOther->
GetNumber() ];
266 return thisNetTieGroup >= 0 && thisNetTieGroup == otherNetTieGroup;
275 return m_pinType.Contains( wxT(
"no_connect" ) );
401 && ( aLayer ==
F_Cu || aLayer ==
B_Cu ) )
414 else if( aOnlyCheckIfPermitted )
417 return board->GetConnectivity()->IsConnectedOnLayer(
this, aLayer, types );
469 return std::make_shared<SHAPE_NULL>();
476 if( flashPTHPads == FLASHING::NEVER_FLASHED )
478 else if( flashPTHPads == FLASHING::ALWAYS_FLASHED )
488 return std::make_shared<SHAPE_NULL>();
532 auto add = [
this](
SHAPE* aShape )
541 if(
GetShape() == PAD_SHAPE::CUSTOM )
544 switch( effectiveShape )
546 case PAD_SHAPE::CIRCLE:
550 case PAD_SHAPE::OVAL:
551 if( size.
x == size.
y )
558 int half_width = std::min( half_size.
x, half_size.
y );
559 VECTOR2I half_len( half_size.
x - half_width, half_size.
y - half_width );
561 add(
new SHAPE_SEGMENT( shapePos - half_len, shapePos + half_len, half_width * 2 ) );
566 case PAD_SHAPE::RECTANGLE:
567 case PAD_SHAPE::TRAPEZOID:
568 case PAD_SHAPE::ROUNDRECT:
582 if( half_size.
x < min_len && half_size.
y < min_len )
588 else if( effectiveShape == PAD_SHAPE::TRAPEZOID )
595 corners.
Append( -half_size.
x - trap_delta.
y, half_size.
y + trap_delta.
x );
596 corners.
Append( half_size.
x + trap_delta.
y, half_size.
y - trap_delta.
x );
597 corners.
Append( half_size.
x - trap_delta.
y, -half_size.
y + trap_delta.
x );
598 corners.
Append( -half_size.
x + trap_delta.
y, -half_size.
y - trap_delta.
x );
601 corners.
Move( shapePos );
641 case PAD_SHAPE::CHAMFERED_RECT:
654 wxFAIL_MSG( wxT(
"PAD::buildEffectiveShapes: Unsupported pad shape: PAD_SHAPE::" )
655 + wxString( std::string( magic_enum::enum_name( effectiveShape ) ) ) );
659 if(
GetShape() == PAD_SHAPE::CUSTOM )
663 if( !primitive->IsProxyItem() )
665 for(
SHAPE* shape : primitive->MakeEffectiveShapes() )
668 shape->Move( shapePos );
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 );
708 effectivePolygon = std::make_shared<SHAPE_POLY_SET>();
719 for(
int cnt = 0; cnt < effectivePolygon->OutlineCount(); ++cnt )
723 for(
int ii = 0; ii < poly.
PointCount(); ++ii )
755 case PAD_ATTRIB::PTH:
760 case PAD_ATTRIB::SMD:
761 case PAD_ATTRIB::CONN:
766 if( copperLayers.
count() > 1 )
768 layerMask &=
~LSET::AllCuMask();
773 layerMask.
set( copperLayers.
Seq().front() );
781 case PAD_ATTRIB::NPTH:
843 auto mirrorBitFlags = [](
int& aBitfield,
int a,
int b )
845 bool temp = aBitfield & a;
890 primitive->Flip(
VECTOR2I( 0, 0 ), aFlipLeftRight );
920 case PAD_SHAPE::CIRCLE:
929 case PAD_SHAPE::OVAL:
953 *aSource =
_(
"pad" );
965 return parentFootprint->GetClearanceOverrides( aSource );
967 return std::optional<int>();
1007 if( !margin.has_value() )
1010 margin = parentFootprint->GetLocalSolderMaskMargin();
1013 if( !margin.has_value() )
1016 margin = brd->GetDesignSettings().m_SolderMaskExpansion;
1019 int marginValue = margin.value_or( 0 );
1022 if( marginValue < 0 )
1026 if( marginValue < minsize )
1027 marginValue = minsize;
1045 if( !margin.has_value() )
1048 margin = parentFootprint->GetLocalSolderPasteMargin();
1051 if( !margin.has_value() )
1054 margin = board->GetDesignSettings().m_SolderPasteMargin;
1057 if( !mratio.has_value() )
1060 mratio = parentFootprint->GetLocalSolderPasteMarginRatio();
1063 if( !mratio.has_value() )
1066 mratio = board->GetDesignSettings().m_SolderPasteMarginRatio;
1091 if( connection != ZONE_CONNECTION::INHERITED )
1094 *aSource =
_(
"pad" );
1097 if( connection == ZONE_CONNECTION::INHERITED )
1100 connection = parentFootprint->GetZoneConnectionOverrides( aSource );
1110 *aSource =
_(
"pad" );
1119 *aSource =
_(
"pad" );
1132 if( parentFootprint )
1133 aList.emplace_back(
_(
"Footprint" ), parentFootprint->
GetReference() );
1136 aList.emplace_back(
_(
"Pad" ),
m_number );
1142 aList.emplace_back(
_(
"Pin Type" ),
GetPinType() );
1148 aList.emplace_back(
_(
"Resolved Netclass" ),
1152 aList.emplace_back(
_(
"Status" ),
_(
"Locked" ) );
1163 double area = poly->Area();
1177 case PAD_PROP::NONE:
break;
1178 case PAD_PROP::BGA: props +=
_(
"BGA" );
break;
1179 case PAD_PROP::FIDUCIAL_GLBL: props +=
_(
"Fiducial global" );
break;
1180 case PAD_PROP::FIDUCIAL_LOCAL: props +=
_(
"Fiducial local" );
break;
1181 case PAD_PROP::TESTPOINT: props +=
_(
"Test point" );
break;
1182 case PAD_PROP::HEATSINK: props +=
_(
"Heat sink" );
break;
1183 case PAD_PROP::CASTELLATED: props +=
_(
"Castellated" );
break;
1184 case PAD_PROP::MECHANICAL: props +=
_(
"Mechanical" );
break;
1204 if( !fp_orient.
IsZero() )
1209 aList.emplace_back(
_(
"Rotation" ), msg );
1213 aList.emplace_back(
_(
"Length in Package" ),
1219 if( drill.
x > 0 || drill.
y > 0 )
1223 aList.emplace_back(
_(
"Hole" ),
1224 wxString::Format( wxT(
"%s" ),
1229 aList.emplace_back(
_(
"Hole X / Y" ),
1230 wxString::Format( wxT(
"%s / %s" ),
1239 if( !source.IsEmpty() )
1241 aList.emplace_back( wxString::Format(
_(
"Min Clearance: %s" ),
1243 wxString::Format(
_(
"(from %s)" ),
1267 BOX2I arect = aRect;
1286 int count = poly->TotalVertices();
1288 for(
int ii = 0; ii < count; ii++ )
1290 VECTOR2I vertex = poly->CVertex( ii );
1291 VECTOR2I vertexNext = poly->CVertex( ( ii + 1 ) % count );
1313 if( ( diff =
static_cast<int>( aPadRef->
GetShape() ) -
1314 static_cast<int>( aPadCmp->
GetShape() ) ) != 0 )
1317 if( ( diff =
static_cast<int>( aPadRef->
m_attribute ) -
1397 case PAD_SHAPE::CIRCLE:
return _(
"Circle" );
1398 case PAD_SHAPE::OVAL:
return _(
"Oval" );
1399 case PAD_SHAPE::RECTANGLE:
return _(
"Rect" );
1400 case PAD_SHAPE::TRAPEZOID:
return _(
"Trap" );
1401 case PAD_SHAPE::ROUNDRECT:
return _(
"Roundrect" );
1402 case PAD_SHAPE::CHAMFERED_RECT:
return _(
"Chamferedrect" );
1403 case PAD_SHAPE::CUSTOM:
return _(
"CustomShape" );
1404 default:
return wxT(
"???" );
1413 case PAD_ATTRIB::PTH:
return _(
"PTH" );
1414 case PAD_ATTRIB::SMD:
return _(
"SMD" );
1415 case PAD_ATTRIB::CONN:
return _(
"Conn" );
1416 case PAD_ATTRIB::NPTH:
return _(
"NPTH" );
1417 default:
return wxT(
"???" );
1436 return wxString::Format(
_(
"NPTH pad of %s" ),
1441 return _(
"NPTH pad" );
1450 return wxString::Format(
_(
"Pad %s of %s on %s" ),
1457 return wxString::Format(
_(
"Pad on %s" ),
1465 return wxString::Format(
_(
"PTH pad %s of %s" ),
1471 return _(
"PTH pad" );
1481 return wxString::Format(
_(
"Pad %s %s of %s on %s" ),
1489 return wxString::Format(
_(
"Pad %s on %s" ),
1498 return wxString::Format(
_(
"PTH pad %s %s of %s" ),
1505 return wxString::Format(
_(
"PTH pad %s" ),
1515 return BITMAPS::pad;
1521 return new PAD( *
this );
1571 for (
int internal =
In1_Cu; internal <
In30_Cu; ++internal )
1574 aLayers[aCount++] = internal;
1586 aLayers[aCount++] = each_layer;
1593 constexpr double HIDE = std::numeric_limits<double>::max();
1658 int64_t minSide = std::min( padSize.
x, padSize.
y );
1678 if( cfg && cfg->m_Display.m_PadClearance &&
GetBoard() )
1683 int xMargin = std::max( solderMaskMargin, solderPasteMargin.
x ) + clearance;
1684 int yMargin = std::max( solderMaskMargin, solderPasteMargin.
y ) + clearance;
1735 case PAD_SHAPE::TRAPEZOID:
1739 case PAD_SHAPE::CIRCLE:
1750 case PAD_ATTRIB::SMD:
1751 case PAD_ATTRIB::CONN:
1787 std::swap( *
this, *
static_cast<PAD*
>( aImage ) );
1796 if( !drillsize.
x || !drillsize.
y )
1802 slot->GetWidth() + aClearance * 2, aError, aErrorLoc );
1809 int aMaxError,
ERROR_LOC aErrorLoc,
bool ignoreLineWidth )
const
1811 wxASSERT_MSG( !ignoreLineWidth, wxT(
"IgnoreLineWidth has no meaning for pads." ) );
1816 const int pad_min_seg_per_circle_count = 16;
1825 case PAD_SHAPE::CIRCLE:
1826 case PAD_SHAPE::OVAL:
1828 if( dx == dy || (
GetShape() == PAD_SHAPE::CIRCLE ) )
1831 pad_min_seg_per_circle_count );
1835 int half_width = std::min( dx, dy );
1841 ( half_width + aClearance ) * 2, aMaxError, aErrorLoc,
1842 pad_min_seg_per_circle_count );
1847 case PAD_SHAPE::TRAPEZOID:
1848 case PAD_SHAPE::RECTANGLE:
1855 ddy, aClearance, aMaxError, aErrorLoc );
1856 aBuffer.
Append( outline );
1860 case PAD_SHAPE::CHAMFERED_RECT:
1861 case PAD_SHAPE::ROUNDRECT:
1863 bool doChamfer =
GetShape() == PAD_SHAPE::CHAMFERED_RECT;
1870 aClearance, aMaxError, aErrorLoc );
1871 aBuffer.
Append( outline );
1875 case PAD_SHAPE::CUSTOM:
1885 aClearance += aMaxError;
1887 outline.
Inflate( aClearance, CORNER_STRATEGY::ROUND_ALL_CORNERS, aMaxError );
1890 else if( aClearance < 0 )
1896 outline.
Inflate( aClearance, CORNER_STRATEGY::ALLOW_ACUTE_CORNERS, aMaxError );
1900 aBuffer.
Append( outline );
1905 wxFAIL_MSG( wxT(
"PAD::TransformShapeToPolygon no implementation for " )
1906 + wxString( std::string( magic_enum::enum_name(
GetShape() ) ) ) );
1950 [&](
PCB_SHAPE* aShape ) -> std::vector<PCB_SHAPE*>
1952 std::vector<PCB_SHAPE*> matching;
1962 && aShape->Compare( other ) == 0 )
1964 matching.push_back( other );
1972 std::vector<PCB_SHAPE*> mergedShapes;
1985 if(
GetShape() == PAD_SHAPE::CIRCLE ||
GetShape() == PAD_SHAPE::RECTANGLE )
2016 mergedShapes.push_back( fpShape );
2031 for(
PCB_SHAPE* other : findMatching( fpShape ) )
2034 mergedShapes.push_back( other );
2044 return mergedShapes;
2049 const std::function<
void(
int aErrorCode,
2050 const wxString& aMsg )>& aErrorHandler )
const
2056 if(
GetShape() == PAD_SHAPE::CUSTOM )
2058 else if( pad_size.
x <= 0 || ( pad_size.
y <= 0 &&
GetShape() != PAD_SHAPE::CIRCLE ) )
2066 const int min_drill_size = 4;
2070 msg.Printf(
_(
"(PTH pad hole size must be larger than %s)" ),
2094 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad hole leaves no copper)" ) );
2102 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad hole non fully inside copper)" ) );
2109 aErrorHandler(
DRCE_PADSTACK,
_(
"(pad hole not inside pad shape)" ) );
2114 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative local clearance values have no effect)" ) );
2121 if( solderMaskMargin.has_value() && solderMaskMargin.value() < 0 )
2123 int absMargin = abs( solderMaskMargin.value() );
2125 if(
GetShape() == PAD_SHAPE::CUSTOM )
2127 for(
const std::shared_ptr<PCB_SHAPE>& shape :
GetPrimitives() )
2129 BOX2I shapeBBox = shape->GetBoundingBox();
2133 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder mask clearance is larger "
2134 "than some shape primitives; results may be "
2141 else if( absMargin > pad_size.
x || absMargin > pad_size.
y )
2143 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder mask clearance is larger than pad; "
2144 "no solder mask will be generated)" ) );
2157 paste_size.x = pad_size.
x + paste_margin +
KiROUND( pad_size.
x * paste_ratio );
2158 paste_size.y = pad_size.
y + paste_margin +
KiROUND( pad_size.
y * paste_ratio );
2160 if( paste_size.x <= 0 || paste_size.y <= 0 )
2162 aErrorHandler(
DRCE_PADSTACK,
_(
"(negative solder paste margin is larger than pad; "
2163 "no solder paste mask will be generated)" ) );
2168 if( padlayers_mask == 0 )
2172 aErrorHandler(
DRCE_PADSTACK,
_(
"(PTH pad has no copper layers)" ) );
2174 if( !padlayers_mask[
F_Cu] && !padlayers_mask[
B_Cu] )
2176 if( ( drill_size.
x || drill_size.
y ) &&
GetAttribute() != PAD_ATTRIB::NPTH )
2178 aErrorHandler(
DRCE_PADSTACK,
_(
"(plated through holes normally have a copper pad on "
2179 "at least one layer)" ) );
2185 case PAD_ATTRIB::NPTH:
2186 case PAD_ATTRIB::PTH:
2187 if( drill_size.
x <= 0
2188 || ( drill_size.
y <= 0 &&
GetDrillShape() == PAD_DRILL_SHAPE::OBLONG ) )
2194 case PAD_ATTRIB::CONN:
2197 aErrorHandler(
DRCE_PADSTACK,
_(
"(connector pads normally have no solder paste; use a "
2198 "SMD pad instead)" ) );
2202 case PAD_ATTRIB::SMD:
2204 if( drill_size.
x > 0 || drill_size.
y > 0 )
2211 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper on both sides of the board)" ) );
2217 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and mask layers on different "
2218 "sides of the board)" ) );
2222 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and paste layers on different "
2223 "sides of the board)" ) );
2230 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and mask layers on different "
2231 "sides of the board)" ) );
2235 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has copper and paste layers on different "
2236 "sides of the board)" ) );
2239 else if( innerlayers_mask.
count() != 0 )
2241 aErrorHandler(
DRCE_PADSTACK,
_(
"(SMD pad has no outer layers)" ) );
2251 aErrorHandler(
DRCE_PADSTACK,
_(
"('fiducial' property makes no sense on NPTH pads)" ) );
2255 aErrorHandler(
DRCE_PADSTACK,
_(
"('testpoint' property makes no sense on NPTH pads)" ) );
2258 aErrorHandler(
DRCE_PADSTACK,
_(
"('heatsink' property makes no sense of NPTH pads)" ) );
2261 aErrorHandler(
DRCE_PADSTACK,
_(
"('castellated' property is for PTH pads)" ) );
2264 aErrorHandler(
DRCE_PADSTACK,
_(
"('BGA' property is for SMD pads)" ) );
2267 aErrorHandler(
DRCE_PADSTACK,
_(
"('mechanical' property is for PTH pads)" ) );
2269 if(
GetShape() == PAD_SHAPE::ROUNDRECT )
2274 aErrorHandler(
DRCE_PADSTACK,
_(
"(corner size will make pad circular)" ) );
2276 else if(
GetShape() == PAD_SHAPE::CHAMFERED_RECT )
2283 else if(
GetShape() == PAD_SHAPE::TRAPEZOID )
2295 if(
GetShape() == PAD_SHAPE::CUSTOM )
2314 const PAD& other =
static_cast<const PAD&
>( aBoardItem );
2316 return *
this == other;
2412 const PAD& other =
static_cast<const PAD&
>( aOther );
2414 double similarity = 1.0;
2497 .Map( PAD_ATTRIB::PTH,
_HKI(
"Through-hole" ) )
2498 .Map( PAD_ATTRIB::SMD,
_HKI(
"SMD" ) )
2499 .Map( PAD_ATTRIB::CONN,
_HKI(
"Edge connector" ) )
2500 .Map( PAD_ATTRIB::NPTH,
_HKI(
"NPTH, mechanical" ) );
2503 .Map( PAD_SHAPE::CIRCLE,
_HKI(
"Circle" ) )
2504 .Map( PAD_SHAPE::RECTANGLE,
_HKI(
"Rectangle" ) )
2505 .Map( PAD_SHAPE::OVAL,
_HKI(
"Oval" ) )
2506 .Map( PAD_SHAPE::TRAPEZOID,
_HKI(
"Trapezoid" ) )
2507 .Map( PAD_SHAPE::ROUNDRECT,
_HKI(
"Rounded rectangle" ) )
2508 .Map( PAD_SHAPE::CHAMFERED_RECT,
_HKI(
"Chamfered rectangle" ) )
2509 .Map( PAD_SHAPE::CUSTOM,
_HKI(
"Custom" ) );
2512 .Map( PAD_PROP::NONE,
_HKI(
"None" ) )
2513 .Map( PAD_PROP::BGA,
_HKI(
"BGA pad" ) )
2514 .Map( PAD_PROP::FIDUCIAL_GLBL,
_HKI(
"Fiducial, global to board" ) )
2515 .Map( PAD_PROP::FIDUCIAL_LOCAL,
_HKI(
"Fiducial, local to footprint" ) )
2516 .Map( PAD_PROP::TESTPOINT,
_HKI(
"Test point pad" ) )
2517 .Map( PAD_PROP::HEATSINK,
_HKI(
"Heatsink pad" ) )
2518 .Map( PAD_PROP::CASTELLATED,
_HKI(
"Castellated pad" ) )
2519 .Map( PAD_PROP::MECHANICAL,
_HKI(
"Mechanical pad" ) );
2523 if( zcMap.
Choices().GetCount() == 0 )
2525 zcMap.
Undefined( ZONE_CONNECTION::INHERITED );
2526 zcMap.
Map( ZONE_CONNECTION::INHERITED,
_HKI(
"Inherited" ) )
2527 .
Map( ZONE_CONNECTION::NONE,
_HKI(
"None" ) )
2528 .
Map( ZONE_CONNECTION::THERMAL,
_HKI(
"Thermal reliefs" ) )
2529 .
Map( ZONE_CONNECTION::FULL,
_HKI(
"Solid" ) )
2530 .
Map( ZONE_CONNECTION::THT_THERMAL,
_HKI(
"Thermal reliefs for PTH" ) );
2537 _HKI(
"Front, back and connected layers" ) );
2547 PROPERTY_DISPLAY::PT_DEGREE ) );
2552 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2553 return pad->GetAttribute() != PAD_ATTRIB::NPTH;
2558 auto padCanHaveHole =
2561 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2563 return pad->GetAttribute() == PAD_ATTRIB::PTH
2564 ||
pad->GetAttribute() == PAD_ATTRIB::NPTH;
2571 _HKI(
"Net" ), isCopperPad );
2573 _HKI(
"Net Class" ), isCopperPad );
2575 const wxString groupPad =
_HKI(
"Pad Properties" );
2587 padNumber->SetAvailableFunc( isCopperPad );
2599 PROPERTY_DISPLAY::PT_SIZE ), groupPad );
2602 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2607 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2608 return pad->GetShape() != PAD_SHAPE::CIRCLE;
2615 roundRadiusRatio->SetAvailableFunc(
2618 if(
PAD*
pad =
dynamic_cast<PAD*
>( aItem ) )
2619 return pad->GetShape() == PAD_SHAPE::ROUNDRECT;
2623 propMgr.
AddProperty( roundRadiusRatio, groupPad );
2627 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2633 PROPERTY_DISPLAY::PT_SIZE ), groupPad )
2641 _HKI(
"Copper Layers" ),
2647 PROPERTY_DISPLAY::PT_SIZE );
2648 padToDie->SetAvailableFunc( isCopperPad );
2651 const wxString groupOverrides =
_HKI(
"Overrides" );
2654 _HKI(
"Clearance Override" ),
2656 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2659 _HKI(
"Soldermask Margin Override" ),
2661 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2664 _HKI(
"Solderpaste Margin Override" ),
2666 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides );
2669 _HKI(
"Solderpaste Margin Ratio Override" ),
2671 PROPERTY_DISPLAY::PT_RATIO ),
2675 _HKI(
"Zone Connection Style" ),
2682 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides )
2683 .
SetValidator( PROPERTY_VALIDATORS::RangeIntValidator<minZoneWidth, INT_MAX> );
2687 PROPERTY_DISPLAY::PT_DEGREE ), groupOverrides );
2691 PROPERTY_DISPLAY::PT_SIZE ), groupOverrides )
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.
BASE_SET & set(size_t pos=std::numeric_limits< size_t >::max(), bool value=true)
bool test(size_t pos) const
int compare(const BASE_SET &other) const
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 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
BOX2< Vec > & Normalize()
Ensure that the height and width are positive.
const Vec & GetOrigin() const
const SizeVec & GetSize() const
size_type GetHeight() const
bool Intersects(const BOX2< Vec > &aRect) const
size_type GetWidth() const
bool Contains(const Vec &aPoint) const
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
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 SetFilled(bool aFlag)
void SetPolyShape(const SHAPE_POLY_SET &aShape)
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.
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
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
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.
LSET & Flip(int aCopperLayersCount=0)
Flip the layers in this set.
LSEQ Seq(const PCB_LAYER_ID *aWishListSequence, unsigned aCount) const
Return an LSEQ from the union of this LSET and a desired sequence.
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.
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 ...
void SetRoundRectRadius(double aRadius, PCB_LAYER_ID aLayer=F_Cu)
std::optional< int > & Clearance(PCB_LAYER_ID aLayer=F_Cu)
bool Deserialize(const google::protobuf::Any &aContainer) override
Deserializes the given protobuf message into this object.
void SetChamferRatio(double aRatio, PCB_LAYER_ID aLayer=F_Cu)
std::vector< std::shared_ptr< PCB_SHAPE > > & Primitives(PCB_LAYER_ID aLayer=F_Cu)
void SetChamferPositions(int aPositions, PCB_LAYER_ID aLayer=F_Cu)
std::optional< double > & SolderPasteMarginRatio(PCB_LAYER_ID aLayer=F_Cu)
void SetRoundRectRadiusRatio(double aRatio, PCB_LAYER_ID aLayer=F_Cu)
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)
const LSET & LayerSet() const
int RoundRectRadius(PCB_LAYER_ID aLayer=F_Cu) const
int & ChamferPositions(PCB_LAYER_ID aLayer=F_Cu)
UNCONNECTED_LAYER_MODE UnconnectedLayerMode() const
std::optional< int > & ThermalGap(PCB_LAYER_ID aLayer=F_Cu)
double RoundRectRadiusRatio(PCB_LAYER_ID aLayer=F_Cu) const
VECTOR2I & TrapezoidDeltaSize(PCB_LAYER_ID aLayer=F_Cu)
VECTOR2I & Offset(PCB_LAYER_ID aLayer=F_Cu)
VECTOR2I & Size(PCB_LAYER_ID aLayer=F_Cu)
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.
double ChamferRatio(PCB_LAYER_ID aLayer=F_Cu) const
PAD_SHAPE Shape(PCB_LAYER_ID aLayer=F_Cu) const
EDA_ANGLE GetOrientation() const
void SetLayerSet(const LSET &aSet)
std::optional< ZONE_CONNECTION > & ZoneConnection(PCB_LAYER_ID aLayer=F_Cu)
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 SetLayerSet(LSET aLayers) override
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.
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.
bool FlashLayer(int aLayer, bool aOnlyCheckIfPermitted=false) const
Check to see whether the pad should be flashed on the specific layer.
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 GetSolderMaskExpansion() const
int GetDrillSizeY() const
std::optional< double > GetLocalSolderPasteMarginRatio() const
const wxString & GetPinType() const
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
void BuildEffectiveShapes(PCB_LAYER_ID aLayer) const
Rebuild the effective shape cache (and bounding box and radius) for the pad and clears the dirty bit.
std::mutex m_shapesBuildingLock
void SetThermalGap(int aGap)
std::shared_ptr< SHAPE_POLY_SET > m_effectivePolygon[2]
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
void FlipPrimitives(bool aFlipLeftRight)
Flip (mirror) the primitives left to right or top to bottom, around the anchor position in custom pad...
void MergePrimitivesAsPolygon(SHAPE_POLY_SET *aMergedPolygon, ERROR_LOC aErrorLoc=ERROR_INSIDE) const
Merge all basic shapes to a SHAPE_POLY_SET.
int GetRoundRectCornerRadius() const
void SetLocalSolderPasteMarginRatio(std::optional< double > aRatio)
PAD & operator=(const PAD &aOther)
std::shared_ptr< SHAPE_SEGMENT > m_effectiveHoleShape
bool IsLocked() const override
VECTOR2I GetPosition() const override
void SetProperty(PAD_PROP aProperty)
void SetThermalSpokeAngleDegrees(double aAngle)
const std::vector< std::shared_ptr< PCB_SHAPE > > & GetPrimitives() const
Accessor to the basic shape list for custom-shaped pads.
EDA_ANGLE GetThermalSpokeAngle() const
void SetOffset(const VECTOR2I &aOffset)
std::vector< PCB_SHAPE * > Recombine(bool aIsDryRun, int aMaxError)
Recombines the pad with other graphical shapes in the footprint.
PCB_LAYER_ID GetPrincipalLayer() const
void SetChamferRectRatio(double aChamferScale)
Has meaning only for chamfered rectangular pads.
const VECTOR2I & GetOffset() 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 SetRoundRectCornerRadius(double aRadius)
Has meaning only for rounded rectangle pads.
bool IsNoConnectPad() const
int GetDrillSizeX() const
VECTOR2I ShapePos() 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").
int GetLocalThermalGapOverride(wxString *aSource=nullptr) const
wxString ShowPadAttr() const
wxString ShowPadShape() const
void SetDrillShape(PAD_DRILL_SHAPE aShape)
int m_effectiveBoundingRadius
void SetLocalSolderMaskMargin(std::optional< int > aMargin)
const std::shared_ptr< SHAPE_POLY_SET > & GetEffectivePolygon(ERROR_LOC aErrorLoc=ERROR_INSIDE) const
void SetLocalZoneConnection(ZONE_CONNECTION aType)
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.
void SetDelta(const VECTOR2I &aSize)
bool IsOnCopperLayer() const override
void SetDrillSizeX(const int aX)
void SetPadstack(const PADSTACK &aPadstack)
void SetPosition(const VECTOR2I &aPos) override
const PADSTACK & Padstack() const
const VECTOR2I & GetDelta() const
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)
PAD_SHAPE GetShape() const
EDA_ANGLE GetOrientation() const
Return the rotation angle of the pad.
PADSTACK::CUSTOM_SHAPE_ZONE_MODE GetCustomShapeInZoneOpt() const
PAD_DRILL_SHAPE GetDrillShape() const
void Flip(const VECTOR2I &VECTOR2I, bool aFlipLeftRight) override
Flip this object, i.e.
VECTOR2I GetSolderPasteMargin() const
Usually < 0 (mask shape smaller than pad)because the margin can be dependent on the pad size,...
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
static LSET SMDMask()
layer set for a SMD pad on Front layer
std::optional< int > GetLocalSolderPasteMargin() const
void CheckPad(UNITS_PROVIDER *aUnitsProvider, const std::function< void(int aErrorCode, const wxString &aMsg)> &aErrorHandler) const
std::optional< int > GetLocalSolderMaskMargin() const
void SetLocalSolderPasteMargin(std::optional< int > aMargin)
void SetShape(PAD_SHAPE aShape)
Set the new shape of this pad.
PCB_LAYER_ID GetLayer() const override
Return the primary layer this item is on.
int GetThermalSpokeWidth() const
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
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 SetRoundRectRadiusRatio(double aRadiusScale)
Has meaning only for rounded rectangle pads.
void SetAnchorPadShape(PAD_SHAPE aShape)
Set the shape of the anchor pad for custom shaped pads.
std::array< ZONE_LAYER_OVERRIDE, MAX_CU_LAYERS > m_zoneLayerOverrides
void AddPrimitive(PCB_SHAPE *aPrimitive)
Add item to the custom shape primitives list.
void SetOrientation(const EDA_ANGLE &aAngle)
Set the rotation angle of the pad.
PADSTACK::UNCONNECTED_LAYER_MODE GetUnconnectedLayerMode() const
BITMAPS GetMenuImage() const override
Return a pointer to an image to be used in menus.
int GetChamferPositions() const
virtual void ViewGetLayers(int aLayers[], int &aCount) const override
Return the all the layers within the VIEW the object is painted on.
void ReplacePrimitives(const std::vector< std::shared_ptr< PCB_SHAPE > > &aPrimitivesList)
Clear the current custom shape primitives list and import a new list.
void SetLocalClearance(std::optional< int > aClearance)
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING flashPTHPads=FLASHING::DEFAULT) const override
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
int GetSubRatsnest() const
void SetSizeX(const int aX)
ZONE_CONNECTION GetLocalZoneConnection() const
void SetThermalSpokeWidth(int aWidth)
Set the width of the thermal spokes connecting the pad to a zone.
void SetSize(const VECTOR2I &aSize)
void SetDrillSizeY(const int aY)
double GetThermalSpokeAngleDegrees() const
double GetRoundRectRadiusRatio() const
int GetThermalGap() 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
bool SharesNetTieGroup(const PAD *aOther) const
const VECTOR2I & GetSize() const
double ViewGetLOD(int aLayer, KIGFX::VIEW *aView) const override
Return the level of detail (LOD) of the item.
void SetSubRatsnest(int aSubRatsnest)
std::shared_ptr< SHAPE_COMPOUND > m_effectiveShape
void SetChamferPositions(int aPositions)
Has meaning only for chamfered rectangular pads.
int GetLocalSpokeWidthOverride(wxString *aSource=nullptr) const
PAD_SHAPE GetAnchorPadShape() 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.
double GetChamferRectRatio() const
void SetPadToDieLength(int aLength)
bool operator==(const PAD &aOther) const
void SetSizeY(const int aY)
int GetPadToDieLength() const
BOX2I m_effectiveBoundingBox
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)
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 BooleanSubtract(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset difference For aFastMode meaning, see function booleanOp.
void Fracture(POLYGON_MODE aFastMode)
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
bool IsEmpty() const
Return true if the set is empty (no polygons at all)
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 BooleanIntersection(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset intersection For aFastMode meaning, see function booleanOp.
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)
int OutlineCount() const
Return the number of outlines in the set.
void Move(const VECTOR2I &aVector) override
const SHAPE_LINE_CHAIN & COutline(int aIndex) 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.
@ 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
ERROR_LOC
When approximating an arc or circle, should the error be placed on the outside or inside of the curve...
Some functions to handle hotkeys in KiCad.
@ 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)
Tests whether a layer is a copper layer.
@ LAYER_FOOTPRINTS_FR
show footprints on front
@ LAYER_NON_PLATEDHOLES
handle color for not plated holes (holes, not pads)
@ LAYER_PADS
Meta control for all pads opacity/visibility (color ignored)
@ LAYER_PAD_PLATEDHOLES
to draw pad holes (plated)
@ LAYER_FOOTPRINTS_BK
show footprints on back
@ LAYER_PADS_SMD_BK
smd pads, back layer
@ LAYER_PADS_TH
multilayer pads, usually with holes
@ LAYER_PADS_SMD_FR
smd pads, front layer
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 ...
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)
T clamp(T min, T value, T max)
void PackVector2(kiapi::common::types::Vector2 &aOutput, const VECTOR2I aInput)
VECTOR2I UnpackVector2(const types::Vector2 &aInput)
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
static struct PAD_DESC _PAD_DESC
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 ...
#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)
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
VECTOR2< int32_t > VECTOR2I
VECTOR2< double > VECTOR2D
VECTOR2< int64_t > VECTOR2L
ZONE_CONNECTION
How pads are covered by copper in zone.
#define ZONE_THICKNESS_MIN_VALUE_MM