47#include <compoundfilereader.h>
54#include <wx/docview.h>
56#include <wx/mstream.h>
57#include <wx/wfstream.h>
58#include <wx/zstream.h>
60#include <magic_enum.hpp>
82 THROW_IO_ERROR( wxString::Format( wxT(
"Component creator tries to access component id %u "
83 "of %u existing components" ),
92 const std::vector<ALTIUM_VERTICE>& aVertices )
101 double startradiant =
DEG2RAD( vertex.startangle );
102 double endradiant =
DEG2RAD( vertex.endangle );
104 -
KiROUND( std::sin( startradiant ) * vertex.radius ) );
107 -
KiROUND( std::sin( endradiant ) * vertex.radius ) );
109 VECTOR2I arcStart = vertex.center + arcStartOffset;
110 VECTOR2I arcEnd = vertex.center + arcEndOffset;
115 if( arcStart.
Distance( vertex.position )
116 < arcEnd.
Distance( vertex.position ) )
143 aLine.
Append( vertex.position );
153 auto override =
m_layermap.find( aAltiumLayer );
157 return override->second;
160 switch( aAltiumLayer )
164 case ALTIUM_LAYER::TOP_LAYER:
return F_Cu;
165 case ALTIUM_LAYER::MID_LAYER_1:
return In1_Cu;
166 case ALTIUM_LAYER::MID_LAYER_2:
return In2_Cu;
167 case ALTIUM_LAYER::MID_LAYER_3:
return In3_Cu;
168 case ALTIUM_LAYER::MID_LAYER_4:
return In4_Cu;
169 case ALTIUM_LAYER::MID_LAYER_5:
return In5_Cu;
170 case ALTIUM_LAYER::MID_LAYER_6:
return In6_Cu;
171 case ALTIUM_LAYER::MID_LAYER_7:
return In7_Cu;
172 case ALTIUM_LAYER::MID_LAYER_8:
return In8_Cu;
173 case ALTIUM_LAYER::MID_LAYER_9:
return In9_Cu;
174 case ALTIUM_LAYER::MID_LAYER_10:
return In10_Cu;
175 case ALTIUM_LAYER::MID_LAYER_11:
return In11_Cu;
176 case ALTIUM_LAYER::MID_LAYER_12:
return In12_Cu;
177 case ALTIUM_LAYER::MID_LAYER_13:
return In13_Cu;
178 case ALTIUM_LAYER::MID_LAYER_14:
return In14_Cu;
179 case ALTIUM_LAYER::MID_LAYER_15:
return In15_Cu;
180 case ALTIUM_LAYER::MID_LAYER_16:
return In16_Cu;
181 case ALTIUM_LAYER::MID_LAYER_17:
return In17_Cu;
182 case ALTIUM_LAYER::MID_LAYER_18:
return In18_Cu;
183 case ALTIUM_LAYER::MID_LAYER_19:
return In19_Cu;
184 case ALTIUM_LAYER::MID_LAYER_20:
return In20_Cu;
185 case ALTIUM_LAYER::MID_LAYER_21:
return In21_Cu;
186 case ALTIUM_LAYER::MID_LAYER_22:
return In22_Cu;
187 case ALTIUM_LAYER::MID_LAYER_23:
return In23_Cu;
188 case ALTIUM_LAYER::MID_LAYER_24:
return In24_Cu;
189 case ALTIUM_LAYER::MID_LAYER_25:
return In25_Cu;
190 case ALTIUM_LAYER::MID_LAYER_26:
return In26_Cu;
191 case ALTIUM_LAYER::MID_LAYER_27:
return In27_Cu;
192 case ALTIUM_LAYER::MID_LAYER_28:
return In28_Cu;
193 case ALTIUM_LAYER::MID_LAYER_29:
return In29_Cu;
194 case ALTIUM_LAYER::MID_LAYER_30:
return In30_Cu;
195 case ALTIUM_LAYER::BOTTOM_LAYER:
return B_Cu;
197 case ALTIUM_LAYER::TOP_OVERLAY:
return F_SilkS;
198 case ALTIUM_LAYER::BOTTOM_OVERLAY:
return B_SilkS;
199 case ALTIUM_LAYER::TOP_PASTE:
return F_Paste;
200 case ALTIUM_LAYER::BOTTOM_PASTE:
return B_Paste;
201 case ALTIUM_LAYER::TOP_SOLDER:
return F_Mask;
202 case ALTIUM_LAYER::BOTTOM_SOLDER:
return B_Mask;
221 case ALTIUM_LAYER::DRILL_GUIDE:
return Dwgs_User;
222 case ALTIUM_LAYER::KEEP_OUT_LAYER:
return Margin;
224 case ALTIUM_LAYER::MECHANICAL_1:
return User_1;
225 case ALTIUM_LAYER::MECHANICAL_2:
return User_2;
226 case ALTIUM_LAYER::MECHANICAL_3:
return User_3;
227 case ALTIUM_LAYER::MECHANICAL_4:
return User_4;
228 case ALTIUM_LAYER::MECHANICAL_5:
return User_5;
229 case ALTIUM_LAYER::MECHANICAL_6:
return User_6;
230 case ALTIUM_LAYER::MECHANICAL_7:
return User_7;
231 case ALTIUM_LAYER::MECHANICAL_8:
return User_8;
232 case ALTIUM_LAYER::MECHANICAL_9:
return User_9;
233 case ALTIUM_LAYER::MECHANICAL_10:
return User_10;
234 case ALTIUM_LAYER::MECHANICAL_11:
return User_11;
235 case ALTIUM_LAYER::MECHANICAL_12:
return F_Fab;
236 case ALTIUM_LAYER::MECHANICAL_13:
return B_Fab;
237 case ALTIUM_LAYER::MECHANICAL_14:
return User_12;
238 case ALTIUM_LAYER::MECHANICAL_15:
return User_13;
239 case ALTIUM_LAYER::MECHANICAL_16:
return User_14;
241 case ALTIUM_LAYER::DRILL_DRAWING:
return Dwgs_User;
259 static std::set<ALTIUM_LAYER> altiumLayersWithWarning;
261 if( aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER || aAltiumLayer == ALTIUM_LAYER::KEEP_OUT_LAYER )
264 std::vector<PCB_LAYER_ID> layers;
265 layers.reserve( layerCount );
270 layers.emplace_back( layer );
281 wxString layerName = it !=
m_layerNames.end() ? it->second : wxString::Format( wxT(
"(%d)" ),
282 (
int) aAltiumLayer );
284 if(
m_reporter && altiumLayersWithWarning.insert( aAltiumLayer ).second )
287 _(
"Altium layer %s has no KiCad equivalent. It has been moved to KiCad "
303 const wxString& aLibrary,
const wxString& aFootprintName )
323 const unsigned PROGRESS_DELTA = 250;
341 const std::map<ALTIUM_PCB_DIR, std::string>& aFileMapping )
344 const std::vector<std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>> parserOrder = {
345 {
true, ALTIUM_PCB_DIR::FILE_HEADER,
350 {
true, ALTIUM_PCB_DIR::BOARD6,
355 {
false, ALTIUM_PCB_DIR::EXTENDPRIMITIVEINFORMATION,
360 {
true, ALTIUM_PCB_DIR::COMPONENTS6,
365 {
false, ALTIUM_PCB_DIR::MODELS,
368 std::vector<std::string> dir{ aFileMapping.at( ALTIUM_PCB_DIR::MODELS ) };
371 {
true, ALTIUM_PCB_DIR::COMPONENTBODIES6,
376 {
true, ALTIUM_PCB_DIR::NETS6,
381 {
true, ALTIUM_PCB_DIR::CLASSES6,
386 {
true, ALTIUM_PCB_DIR::RULES6,
391 {
true, ALTIUM_PCB_DIR::DIMENSIONS6,
396 {
true, ALTIUM_PCB_DIR::POLYGONS6,
401 {
true, ALTIUM_PCB_DIR::ARCS6,
406 {
true, ALTIUM_PCB_DIR::PADS6,
411 {
true, ALTIUM_PCB_DIR::VIAS6,
416 {
true, ALTIUM_PCB_DIR::TRACKS6,
421 {
false, ALTIUM_PCB_DIR::WIDESTRINGS6,
426 {
true, ALTIUM_PCB_DIR::TEXTS6,
431 {
true, ALTIUM_PCB_DIR::FILLS6,
436 {
false, ALTIUM_PCB_DIR::BOARDREGIONS,
441 {
true, ALTIUM_PCB_DIR::SHAPEBASEDREGIONS6,
446 {
true, ALTIUM_PCB_DIR::REGIONS6,
456 for(
const std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>& cur : parserOrder )
461 std::tie( isRequired,
directory, fp ) = cur;
463 if(
directory == ALTIUM_PCB_DIR::FILE_HEADER )
466 const auto& mappedDirectory = aFileMapping.find(
directory );
468 if( mappedDirectory == aFileMapping.end() )
471 const std::vector<std::string> mappedFile{ mappedDirectory->second,
"Header" };
472 const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.
FindStream( mappedFile );
474 if( file ==
nullptr )
478 uint32_t numOfRecords = reader.
Read<uint32_t>();
508 const auto& boardDirectory = aFileMapping.find( ALTIUM_PCB_DIR::BOARD6 );
510 if( boardDirectory != aFileMapping.end() )
512 std::vector<std::string> mappedFile{ boardDirectory->second,
"Data" };
514 const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.
FindStream( mappedFile );
519 "This file does not appear to be in a valid PCB Binary Version 6.0 format. In "
521 "make sure to save as \"PCB Binary Files (*.PcbDoc)\"." ) );
526 for(
const std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>& cur : parserOrder )
531 std::tie( isRequired,
directory, fp ) = cur;
533 const auto& mappedDirectory = aFileMapping.find(
directory );
535 if( mappedDirectory == aFileMapping.end() )
537 wxASSERT_MSG( !isRequired, wxString::Format( wxT(
"Altium Directory of kind %d was "
538 "expected, but no mapping is "
539 "present in the code" ),
544 std::vector<std::string> mappedFile{ mappedDirectory->second };
546 if(
directory != ALTIUM_PCB_DIR::FILE_HEADER )
547 mappedFile.emplace_back(
"Data" );
549 const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.
FindStream( mappedFile );
551 if( file !=
nullptr )
553 fp( altiumPcbFile, file );
555 else if( isRequired )
559 m_reporter->
Report( wxString::Format(
_(
"File not found: '%s' for directory '%s'." ),
574 if( zone->GetAssignedPriority() == 1000 )
585 zone->SetAssignedPriority( priority >= 0 ? priority : 0 );
589 for( std::pair<const ALTIUM_LAYER, ZONE*>& zone :
m_outer_plane )
590 zone.second->SetAssignedPriority( 0 );
600 if( !zone->HasFilledPolysForLayer( layer ) )
603 zone->GetFilledPolysList( layer )->Fracture();
622 if( shape->
GetShape() != SHAPE_T::ARC && shape->
GetShape() != SHAPE_T::CIRCLE )
641 if( arc->
GetCenter() == dim->GetPosition() )
650 VECTOR2I radialLine = dim->GetEnd() - dim->GetStart();
655 radialLine = radialLine.
Resize( std::max(
radius, 2 ) );
656 dim->SetEnd( dim->GetStart() + (
VECTOR2I) radialLine );
657 dim->SetLeaderLength( totalLength -
radius );
667 int desired_x = ( w - bbbox.
GetWidth() ) / 2;
668 int desired_y = ( h - bbbox.
GetHeight() ) / 2;
670 VECTOR2I movementVector( desired_x - bbbox.
GetX(), desired_y - bbbox.
GetY() );
682 const wxString& aFootprintName )
684 std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>(
m_board );
702 std::tuple<wxString, const CFB::COMPOUND_FILE_ENTRY*> ret =
705 wxString fpDirName = std::get<0>( ret );
706 const CFB::COMPOUND_FILE_ENTRY* footprintStream = std::get<1>( ret );
708 if( fpDirName.IsEmpty() )
711 wxString::Format(
_(
"Footprint directory not found: '%s'." ), aFootprintName ) );
714 const std::vector<std::string> streamName{ fpDirName.ToStdString(),
"Data" };
715 const CFB::COMPOUND_FILE_ENTRY* footprintData = altiumLibFile.
FindStream( footprintStream, {
"Data" } );
717 if( footprintData ==
nullptr )
730 footprint->SetFPID( fpID );
732 const std::vector<std::string> parametersStreamName{ fpDirName.ToStdString(),
734 const CFB::COMPOUND_FILE_ENTRY* parametersData =
735 altiumLibFile.
FindStream( footprintStream, {
"Parameters" } );
737 if( parametersData !=
nullptr )
740 std::map<wxString, wxString> parameterProperties = parametersReader.
ReadProperties();
742 wxT(
"DESCRIPTION" ), wxT(
"" ) );
743 footprint->SetLibDescription( description );
754 footprint->SetLibDescription( wxT(
"" ) );
757 const std::vector<std::string> extendedPrimitiveInformationStreamName{
758 "ExtendedPrimitiveInformation",
"Data"
760 const CFB::COMPOUND_FILE_ENTRY* extendedPrimitiveInformationData =
761 altiumLibFile.
FindStream( footprintStream, extendedPrimitiveInformationStreamName );
763 if( extendedPrimitiveInformationData !=
nullptr )
766 footprint->SetReference( wxT(
"REF**" ) );
767 footprint->SetValue( aFootprintName );
768 footprint->Reference().SetVisible(
true );
769 footprint->Value().SetVisible(
true );
774 for(
PCB_FIELD* field : footprint->GetFields() )
776 field->SetTextSize( defaultTextSize );
777 field->SetTextThickness( defaultTextThickness );
786 case ALTIUM_RECORD::ARC:
792 case ALTIUM_RECORD::PAD:
798 case ALTIUM_RECORD::VIA:
804 case ALTIUM_RECORD::TRACK:
810 case ALTIUM_RECORD::TEXT:
816 case ALTIUM_RECORD::FILL:
822 case ALTIUM_RECORD::REGION:
828 case ALTIUM_RECORD::MODEL:
835 THROW_IO_ERROR( wxString::Format(
_(
"Record of unknown type: '%d'." ), recordtype ) );
841 for(
bool changes =
true; changes; )
846 [&changes](
PAD* aPad1,
PAD* aPad2 )
848 if( !( aPad1->GetNumber().IsEmpty() ^ aPad2->GetNumber().IsEmpty() ) )
851 for( PCB_LAYER_ID layer : aPad1->GetLayerSet().Seq() )
853 std::shared_ptr<SHAPE> shape1 = aPad1->GetEffectiveShape( layer );
854 std::shared_ptr<SHAPE> shape2 = aPad2->GetEffectiveShape( layer );
856 if( shape1->Collide( shape2.get() ) )
858 if( aPad1->GetNumber().IsEmpty() )
859 aPad1->SetNumber( aPad2->GetNumber() );
861 aPad2->SetNumber( aPad1->GetNumber() );
870 footprint->AutoPositionFields();
872 if( parser.HasParsingError() )
874 THROW_IO_ERROR( wxString::Format( wxT(
"%s stream was not parsed correctly" ),
878 if( parser.GetRemainingBytes() != 0 )
880 THROW_IO_ERROR( wxString::Format( wxT(
"%s stream is not fully parsed" ),
884 return footprint.release();
895 THROW_IO_ERROR( wxString::Format( wxT(
"Netcode with id %d does not exist. Only %d nets "
907 const auto rules =
m_rules.find( aKind );
912 for(
const ARULE6& rule : rules->second )
914 if( rule.
name == aName )
923 const auto rules =
m_rules.find( aKind );
928 for(
const ARULE6& rule : rules->second )
938 const CFB::COMPOUND_FILE_ENTRY* aEntry )
956 const CFB::COMPOUND_FILE_ENTRY* aEntry )
973 THROW_IO_ERROR( wxT(
"ExtendedPrimitiveInformation stream is not fully parsed" ) );
978 const CFB::COMPOUND_FILE_ENTRY* aEntry )
995 size_t layercount = 0;
996 size_t layerid =
static_cast<size_t>( ALTIUM_LAYER::TOP_LAYER );
998 while( layerid < elem.
stackup.size() && layerid != 0 )
1000 layerid = elem.
stackup[ layerid - 1 ].nextId;
1004 size_t kicadLayercount = ( layercount % 2 == 0 ) ? layercount : layercount + 1;
1014 auto it = stackup.
GetList().begin();
1022 for(
size_t altiumLayerId =
static_cast<size_t>( ALTIUM_LAYER::TOP_LAYER );
1023 altiumLayerId < elem.
stackup.size() && altiumLayerId != 0;
1024 altiumLayerId = elem.
stackup[altiumLayerId - 1].nextId )
1030 if( layer.
nextId == 0 && layercount != kicadLayercount )
1035 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1037 ( *it )->SetThickness( 0 );
1042 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1044 ( *it )->SetThickness( 0, 0 );
1045 ( *it )->SetThicknessLocked(
true, 0 );
1053 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1067 if( klayer ==
B_Cu )
1070 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected id while parsing last stackup layer" ) );
1080 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1094 for(
size_t altiumLayerId =
static_cast<size_t>( ALTIUM_LAYER::TOP_OVERLAY );
1095 altiumLayerId <= static_cast<size_t>( ALTIUM_LAYER::BOTTOM_SOLDER ); altiumLayerId++ )
1106 for(
size_t altiumLayerId =
static_cast<size_t>( ALTIUM_LAYER::MECHANICAL_1 );
1107 altiumLayerId <= static_cast<size_t>( ALTIUM_LAYER::MECHANICAL_16 ); altiumLayerId++ )
1128 if( aStackup.size() == 0 )
1131 std::vector<INPUT_LAYER_DESC> inputLayers;
1132 std::map<wxString, ALTIUM_LAYER> altiumLayerNameMap;
1139 [&](
size_t ii ) ->
size_t
1144 if( layer_num < ALTIUM_LAYER::BOTTOM_LAYER )
1145 return curLayer.
nextId - 1;
1150 for(
size_t ii = 0; ii < aStackup.size(); ii =
next( ii ) )
1152 curLayer = aStackup[ii];
1156 && !( layer_num >= ALTIUM_LAYER::TOP_OVERLAY
1157 && layer_num <= ALTIUM_LAYER::BOTTOM_SOLDER )
1158 && !( layer_num >= ALTIUM_LAYER::MECHANICAL_1
1159 && layer_num <= ALTIUM_LAYER::MECHANICAL_16 ) )
1161 if( layer_num < ALTIUM_LAYER::BOTTOM_LAYER )
1175 inputLayers.push_back( iLdesc );
1176 altiumLayerNameMap.insert( { curLayer.
name, layer_num } );
1180 if( inputLayers.size() == 0 )
1187 for( std::pair<wxString, PCB_LAYER_ID> layerPair : reMappedLayers )
1189 if( layerPair.second == PCB_LAYER_ID::UNDEFINED_LAYER )
1191 wxFAIL_MSG( wxT(
"Unexpected Layer ID" ) );
1195 ALTIUM_LAYER altiumID = altiumLayerNameMap.at( layerPair.first );
1196 m_layermap.insert_or_assign( altiumID, layerPair.second );
1197 enabledLayers |=
LSET( { layerPair.second } );
1211 LINE_STYLE::SOLID );
1218 int nextShape = lineChain.
NextShape( i );
1219 bool isLastShape = nextShape < 0;
1221 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::ARC );
1223 shape->SetStroke( stroke );
1227 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1233 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1235 shape->SetStroke( stroke );
1237 shape->SetStart( seg.
A );
1238 shape->SetEnd( seg.
B );
1240 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1247 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1259 if( elem.
kind == ALTIUM_CLASS_KIND::NET_CLASS )
1261 std::shared_ptr<NETCLASS> nc = std::make_shared<NETCLASS>( elem.
name );
1263 for(
const wxString&
name : elem.
names )
1266 name, nc->GetName() );
1276 msg.Printf(
_(
"More than one Altium netclass with name '%s' found. "
1277 "Only the first one will be imported." ), elem.
name );
1296 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1303 uint16_t componentId = 0;
1310 std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>(
m_board );
1320 footprint->SetFPID( fpID );
1322 footprint->SetPosition( elem.
position );
1323 footprint->SetOrientationDegrees( elem.
rotation );
1329 if( reference.find_first_not_of(
"0123456789" ) == wxString::npos )
1330 reference.Prepend( wxT(
"UNK" ) );
1332 footprint->SetReference( reference );
1337 path.push_back( pathid );
1338 path.push_back(
id );
1340 footprint->SetPath(
path );
1344 footprint->SetLocked( elem.
locked );
1345 footprint->Reference().SetVisible( elem.
nameon );
1346 footprint->Value().SetVisible( elem.
commenton );
1347 footprint->SetLayer( elem.
layer == ALTIUM_LAYER::TOP_LAYER ?
F_Cu :
B_Cu );
1350 m_board->
Add( footprint.release(), ADD_MODE::APPEND );
1356 THROW_IO_ERROR( wxT(
"Components6 stream is not fully parsed" ) );
1363 while( Angle < aMin )
1366 while( Angle >= aMax )
1389 m_reporter->
Report( wxString::Format( wxT(
"Model %s not found for footprint %s" ),
1402 if( file->
name.IsEmpty() )
1403 file->
name = model->first.name;
1406 std::vector<char> decompressedData;
1407 wxMemoryInputStream compressedStream( model->second.data(), model->second.size() );
1408 wxZlibInputStream zlibStream( compressedStream );
1412 decompressedData.resize( model->second.size() * 6 );
1415 while( !zlibStream.Eof() )
1417 zlibStream.Read( decompressedData.data() + offset, decompressedData.size() - offset );
1418 size_t bytesRead = zlibStream.LastRead();
1423 offset += bytesRead;
1425 if( offset >= decompressedData.size() )
1426 decompressedData.resize( 2 * decompressedData.size() );
1429 decompressedData.resize( offset );
1450 orientation = -orientation;
1462 aFootprint->
Models().push_back( modelSettings );
1467 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1484 THROW_IO_ERROR( wxString::Format( wxT(
"ComponentsBodies6 stream tries to access "
1485 "component id %d of %zu existing components" ),
1500 msg.Printf( wxT(
"ComponentsBodies6 stream tries to access model id %s which does "
1501 "not exist" ), elem.
modelId );
1514 wxMemoryInputStream compressedStream( modelData.
m_data.data(), modelData.
m_data.size() );
1515 wxZlibInputStream zlibStream( compressedStream );
1516 wxMemoryOutputStream decompressedStream;
1518 zlibStream.Read( decompressedStream );
1541 orientation = -orientation;
1554 footprint->
Models().push_back( modelSettings );
1558 THROW_IO_ERROR( wxT(
"ComponentsBodies6 stream is not fully parsed" ) );
1565 THROW_IO_ERROR( wxT(
"Incorrect number of reference points for linear dimension object" ) );
1574 _(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1575 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer ),
1588 dimension->SetLayer( klayer );
1589 dimension->SetStart( referencePoint0 );
1591 if( referencePoint0 != aElem.
xy1 )
1604 SEG segm1( referencePoint0, referencePoint0 + directionNormalVector );
1605 SEG segm2( referencePoint1, referencePoint1 + direction );
1609 THROW_IO_ERROR( wxT(
"Invalid dimension. This should never happen." ) );
1611 dimension->SetEnd( *intersection );
1615 if( ( direction.
x > 0 || direction.
y < 0 ) != ( aElem.
angle >= 180.0 ) )
1618 dimension->SetHeight( height );
1622 dimension->SetEnd( referencePoint1 );
1625 dimension->SetLineThickness( aElem.
linewidth );
1627 dimension->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
1631 wxRegEx units( wxS(
"(mm)|(in)|(mils)|(thou)|(')|(\")" ), wxRE_ADVANCED );
1634 dimension->SetUnitsFormat( DIM_UNITS_FORMAT::BARE_SUFFIX );
1643 dimension->Text().SetBold( aElem.
textbold );
1646 dimension->SetTextThickness( dimension->GetTextThickness() *
BOLD_FACTOR );
1651 case ALTIUM_UNIT::INCH: dimension->SetUnits( EDA_UNITS::INCH );
break;
1652 case ALTIUM_UNIT::MILS: dimension->SetUnits( EDA_UNITS::MILS );
break;
1653 case ALTIUM_UNIT::MM: dimension->SetUnits( EDA_UNITS::MM );
break;
1654 case ALTIUM_UNIT::CM: dimension->SetUnits( EDA_UNITS::MM );
break;
1658 m_board->
Add( dimension.release(), ADD_MODE::APPEND );
1665 THROW_IO_ERROR( wxT(
"Not enough reference points for radial dimension object" ) );
1674 _(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1675 "It has been moved to KiCad layer Eco1_User." ),
1685 std::unique_ptr<PCB_DIM_RADIAL> dimension = std::make_unique<PCB_DIM_RADIAL>(
m_board );
1688 dimension->SetLayer( klayer );
1689 dimension->SetStart( referencePoint0 );
1690 dimension->SetEnd( aElem.
xy1 );
1691 dimension->SetLineThickness( aElem.
linewidth );
1692 dimension->SetKeepTextAligned(
false );
1697 dimension->SetUnitsFormat( aElem.
textsuffix.IsEmpty() ? DIM_UNITS_FORMAT::NO_SUFFIX
1698 : DIM_UNITS_FORMAT::BARE_SUFFIX );
1702 case ALTIUM_UNIT::INCH: dimension->SetUnits( EDA_UNITS::INCH );
break;
1703 case ALTIUM_UNIT::MILS: dimension->SetUnits( EDA_UNITS::MILS );
break;
1704 case ALTIUM_UNIT::MM: dimension->SetUnits( EDA_UNITS::MM );
break;
1705 case ALTIUM_UNIT::CM: dimension->SetUnits( EDA_UNITS::MM );
break;
1713 m_reporter->
Report( wxT(
"No text position present for leader dimension object" ),
1720 dimension->SetTextPos( aElem.
textPoint.at( 0 ) );
1726 dimension->SetBold( aElem.
textbold );
1729 dimension->SetTextThickness( dimension->GetTextThickness() *
BOLD_FACTOR );
1737 int yAdjust = dimension->GetTextBox().GetCenter().y - dimension->GetTextPos().y;
1738 dimension->SetTextPos( dimension->GetTextPos() +
VECTOR2I( 0, yAdjust + aElem.
textgap ) );
1742 m_board->
Add( dimension.release(), ADD_MODE::APPEND );
1755 msg.Printf(
_(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1756 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
1771 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1773 shape->SetLayer( klayer );
1775 shape->SetStart( last );
1779 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1787 if( dirVec.
x != 0 || dirVec.
y != 0 )
1795 std::unique_ptr<PCB_SHAPE> shape1 =
1796 std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1798 shape1->SetLayer( klayer );
1800 shape1->SetStart( referencePoint0 );
1801 shape1->SetEnd( referencePoint0 + arrVec );
1803 m_board->
Add( shape1.release(), ADD_MODE::APPEND );
1809 std::unique_ptr<PCB_SHAPE> shape2 =
1810 std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1812 shape2->SetLayer( klayer );
1814 shape2->SetStart( referencePoint0 );
1815 shape2->SetEnd( referencePoint0 + arrVec );
1817 m_board->
Add( shape2.release(), ADD_MODE::APPEND );
1827 m_reporter->
Report( wxT(
"No text position present for leader dimension object" ),
1834 std::unique_ptr<PCB_TEXT>
text = std::make_unique<PCB_TEXT>(
m_board );
1838 text->SetLayer( klayer );
1857 msg.Printf(
_(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1858 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
1867 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1869 shape->SetLayer( klayer );
1874 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1888 msg.Printf(
_(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1889 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
1899 std::unique_ptr<PCB_DIM_CENTER> dimension = std::make_unique<PCB_DIM_CENTER>(
m_board );
1901 dimension->SetLayer( klayer );
1902 dimension->SetLineThickness( aElem.
linewidth );
1903 dimension->SetStart( aElem.
xy1 );
1904 dimension->SetEnd( aElem.
xy1 + vec );
1906 m_board->
Add( dimension.release(), ADD_MODE::APPEND );
1911 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1925 case ALTIUM_DIMENSION_KIND::LINEAR:
1928 case ALTIUM_DIMENSION_KIND::ANGULAR:
1932 wxString::Format(
_(
"Ignored Angular dimension (not yet supported)." ) ),
1936 case ALTIUM_DIMENSION_KIND::RADIAL:
1939 case ALTIUM_DIMENSION_KIND::LEADER:
1942 case ALTIUM_DIMENSION_KIND::DATUM:
1946 wxString::Format(
_(
"Ignored Datum dimension (not yet supported)." ) ),
1951 case ALTIUM_DIMENSION_KIND::BASELINE:
1955 wxString::Format(
_(
"Ignored Baseline dimension (not yet supported)." ) ),
1959 case ALTIUM_DIMENSION_KIND::CENTER:
1962 case ALTIUM_DIMENSION_KIND::LINEAR_DIAMETER:
1966 wxString::Format(
_(
"Ignored Linear dimension (not yet supported)." ) ),
1970 case ALTIUM_DIMENSION_KIND::RADIAL_DIAMETER:
1974 wxString::Format(
_(
"Ignored Radial dimension (not yet supported)." ) ),
1982 msg.Printf(
_(
"Ignored dimension of kind %d (not yet supported)." ), elem.
kind );
1990 THROW_IO_ERROR( wxT(
"Dimensions6 stream is not fully parsed" ) );
1995 const CFB::COMPOUND_FILE_ENTRY* aEntry,
1996 const std::vector<std::string>& aRootDir )
2007 wxString invalidChars = wxFileName::GetForbiddenChars();
2014 std::vector<std::string> stepPath = aRootDir;
2015 stepPath.emplace_back( std::to_string( idx ) );
2017 bool validName = !elem.
name.IsEmpty() && elem.
name.IsAscii() &&
2018 wxString::npos == elem.
name.find_first_of( invalidChars );
2019 wxString storageName = !validName ? wxString::Format( wxT(
"model_%d" ), idx )
2024 const CFB::COMPOUND_FILE_ENTRY* stepEntry = aAltiumPcbFile.
FindStream( stepPath );
2026 if( stepEntry ==
nullptr )
2031 msg.Printf(
_(
"File not found: '%s'. 3D-model not imported." ),
2039 size_t stepSize =
static_cast<size_t>( stepEntry->size );
2040 std::vector<char> stepContent( stepSize );
2048 std::move( stepContent ) ) ) );
2052 std::map<wxString, std::vector<wxString>> nameIdMap;
2055 nameIdMap[data.m_modelname].push_back(
id );
2057 for(
auto& [
name, ids] : nameIdMap )
2059 for(
size_t i = 1; i < ids.size(); i++ )
2061 const wxString&
id = ids[i];
2068 wxString modelName = modelTuple->second.m_modelname;
2070 if( modelName.Contains(
"." ) )
2073 wxString baseName = modelName.BeforeLast(
'.', &ext );
2075 modelTuple->second.m_modelname = baseName +
'_' + std::to_string( i ) +
'.' + ext;
2079 modelTuple->second.m_modelname = modelName +
'_' + std::to_string( i );
2090 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2102 ANET6 elem( reader );
2116 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2149 if( elem.
hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::SOLID )
2159 msg.Printf(
_(
"Polygon outline count is %d, expected 1." ), outline.
OutlineCount() );
2167 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(
m_board);
2173 zone->SetPosition( elem.
vertices.at( 0 ).position );
2174 zone->SetLocked( elem.
locked );
2176 zone->Outline()->AddOutline( outline.
Outline( 0 ) );
2182 const ARULE6* zoneClearanceRule =
GetRule( ALTIUM_RULE_KIND::CLEARANCE,
2183 wxT(
"PolygonClearance" ) );
2184 int planeLayers = 0;
2185 int signalLayers = 0;
2199 if( planeLayers > 0 && planeClearanceRule )
2202 if( signalLayers > 0 && zoneClearanceRule )
2210 if( polygonConnectRule !=
nullptr )
2214 case ALTIUM_CONNECT_STYLE::DIRECT:
2215 zone->SetPadConnection( ZONE_CONNECTION::FULL );
2218 case ALTIUM_CONNECT_STYLE::NONE:
2219 zone->SetPadConnection( ZONE_CONNECTION::NONE );
2223 case ALTIUM_CONNECT_STYLE::RELIEF:
2224 zone->SetPadConnection( ZONE_CONNECTION::THERMAL );
2229 zone->SetThermalReliefSpokeWidth(
2240 zone->SetAssignedPriority( 1 );
2245 || zone->GetBoundingBox().Contains( outer_plane->second->GetBoundingBox() ) )
2251 if( elem.
hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::SOLID
2252 && elem.
hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::UNKNOWN )
2254 zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
2257 if( elem.
hatchstyle == ALTIUM_POLYGON_HATCHSTYLE::NONE )
2260 const BOX2I& bbox = zone->GetBoundingBox();
2268 if( elem.
hatchstyle == ALTIUM_POLYGON_HATCHSTYLE::DEGREE_45 )
2269 zone->SetHatchOrientation(
ANGLE_45 );
2272 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
2276 m_board->
Add( zone.release(), ADD_MODE::APPEND );
2284 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2302 std::sort( val.second.begin(), val.second.end(),
2305 return lhs.priority < rhs.priority;
2318 if( trackWidthRule )
2324 if( routingViasRule )
2335 if( holeToHoleRule )
2341 if( soldermaskRule )
2352 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2368 THROW_IO_ERROR( wxT(
"BoardRegions stream is not fully parsed" ) );
2372 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2380 for(
int primitiveIndex = 0; reader.
GetRemainingBytes() >= 4; primitiveIndex++ )
2386 || elem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2399 THROW_IO_ERROR(
"ShapeBasedRegions6 stream is not fully parsed" );
2405 if( aElem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2409 else if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT || aElem.
is_keepout )
2423 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(
m_board );
2425 zone->SetIsRuleArea(
true );
2431 else if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT )
2433 zone->SetDoNotAllowZoneFills(
true );
2434 zone->SetDoNotAllowVias(
false );
2435 zone->SetDoNotAllowTracks(
false );
2436 zone->SetDoNotAllowPads(
false );
2437 zone->SetDoNotAllowFootprints(
false );
2440 zone->SetPosition( aElem.
outline.at( 0 ).position );
2441 zone->Outline()->AddOutline( linechain );
2445 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
2448 m_board->
Add( zone.release(), ADD_MODE::APPEND );
2450 else if( aElem.
kind == ALTIUM_REGION_KIND::DASHED_OUTLINE )
2459 msg.Printf(
_(
"Dashed outline found on an Altium layer (%d) with no KiCad equivalent. "
2460 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
2479 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::POLY );
2481 shape->SetPolyShape( linechain );
2482 shape->SetFilled(
false );
2483 shape->SetLayer( klayer );
2486 m_board->
Add( shape.release(), ADD_MODE::APPEND );
2488 else if( aElem.
kind == ALTIUM_REGION_KIND::COPPER )
2496 else if( aElem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2505 msg.Printf(
_(
"Ignored polygon shape of kind %d (not yet supported)." ), aElem.
kind );
2514 const int aPrimitiveIndex )
2516 if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT || aElem.
is_keepout )
2530 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( aFootprint );
2532 zone->SetIsRuleArea(
true );
2538 else if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT )
2540 zone->SetDoNotAllowZoneFills(
true );
2541 zone->SetDoNotAllowVias(
false );
2542 zone->SetDoNotAllowTracks(
false );
2543 zone->SetDoNotAllowPads(
false );
2544 zone->SetDoNotAllowFootprints(
false );
2547 zone->SetPosition( aElem.
outline.at( 0 ).position );
2548 zone->Outline()->AddOutline( linechain );
2552 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
2555 aFootprint->
Add( zone.release(), ADD_MODE::APPEND );
2557 else if( aElem.
kind == ALTIUM_REGION_KIND::COPPER )
2568 else if( aElem.
kind == ALTIUM_REGION_KIND::DASHED_OUTLINE
2569 || aElem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2582 msg.Printf(
_(
"Loading library '%s':\n"
2583 "Footprint %s contains a dashed outline on Altium layer (%d) with "
2584 "no KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
2596 msg.Printf(
_(
"Footprint %s contains a dashed outline on Altium layer (%d) with "
2597 "no KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
2619 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::POLY );
2621 shape->SetPolyShape( linechain );
2622 shape->SetFilled(
false );
2623 shape->SetLayer( klayer );
2625 if( aElem.
kind == ALTIUM_REGION_KIND::DASHED_OUTLINE )
2630 aFootprint->
Add( shape.release(), ADD_MODE::APPEND );
2639 msg.Printf(
_(
"Error loading library '%s':\n"
2640 "Footprint %s contains polygon shape of kind %d (not yet supported)." ),
2652 msg.Printf(
_(
"Footprint %s contains polygon shape of kind %d (not yet supported)." ),
2680 for(
const std::vector<ALTIUM_VERTICE>& hole : aElem.
holes )
2688 polySet.
AddHole( hole_linechain );
2691 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::POLY );
2693 shape->SetPolyShape( polySet );
2694 shape->SetFilled(
true );
2695 shape->SetLayer( aLayer );
2703 m_board->
Add( shape.release(), ADD_MODE::APPEND );
2710 const int aPrimitiveIndex )
2727 for(
const std::vector<ALTIUM_VERTICE>& hole : aElem.
holes )
2735 polySet.
AddHole( hole_linechain );
2738 if( aLayer ==
F_Cu || aLayer ==
B_Cu )
2741 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
2744 padLayers.
set( aLayer );
2746 pad->SetAttribute( PAD_ATTRIB::SMD );
2755 pad->SetPosition( anchorPos );
2758 shapePolys.
Move( -anchorPos );
2762 auto it = map.find( aPrimitiveIndex );
2764 if( it != map.end() )
2768 if(
info.pastemaskexpansionmode == ALTIUM_MODE::MANUAL )
2770 pad->SetLocalSolderPasteMargin(
2771 info.pastemaskexpansionmanual ?
info.pastemaskexpansionmanual : 1 );
2774 if(
info.soldermaskexpansionmode == ALTIUM_MODE::MANUAL )
2776 pad->SetLocalSolderMaskMargin(
2777 info.soldermaskexpansionmanual ?
info.soldermaskexpansionmanual : 1 );
2780 if(
info.pastemaskexpansionmode != ALTIUM_MODE::NONE )
2783 if(
info.soldermaskexpansionmode != ALTIUM_MODE::NONE )
2787 pad->SetLayerSet( padLayers );
2789 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
2793 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::POLY );
2795 shape->SetPolyShape( polySet );
2796 shape->SetFilled(
true );
2797 shape->SetLayer( aLayer );
2800 aFootprint->
Add( shape.release(), ADD_MODE::APPEND );
2806 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2822 THROW_IO_ERROR( wxString::Format(
"Region stream tries to access polygon id %d "
2823 "of %d existing polygons.",
2830 if( zone ==
nullptr )
2852 for(
const std::vector<ALTIUM_VERTICE>& hole : elem.
holes )
2859 hole_linechain.
Append( hole.at( 0 ).position );
2861 fill.
AddHole( hole_linechain );
2881 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2888 for(
int primitiveIndex = 0; reader.
GetRemainingBytes() >= 4; primitiveIndex++ )
2891 AARC6 elem( reader );
2913 aShape->
SetShape( SHAPE_T::CIRCLE );
2942 THROW_IO_ERROR( wxString::Format(
"Tracks stream tries to access polygon id %u "
2943 "of %zu existing polygons.",
2949 if( zone ==
nullptr )
2997 for(
const auto& layerExpansionMask :
3000 int width = aElem.
width + ( layerExpansionMask.second * 2 );
3004 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>(
m_board );
3007 arc->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
3008 arc->SetLayer( layerExpansionMask.first );
3010 m_board->
Add( arc.release(), ADD_MODE::APPEND );
3017 const int aPrimitiveIndex,
const bool aIsBoardImport )
3021 wxFAIL_MSG( wxString::Format(
"Altium: Unexpected footprint Arc with polygon id %d",
3054 for(
const auto& layerExpansionMask :
3057 int width = aElem.
width + ( layerExpansionMask.second * 2 );
3061 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( aFootprint );
3064 arc->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
3065 arc->SetLayer( layerExpansionMask.first );
3067 aFootprint->
Add( arc.release(), ADD_MODE::APPEND );
3088 PCB_SHAPE shape(
nullptr, SHAPE_T::ARC );
3097 std::unique_ptr<PCB_ARC> arc = std::make_unique<PCB_ARC>(
m_board, &shapeArc );
3099 arc->SetWidth( aElem.
width );
3100 arc->SetLayer( aLayer );
3103 m_board->
Add( arc.release(), ADD_MODE::APPEND );
3108 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>(
m_board);
3112 arc->SetLayer( aLayer );
3114 m_board->
Add( arc.release(), ADD_MODE::APPEND );
3122 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( aFootprint );
3126 arc->SetLayer( aLayer );
3128 aFootprint->
Add( arc.release(), ADD_MODE::APPEND );
3133 const CFB::COMPOUND_FILE_ENTRY* aEntry )
3143 APAD6 elem( reader );
3165 && aElem.
layer != ALTIUM_LAYER::MULTI_LAYER )
3172 std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>(
m_board );
3173 footprint->SetPosition( aElem.
position );
3177 m_board->
Add( footprint.release(), ADD_MODE::APPEND );
3184 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
3186 pad->SetNumber(
"" );
3192 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3194 pad->SetAttribute( PAD_ATTRIB::PTH );
3197 pad->SetLayerSet(
LSET().AllCuMask() );
3199 if( aElem.
viamode == ALTIUM_PAD_MODE::SIMPLE )
3203 else if( aElem.
viamode == ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM )
3224 pad->Padstack().FrontOuterLayers().has_solder_mask =
true;
3228 pad->Padstack().FrontOuterLayers().has_solder_mask =
false;
3234 pad->Padstack().BackOuterLayers().has_solder_mask =
true;
3238 pad->Padstack().BackOuterLayers().has_solder_mask =
false;
3243 pad->SetLocked(
true );
3252 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
3260 && aElem.
layer != ALTIUM_LAYER::MULTI_LAYER )
3273 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
3284 pad->SetAttribute( PAD_ATTRIB::SMD );
3288 if( aElem.
layer != ALTIUM_LAYER::MULTI_LAYER )
3296 msg.Printf(
_(
"Error loading library '%s':\n"
3297 "Footprint %s pad %s is not marked as multilayer, but is a TH pad." ),
3309 msg.Printf(
_(
"Footprint %s pad %s is not marked as multilayer, but is a TH pad." ),
3317 pad->SetAttribute( aElem.
plated ? PAD_ATTRIB::PTH : PAD_ATTRIB::NPTH );
3321 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3328 case ALTIUM_PAD_HOLE_SHAPE::ROUND:
3329 wxFAIL_MSG( wxT(
"Round holes are handled before the switch" ) );
3332 case ALTIUM_PAD_HOLE_SHAPE::SQUARE:
3338 msg.Printf(
_(
"Loading library '%s':\n"
3339 "Footprint %s pad %s has a square hole (not yet supported)." ),
3351 msg.Printf(
_(
"Footprint %s pad %s has a square hole (not yet supported)." ),
3358 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3364 case ALTIUM_PAD_HOLE_SHAPE::SLOT:
3366 pad->SetDrillShape( PAD_DRILL_SHAPE::OBLONG );
3386 msg.Printf(
_(
"Loading library '%s':\n"
3387 "Footprint %s pad %s has a hole-rotation of %f degrees. "
3388 "KiCad only supports 90 degree rotations." ),
3401 msg.Printf(
_(
"Footprint %s pad %s has a hole-rotation of %f degrees. "
3402 "KiCad only supports 90 degree rotations." ),
3415 case ALTIUM_PAD_HOLE_SHAPE::UNKNOWN:
3421 msg.Printf(
_(
"Error loading library '%s':\n"
3422 "Footprint %s pad %s uses a hole of unknown kind %d." ),
3435 msg.Printf(
_(
"Footprint %s pad %s uses a hole of unknown kind %d." ),
3443 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3455 auto setCopperGeometry =
3464 case ALTIUM_PAD_SHAPE::RECT:
3465 ps.
SetShape( PAD_SHAPE::RECTANGLE, aLayer );
3468 case ALTIUM_PAD_SHAPE::CIRCLE:
3470 && aElem.
sizeAndShape->alt_shape[altLayer] == ALTIUM_PAD_SHAPE_ALT::ROUNDRECT )
3472 ps.
SetShape( PAD_SHAPE::ROUNDRECT, aLayer );
3473 double ratio = aElem.
sizeAndShape->cornerradius[altLayer] / 200.;
3478 ps.
SetShape( PAD_SHAPE::CIRCLE, aLayer );
3482 ps.
SetShape( PAD_SHAPE::OVAL, aLayer );
3487 case ALTIUM_PAD_SHAPE::OCTAGONAL:
3488 ps.
SetShape( PAD_SHAPE::CHAMFERED_RECT, aLayer );
3493 case ALTIUM_PAD_SHAPE::UNKNOWN:
3500 msg.Printf(
_(
"Error loading library '%s':\n"
3501 "Footprint %s pad %s uses an unknown pad-shape." ),
3513 msg.Printf(
_(
"Footprint %s pad %s uses an unknown pad-shape." ),
3525 case ALTIUM_PAD_MODE::SIMPLE:
3530 case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
3537 case ALTIUM_PAD_MODE::FULL_STACK:
3554 setCopperGeometry( layer, aElem.
sizeAndShape->inner_shape[i],
3564 switch( aElem.
layer )
3566 case ALTIUM_LAYER::TOP_LAYER:
3571 case ALTIUM_LAYER::BOTTOM_LAYER:
3576 case ALTIUM_LAYER::MULTI_LAYER:
3582 pad->SetLayer( klayer );
3583 pad->SetLayerSet(
LSET( { klayer } ) );
3594 pad->SetLayerSet(
pad->GetLayerSet().reset(
F_Mask ) );
3597 pad->SetLayerSet(
pad->GetLayerSet().reset(
B_Mask ) );
3599 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
3612 msg.Printf(
_(
"Non-copper pad %s found on an Altium layer (%d) with no KiCad "
3613 "equivalent. It has been moved to KiCad layer Eco1_User." ),
3621 std::unique_ptr<PCB_SHAPE>
pad = std::make_unique<PCB_SHAPE>(
m_board );
3640 msg.Printf(
_(
"Loading library '%s':\n"
3641 "Footprint %s non-copper pad %s found on an Altium layer (%d) with no "
3642 "KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
3655 msg.Printf(
_(
"Footprint %s non-copper pad %s found on an Altium layer (%d) with no "
3656 "KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
3667 std::unique_ptr<PCB_SHAPE>
pad = std::make_unique<PCB_SHAPE>( aFootprint );
3671 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
3683 msg.Printf(
_(
"Non-copper pad %s is connected to a net, which is not supported." ),
3694 msg.Printf(
_(
"Non-copper pad %s has a hole, which is not supported." ), aElem.
name );
3699 if( aElem.
padmode != ALTIUM_PAD_MODE::SIMPLE )
3704 msg.Printf(
_(
"Non-copper pad %s has a complex pad stack (not yet supported)." ),
3712 case ALTIUM_PAD_SHAPE::RECT:
3731 case ALTIUM_PAD_SHAPE::CIRCLE:
3733 && aElem.
sizeAndShape->alt_shape[0] == ALTIUM_PAD_SHAPE_ALT::ROUNDRECT )
3736 int cornerradius = aElem.
sizeAndShape->cornerradius[0];
3737 int offset = ( std::min( aElem.
topsize.
x, aElem.
topsize.
y ) * cornerradius ) / 200;
3742 if( cornerradius < 100 )
3744 int offsetX = aElem.
topsize.
x / 2 - offset;
3745 int offsetY = aElem.
topsize.
y / 2 - offset;
3759 aShape->
SetShape( SHAPE_T::CIRCLE );
3768 aShape->
SetShape( SHAPE_T::SEGMENT );
3776 aShape->
SetShape( SHAPE_T::SEGMENT );
3788 aShape->
SetShape( SHAPE_T::CIRCLE );
3798 aShape->
SetShape( SHAPE_T::SEGMENT );
3801 LINE_STYLE::SOLID ) );
3821 case ALTIUM_PAD_SHAPE::OCTAGONAL:
3838 aShape->
SetPolyPoints( { p11 - chamferX, p11 - chamferY, p12 + chamferY, p12 - chamferX,
3839 p22 + chamferX, p22 + chamferY, p21 - chamferY, p21 + chamferX } );
3846 case ALTIUM_PAD_SHAPE::UNKNOWN:
3851 msg.Printf(
_(
"Non-copper pad %s uses an unknown pad-shape." ), aElem.
name );
3861 const CFB::COMPOUND_FILE_ENTRY* aEntry )
3871 AVIA6 elem( reader );
3873 std::unique_ptr<PCB_VIA>
via = std::make_unique<PCB_VIA>(
m_board );
3880 bool start_layer_outside = elem.
layer_start == ALTIUM_LAYER::TOP_LAYER
3881 || elem.
layer_start == ALTIUM_LAYER::BOTTOM_LAYER;
3882 bool end_layer_outside = elem.
layer_end == ALTIUM_LAYER::TOP_LAYER
3883 || elem.
layer_end == ALTIUM_LAYER::BOTTOM_LAYER;
3885 if( start_layer_outside && end_layer_outside )
3887 via->SetViaType( VIATYPE::THROUGH );
3889 else if( ( !start_layer_outside ) || ( !end_layer_outside ) )
3891 via->SetViaType( VIATYPE::BLIND_BURIED );
3897 via->SetViaType( VIATYPE::MICROVIA );
3908 msg.Printf(
_(
"Via from layer %d to %d uses a non-copper layer, which is not "
3919 via->SetLayerPair( start_klayer, end_klayer );
3924 case ALTIUM_PAD_MODE::SIMPLE:
3928 case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
3935 case ALTIUM_PAD_MODE::FULL_STACK:
3942 wxCHECK2_MSG( altiumLayer < 32,
break,
3943 "Altium importer expects 32 or fewer copper layers" );
3954 via->SetFrontTentingMode( elem.
is_tent_top ? TENTING_MODE::TENTED
3955 : TENTING_MODE::NOT_TENTED );
3957 : TENTING_MODE::NOT_TENTED );
3968 const CFB::COMPOUND_FILE_ENTRY* aEntry )
3975 for(
int primitiveIndex = 0; reader.
GetRemainingBytes() >= 4; primitiveIndex++ )
4006 msg.Printf( wxT(
"ATRACK6 stream tries to access polygon id %u "
4007 "of %u existing polygons; skipping it" ),
4008 static_cast<unsigned>( aElem.
polygon ),
4009 static_cast<unsigned>(
m_polygons.size() ) );
4018 if( zone ==
nullptr )
4034 PCB_SHAPE shape(
nullptr, SHAPE_T::SEGMENT );
4052 PCB_SHAPE shape(
nullptr, SHAPE_T::SEGMENT );
4066 ALTIUM_RECORD::TRACK, aPrimitiveIndex, aElem.
layer ) )
4068 int width = aElem.
width + ( layerExpansionMask.second * 2 );
4071 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
4073 seg->SetStart( aElem.
start );
4074 seg->SetEnd( aElem.
end );
4075 seg->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
4076 seg->SetLayer( layerExpansionMask.first );
4078 m_board->
Add( seg.release(), ADD_MODE::APPEND );
4085 const int aPrimitiveIndex,
4086 const bool aIsBoardImport )
4090 wxFAIL_MSG( wxString::Format(
"Altium: Unexpected footprint Track with polygon id %u",
4099 PCB_SHAPE shape(
nullptr, SHAPE_T::SEGMENT );
4124 ALTIUM_RECORD::TRACK, aPrimitiveIndex, aElem.
layer ) )
4126 int width = aElem.
width + ( layerExpansionMask.second * 2 );
4129 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::SEGMENT );
4131 seg->SetStart( aElem.
start );
4132 seg->SetEnd( aElem.
end );
4133 seg->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
4134 seg->SetLayer( layerExpansionMask.first );
4136 aFootprint->
Add( seg.release(), ADD_MODE::APPEND );
4146 std::unique_ptr<PCB_TRACK> track = std::make_unique<PCB_TRACK>(
m_board );
4148 track->SetStart( aElem.
start );
4149 track->SetEnd( aElem.
end );
4150 track->SetWidth( aElem.
width );
4151 track->SetLayer( aLayer );
4154 m_board->
Add( track.release(), ADD_MODE::APPEND );
4158 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
4160 seg->SetStart( aElem.
start );
4161 seg->SetEnd( aElem.
end );
4163 seg->SetLayer( aLayer );
4165 m_board->
Add( seg.release(), ADD_MODE::APPEND );
4173 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::SEGMENT );
4175 seg->SetStart( aElem.
start );
4176 seg->SetEnd( aElem.
end );
4178 seg->SetLayer( aLayer );
4180 aFootprint->
Add( seg.release(), ADD_MODE::APPEND );
4185 const CFB::COMPOUND_FILE_ENTRY* aEntry )
4195 THROW_IO_ERROR( wxT(
"WideStrings6 stream is not fully parsed" ) );
4199 const CFB::COMPOUND_FILE_ENTRY* aEntry )
4229 if( aElem.
fonttype == ALTIUM_TEXT_TYPE::BARCODE )
4234 msg.Printf(
_(
"Ignored barcode on Altium layer %d (not yet supported)." ),
4249 if( aElem.
fonttype == ALTIUM_TEXT_TYPE::BARCODE )
4256 msg.Printf(
_(
"Error loading library '%s':\n"
4257 "Footprint %s contains barcode on Altium layer %d (not yet supported)." ),
4269 msg.Printf(
_(
"Footprint %s contains barcode on Altium layer %d (not yet supported)." ),
4286 std::unique_ptr<PCB_TEXTBOX> pcbTextbox = std::make_unique<PCB_TEXTBOX>(
m_board );
4287 std::unique_ptr<PCB_TEXT> pcbText = std::make_unique<PCB_TEXT>(
m_board );
4291 static const std::map<wxString, wxString> variableMap = {
4292 {
"LAYER_NAME",
"LAYER" },
4293 {
"PRINT_DATE",
"CURRENT_DATE"},
4303 item = pcbTextbox.get();
4304 text = pcbTextbox.get();
4315 text->SetText( kicadText );
4320 m_board->
Add( pcbTextbox.release(), ADD_MODE::APPEND );
4322 m_board->
Add( pcbText.release(), ADD_MODE::APPEND );
4329 std::unique_ptr<PCB_TEXTBOX> fpTextbox = std::make_unique<PCB_TEXTBOX>( aFootprint );
4330 std::unique_ptr<PCB_TEXT> fpText = std::make_unique<PCB_TEXT>( aFootprint );
4347 item = &aFootprint->
Value();
4349 field = &aFootprint->
Value();
4353 item = fpText.get();
4354 text = fpText.get();
4358 static const std::map<wxString, wxString> variableMap = {
4359 {
"DESIGNATOR",
"REFERENCE" },
4360 {
"COMMENT",
"VALUE" },
4361 {
"VALUE",
"ALTIUM_VALUE" },
4362 {
"LAYER_NAME",
"LAYER" },
4363 {
"PRINT_DATE",
"CURRENT_DATE"},
4368 item = fpTextbox.get();
4369 text = fpTextbox.get();
4382 text->SetText( kicadText );
4383 text->SetKeepUpright(
false );
4390 aFootprint->
Add( fpTextbox.release(), ADD_MODE::APPEND );
4392 aFootprint->
Add( fpText.release(), ADD_MODE::APPEND );
4420 kicadMargin =
VECTOR2I( charWidth * 0.933, charHeight * 0.67 );
4422 kicadMargin =
VECTOR2I( charWidth * 0.808, charHeight * 0.844 );
4425 + kicadMargin * 2 - margin * 2 );
4427 kposition = kposition - kicadMargin + margin;
4443 : ALTIUM_TEXT_POSITION::LEFT_BOTTOM;
4445 switch( justification )
4447 case ALTIUM_TEXT_POSITION::LEFT_TOP:
4448 case ALTIUM_TEXT_POSITION::LEFT_CENTER:
4449 case ALTIUM_TEXT_POSITION::LEFT_BOTTOM:
4453 case ALTIUM_TEXT_POSITION::CENTER_TOP:
4454 case ALTIUM_TEXT_POSITION::CENTER_CENTER:
4455 case ALTIUM_TEXT_POSITION::CENTER_BOTTOM:
4459 case ALTIUM_TEXT_POSITION::RIGHT_TOP:
4460 case ALTIUM_TEXT_POSITION::RIGHT_CENTER:
4461 case ALTIUM_TEXT_POSITION::RIGHT_BOTTOM:
4469 msg.Printf(
_(
"Unknown textbox justification %d, aText %s" ), justification,
4489 int rectHeight = aElem.
height;
4492 rectWidth = -rectWidth;
4496 : ALTIUM_TEXT_POSITION::LEFT_BOTTOM;
4498 switch( justification )
4500 case ALTIUM_TEXT_POSITION::LEFT_TOP:
4504 kposition.
y -= rectHeight;
4506 case ALTIUM_TEXT_POSITION::LEFT_CENTER:
4510 kposition.
y -= rectHeight / 2;
4512 case ALTIUM_TEXT_POSITION::LEFT_BOTTOM:
4516 case ALTIUM_TEXT_POSITION::CENTER_TOP:
4520 kposition.
x += rectWidth / 2;
4521 kposition.
y -= rectHeight;
4523 case ALTIUM_TEXT_POSITION::CENTER_CENTER:
4527 kposition.
x += rectWidth / 2;
4528 kposition.
y -= rectHeight / 2;
4530 case ALTIUM_TEXT_POSITION::CENTER_BOTTOM:
4534 kposition.
x += rectWidth / 2;
4536 case ALTIUM_TEXT_POSITION::RIGHT_TOP:
4540 kposition.
x += rectWidth;
4541 kposition.
y -= rectHeight;
4543 case ALTIUM_TEXT_POSITION::RIGHT_CENTER:
4547 kposition.
x += rectWidth;
4548 kposition.
y -= rectHeight / 2;
4550 case ALTIUM_TEXT_POSITION::RIGHT_BOTTOM:
4554 kposition.
x += rectWidth;
4599 if( aElem.
fonttype == ALTIUM_TEXT_TYPE::TRUETYPE )
4607 if( font->
GetName().Contains( wxS(
"Arial" ) ) )
4622 const CFB::COMPOUND_FILE_ENTRY* aEntry )
4655 PCB_SHAPE shape(
nullptr, SHAPE_T::RECTANGLE );
4680 const bool aIsBoardImport )
4683 || aElem.
layer == ALTIUM_LAYER::KEEP_OUT_LAYER )
4686 PCB_SHAPE shape(
nullptr, SHAPE_T::RECTANGLE );
4720 std::unique_ptr<PCB_SHAPE> fill = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::RECTANGLE );
4722 fill->SetFilled(
true );
4723 fill->SetLayer( aLayer );
4726 fill->SetStart( aElem.
pos1 );
4727 fill->SetEnd( aElem.
pos2 );
4742 m_board->
Add( fill.release(), ADD_MODE::APPEND );
4749 if( aLayer ==
F_Cu || aLayer ==
B_Cu )
4751 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
4754 padLayers.
set( aLayer );
4756 pad->SetAttribute( PAD_ATTRIB::SMD );
4769 std::swap( width, height );
4772 pad->SetPosition( aElem.
pos1 / 2 + aElem.
pos2 / 2 );
4784 pad->SetPosition( anchorPos );
4795 aElem.
pos1.
y / 2 + aElem.
pos2.
y / 2 - anchorPos.
y );
4797 pad->AddPrimitivePoly(
F_Cu, shapePolys, 0,
true );
4801 pad->SetLayerSet( padLayers );
4803 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
4807 std::unique_ptr<PCB_SHAPE> fill =
4808 std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::RECTANGLE );
4810 fill->SetFilled(
true );
4811 fill->SetLayer( aLayer );
4814 fill->SetStart( aElem.
pos1 );
4815 fill->SetEnd( aElem.
pos2 );
4824 aFootprint->
Add( fill.release(), ADD_MODE::APPEND );
4834 layerSet.
set( klayer );
4842 bool keepoutRestrictionVia = ( aKeepoutRestrictions & 0x01 ) != 0;
4843 bool keepoutRestrictionTrack = ( aKeepoutRestrictions & 0x02 ) != 0;
4844 bool keepoutRestrictionCopper = ( aKeepoutRestrictions & 0x04 ) != 0;
4845 bool keepoutRestrictionSMDPad = ( aKeepoutRestrictions & 0x08 ) != 0;
4846 bool keepoutRestrictionTHPad = ( aKeepoutRestrictions & 0x10 ) != 0;
4858 const uint8_t aKeepoutRestrictions )
4860 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(
m_board );
4862 zone->SetIsRuleArea(
true );
4869 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
4872 m_board->
Add( zone.release(), ADD_MODE::APPEND );
4879 const uint8_t aKeepoutRestrictions )
4881 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( aFootprint );
4883 zone->SetIsRuleArea(
true );
4890 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
4894 aFootprint->
Add( zone.release(), ADD_MODE::APPEND );
4907 if( elems.first == elems.second )
4910 std::vector<std::pair<PCB_LAYER_ID, int>> layerExpansionPairs;
4912 for(
auto it = elems.first; it != elems.second; ++it )
4916 if( pInf.
type == AEXTENDED_PRIMITIVE_INFORMATION_TYPE::MASK )
4922 if( aAltiumLayer == ALTIUM_LAYER::TOP_LAYER
4923 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4928 if( aAltiumLayer == ALTIUM_LAYER::BOTTOM_LAYER
4929 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4937 if( aAltiumLayer == ALTIUM_LAYER::TOP_LAYER
4938 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4943 if( aAltiumLayer == ALTIUM_LAYER::BOTTOM_LAYER
4944 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4952 return layerExpansionPairs;
std::string FormatPath(const std::vector< std::string > &aVectorPath)
Helper for debug logging (vector -> string)
const uint16_t ALTIUM_NET_UNCONNECTED
const uint16_t ALTIUM_POLYGON_NONE
const uint16_t ALTIUM_POLYGON_BOARD
const int ALTIUM_COMPONENT_NONE
LIB_ID AltiumToKiCadLibID(const wxString &aLibName, const wxString &aLibReference)
wxString AltiumPcbSpecialStringsToKiCadStrings(const wxString &aString, const std::map< wxString, wxString > &aOverrides)
void HelperShapeLineChainFromAltiumVertices(SHAPE_LINE_CHAIN &aLine, const std::vector< ALTIUM_VERTICE > &aVertices)
double normalizeAngleDegrees(double Angle, double aMin, double aMax)
Normalize angle to be aMin < angle <= aMax angle is in degrees.
constexpr double BOLD_FACTOR
bool IsAltiumLayerCopper(ALTIUM_LAYER aLayer)
bool IsAltiumLayerAPlane(ALTIUM_LAYER aLayer)
std::function< void(const ALTIUM_PCB_COMPOUND_FILE &, const CFB::COMPOUND_FILE_ENTRY *)> PARSE_FUNCTION_POINTER_fp
constexpr int ARC_HIGH_DEF
constexpr EDA_IU_SCALE pcbIUScale
LAYER_T
The allowed types of layers, same as Specctra DSN spec.
@ BS_ITEM_TYPE_DIELECTRIC
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
size_t GetRemainingBytes() const
std::map< uint32_t, wxString > ReadWideStringTable()
size_t ReadAndSetSubrecordLength()
std::map< wxString, wxString > ReadProperties(std::function< std::map< wxString, wxString >(const std::string &)> handleBinaryData=[](const std::string &) { return std::map< wxString, wxString >();})
const CFB::CompoundFileReader & GetCompoundFileReader() const
const CFB::COMPOUND_FILE_ENTRY * FindStream(const std::vector< std::string > &aStreamPath) const
const std::pair< AMODEL, std::vector< char > > * GetLibModel(const wxString &aModelID) const
std::tuple< wxString, const CFB::COMPOUND_FILE_ENTRY * > FindLibFootprintDirName(const wxString &aFpUnicodeName)
PROGRESS_REPORTER * m_progressReporter
optional; may be nullptr
void ParseClasses6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::vector< PCB_DIM_RADIAL * > m_radialDimensions
void ConvertArcs6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const AARC6 &aElem, PCB_LAYER_ID aLayer)
void ConvertTracks6ToBoardItem(const ATRACK6 &aElem, const int aPrimitiveIndex)
void ConvertTracks6ToFootprintItem(FOOTPRINT *aFootprint, const ATRACK6 &aElem, const int aPrimitiveIndex, const bool aIsBoardImport)
int m_highest_pour_index
Altium stores pour order across all layers.
void ConvertTexts6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const ATEXT6 &aElem, PCB_LAYER_ID aLayer)
std::map< ALTIUM_LAYER, PCB_LAYER_ID > m_layermap
void ConvertShapeBasedRegions6ToBoardItemOnLayer(const AREGION6 &aElem, PCB_LAYER_ID aLayer)
void ParseVias6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperParseDimensions6Leader(const ADIMENSION6 &aElem)
wxString m_footprintName
for footprint library loading error reporting
std::vector< FOOTPRINT * > m_components
void ParseShapeBasedRegions6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
const ARULE6 * GetRuleDefault(ALTIUM_RULE_KIND aKind) const
void HelperParsePad6NonCopper(const APAD6 &aElem, PCB_LAYER_ID aLayer, PCB_SHAPE *aShape)
void ParseRegions6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::vector< PCB_LAYER_ID > GetKicadLayersToIterate(ALTIUM_LAYER aAltiumLayer) const
void ConvertShapeBasedRegions6ToFootprintItem(FOOTPRINT *aFootprint, const AREGION6 &aElem, const int aPrimitiveIndex)
void HelperPcpShapeAsFootprintKeepoutRegion(FOOTPRINT *aFootprint, const PCB_SHAPE &aShape, const ALTIUM_LAYER aAltiumLayer, const uint8_t aKeepoutRestrictions)
void ConvertArcs6ToBoardItem(const AARC6 &aElem, const int aPrimitiveIndex)
void ConvertShapeBasedRegions6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const AREGION6 &aElem, PCB_LAYER_ID aLayer, const int aPrimitiveIndex)
std::map< ALTIUM_LAYER, ZONE * > m_outer_plane
std::vector< int > m_altiumToKicadNetcodes
unsigned m_totalCount
for progress reporting
void ParseComponents6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperPcpShapeAsBoardKeepoutRegion(const PCB_SHAPE &aShape, const ALTIUM_LAYER aAltiumLayer, const uint8_t aKeepoutRestrictions)
std::map< wxString, ALTIUM_EMBEDDED_MODEL_DATA > m_EmbeddedModels
void ConvertFills6ToBoardItemOnLayer(const AFILL6 &aElem, PCB_LAYER_ID aLayer)
std::vector< std::pair< PCB_LAYER_ID, int > > HelperGetSolderAndPasteMaskExpansions(const ALTIUM_RECORD aType, const int aPrimitiveIndex, const ALTIUM_LAYER aAltiumLayer)
void ConvertComponentBody6ToFootprintItem(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, FOOTPRINT *aFootprint, const ACOMPONENTBODY6 &aElem)
void HelperSetTextAlignmentAndPos(const ATEXT6 &aElem, EDA_TEXT *aEdaText)
void ParseBoard6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertFills6ToFootprintItem(FOOTPRINT *aFootprint, const AFILL6 &aElem, const bool aIsBoardImport)
void ParseExtendedPrimitiveInformationData(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ParseFileHeader(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertShapeBasedRegions6ToBoardItem(const AREGION6 &aElem)
void HelperCreateBoardOutline(const std::vector< ALTIUM_VERTICE > &aVertices)
std::map< ALTIUM_RULE_KIND, std::vector< ARULE6 > > m_rules
void ConvertVias6ToFootprintItem(FOOTPRINT *aFootprint, const AVIA6 &aElem)
void ParseRules6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperSetZoneKeepoutRestrictions(ZONE &aZone, const uint8_t aKeepoutRestrictions)
void HelperParseDimensions6Linear(const ADIMENSION6 &aElem)
void ParseTracks6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::map< uint32_t, wxString > m_unicodeStrings
void ConvertTexts6ToBoardItem(const ATEXT6 &aElem)
void HelperParseDimensions6Center(const ADIMENSION6 &aElem)
void HelperParseDimensions6Radial(const ADIMENSION6 &aElem)
void ParseBoardRegionsData(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ParseArcs6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertTexts6ToBoardItemOnLayer(const ATEXT6 &aElem, PCB_LAYER_ID aLayer)
void ConvertPads6ToFootprintItemOnCopper(FOOTPRINT *aFootprint, const APAD6 &aElem)
FOOTPRINT * ParseFootprint(ALTIUM_PCB_COMPOUND_FILE &altiumLibFile, const wxString &aFootprintName)
REPORTER * m_reporter
optional; may be nullptr
int GetNetCode(uint16_t aId) const
void ConvertTexts6ToEdaTextSettings(const ATEXT6 &aElem, EDA_TEXT &aEdaText)
wxString m_library
for footprint library loading error reporting
void ConvertPads6ToFootprintItemOnNonCopper(FOOTPRINT *aFootprint, const APAD6 &aElem)
void ConvertTexts6ToFootprintItem(FOOTPRINT *aFootprint, const ATEXT6 &aElem)
unsigned m_lastProgressCount
void ParseFills6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertArcs6ToFootprintItem(FOOTPRINT *aFootprint, const AARC6 &aElem, const int aPrimitiveIndex, const bool aIsBoardImport)
void HelperParseDimensions6Datum(const ADIMENSION6 &aElem)
void ConvertPads6ToBoardItem(const APAD6 &aElem)
void ConvertFills6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const AFILL6 &aElem, PCB_LAYER_ID aLayer)
void ParseWideStrings6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void remapUnsureLayers(std::vector< ABOARD6_LAYER_STACKUP > &aStackup)
std::vector< ZONE * > m_polygons
void ParsePads6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertArcs6ToPcbShape(const AARC6 &aElem, PCB_SHAPE *aShape)
void ConvertTracks6ToBoardItemOnLayer(const ATRACK6 &aElem, PCB_LAYER_ID aLayer)
void ConvertFills6ToBoardItem(const AFILL6 &aElem)
FOOTPRINT * HelperGetFootprint(uint16_t aComponent) const
LAYER_MAPPING_HANDLER m_layerMappingHandler
void ParsePolygons6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
PCB_LAYER_ID GetKicadLayer(ALTIUM_LAYER aAltiumLayer) const
void ParseComponentsBodies6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertTracks6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const ATRACK6 &aElem, PCB_LAYER_ID aLayer)
void Parse(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const std::map< ALTIUM_PCB_DIR, std::string > &aFileMapping)
ALTIUM_PCB(BOARD *aBoard, PROGRESS_REPORTER *aProgressReporter, LAYER_MAPPING_HANDLER &aLayerMappingHandler, REPORTER *aReporter=nullptr, const wxString &aLibrary=wxEmptyString, const wxString &aFootprintName=wxEmptyString)
void ConvertArcs6ToBoardItemOnLayer(const AARC6 &aElem, PCB_LAYER_ID aLayer)
void ParseTexts6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::map< ALTIUM_RECORD, std::multimap< int, const AEXTENDED_PRIMITIVE_INFORMATION > > m_extendedPrimitiveInformationMaps
void ParseModelsData(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry, const std::vector< std::string > &aRootDir)
std::map< ALTIUM_LAYER, wxString > m_layerNames
void ConvertPads6ToBoardItemOnNonCopper(const APAD6 &aElem)
void HelperSetTextboxAlignmentAndPos(const ATEXT6 &aElem, PCB_TEXTBOX *aPcbTextbox)
void ParseNets6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertPads6ToFootprintItem(FOOTPRINT *aFootprint, const APAD6 &aElem)
const ARULE6 * GetRule(ALTIUM_RULE_KIND aKind, const wxString &aName) const
void ParseDimensions6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperSetZoneLayers(ZONE &aZone, const ALTIUM_LAYER aAltiumLayer)
static wxString ReadString(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
BASE_SET & set(size_t pos)
Container for design settings for a BOARD object.
std::shared_ptr< NET_SETTINGS > m_NetSettings
void SetGridOrigin(const VECTOR2I &aOrigin)
const VECTOR2I & GetGridOrigin() const
void SetAuxOrigin(const VECTOR2I &aOrigin)
const VECTOR2I & GetAuxOrigin() const
int m_SolderMaskExpansion
BOARD_STACKUP & GetStackupDescriptor()
int GetLineThickness(PCB_LAYER_ID aLayer) const
Return the default graphic segment thickness from the layer class for the given layer.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual void SetIsKnockout(bool aKnockout)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
virtual LSET BoardLayerSet() const
Return the LSET for the board that this item resides on.
Manage layers needed to make a physical board.
void RemoveAll()
Delete all items in list and clear the list.
const std::vector< BOARD_STACKUP_ITEM * > & GetList() const
void BuildDefaultStackupList(const BOARD_DESIGN_SETTINGS *aSettings, int aActiveCopperLayersCount=0)
Create a default stackup, according to the current BOARD_DESIGN_SETTINGS settings.
Information pertinent to a Pcbnew printed circuit board.
void SetVisibleLayers(const LSET &aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings changes the bit-mask of vis...
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
const BOX2I GetBoardEdgesBoundingBox() const
Return the board bounding box calculated using exclusively the board edges (graphics on Edge....
const PAGE_INFO & GetPageSettings() const
bool IsLayerEnabled(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
LAYER_T GetLayerType(PCB_LAYER_ID aLayer) const
Return the type of the copper layer given by aLayer.
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Changes the name of the layer given by aLayer.
void Move(const VECTOR2I &aMoveVector) override
Move this object.
int GetCopperLayerCount() const
const TRACKS & Tracks() const
bool m_LegacyNetclassesLoaded
True if netclasses were loaded from the file.
void SetCopperLayerCount(int aCount)
bool SetLayerType(PCB_LAYER_ID aLayer, LAYER_T aLayerType)
Change the type of the layer given by aLayer.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
const LSET & GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
void SetEnabledLayers(const LSET &aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings.
const DRAWINGS & Drawings() const
constexpr coord_type GetY() const
constexpr size_type GetWidth() const
constexpr coord_type GetX() const
constexpr size_type GetHeight() const
bool IsHorizontal() const
bool IsCardinal90() const
EDA_ANGLE GetArcAngle() const
void SetCenter(const VECTOR2I &aCenter)
virtual void SetFilled(bool aFlag)
void SetStart(const VECTOR2I &aStart)
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
void SetShape(SHAPE_T aShape)
void SetEnd(const VECTOR2I &aEnd)
void SetArcAngleAndEnd(const EDA_ANGLE &aAngle, bool aCheckNegativeAngle=false)
Set the end point from the angle center and start.
void SetPolyPoints(const std::vector< VECTOR2I > &aPoints)
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
int GetTextHeight() const
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
void SetTextPos(const VECTOR2I &aPoint)
KIFONT::FONT * GetFont() const
void SetMirrored(bool isMirrored)
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
void SetBoldFlag(bool aBold)
Set only the bold flag, without changing the font.
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
GR_TEXT_V_ALIGN_T GetVertJustify() const
virtual void SetTextAngle(const EDA_ANGLE &aAngle)
void SetItalic(bool aItalic)
Set the text to be italic - this will also update the font if needed.
void SetFont(KIFONT::FONT *aFont)
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
wxString GetEmbeddedFileLink(const EMBEDDED_FILE &aFile) const
Return the link for an embedded file.
EMBEDDED_FILE * AddFile(const wxFileName &aName, bool aOverwrite)
Load a file from disk and adds it to the collection.
static RETURN_CODE CompressAndEncode(EMBEDDED_FILE &aFile)
Take data from the #decompressedData buffer and compresses it using ZSTD into the #compressedEncodedD...
VECTOR3D m_Offset
3D model offset (mm)
VECTOR3D m_Rotation
3D model rotation (degrees)
wxString m_Filename
The 3D shape filename in 3D library.
FONT is an abstract base class for both outline and stroke fonts.
static FONT * GetFont(const wxString &aFontName=wxEmptyString, bool aBold=false, bool aItalic=false, const std::vector< wxString > *aEmbeddedFiles=nullptr, bool aForDrawingSheet=false)
virtual bool IsStroke() const
const wxString & GetName() const
virtual bool IsOutline() const
LAYER_RANGE_ITERATOR begin() const
A logical library item identifier and consists of various portions much like a URI.
LSET is a set of PCB_LAYER_IDs.
static const LSET & AllBoardTechMask()
Return a mask holding board technical layers (no CU layer) on both side.
static const LSET & UserMask()
static LSET UserDefinedLayersMask(int aUserDefinedLayerCount=MAX_USER_DEFINED_LAYERS)
Return a mask with the requested number of user defined layers.
static const LSET & InternalCuMask()
Return a complete set of internal copper layers which is all Cu layers except F_Cu and B_Cu.
Handle the data for a net.
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
A PADSTACK defines the characteristics of a single or multi-layer pad, in the IPC sense of the word.
void SetRoundRectRadiusRatio(double aRatio, PCB_LAYER_ID aLayer)
void SetChamferRatio(double aRatio, PCB_LAYER_ID aLayer)
void SetShape(PAD_SHAPE aShape, PCB_LAYER_ID aLayer)
void SetChamferPositions(int aPositions, PCB_LAYER_ID aLayer)
@ NORMAL
Shape is the same on all layers.
@ CUSTOM
Shapes can be defined on arbitrary layers.
@ FRONT_INNER_BACK
Up to three shapes can be defined (F_Cu, inner copper layers, B_Cu)
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
static constexpr PCB_LAYER_ID INNER_LAYERS
! The layer identifier to use for "inner layers" on top/inner/bottom padstacks
static LSET PTHMask()
layer set for a through hole pad
static LSET UnplatedHoleMask()
layer set for a mechanical unplated through hole pad
static LSET SMDMask()
layer set for a SMD pad on Front layer
int GetHeightIU(double aIUScale) const
Gets the page height in IU.
int GetWidthIU(double aIUScale) const
Gets the page width in IU.
virtual VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
A radial dimension indicates either the radius or diameter of an arc or circle.
VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
void SetPosition(const VECTOR2I &aPos) override
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
void SetStroke(const STROKE_PARAMS &aStroke) override
VECTOR2I GetPosition() const override
void SetBorderEnabled(bool enabled)
void SetMarginTop(int aTop)
void SetMarginLeft(int aLeft)
void SetMarginBottom(int aBottom)
void SetTextAngle(const EDA_ANGLE &aAngle) override
void SetMarginRight(int aRight)
A progress reporter interface for use in multi-threaded environments.
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
virtual void Report(const wxString &aMessage)=0
Display aMessage in the progress bar dialog.
virtual void SetCurrentProgress(double aProgress)=0
Set the progress value to aProgress (0..1).
A pure virtual class used to derive REPORTER objects from.
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
Report a string with a given severity.
OPT_VECTOR2I Intersect(const SEG &aSeg, bool aIgnoreEndpoints=false, bool aLines=false) const
Compute intersection point of segment (this) with segment aSeg.
const VECTOR2I & GetArcMid() const
const VECTOR2I & GetP1() const
const VECTOR2I & GetP0() const
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
const SHAPE_ARC & Arc(size_t aArc) const
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
int PointCount() const
Return the number of points (vertices) in this line chain.
ssize_t ArcIndex(size_t aSegment) const
Return the arc index for the given segment index.
SEG Segment(int aIndex) const
Return a copy of the aIndex-th segment in the line chain.
int NextShape(int aPointIndex) const
Return the vertex index of the next shape in the chain, or -1 if aPointIndex is the last shape.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
bool IsArcStart(size_t aIndex) const
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 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.
void Fracture()
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
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 AddHole(const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
Adds a new hole to the given outline (default: last) and returns its index.
SHAPE_LINE_CHAIN & Outline(int aIndex)
Return the reference to aIndex-th outline in the set.
int NewOutline()
Creates a new empty polygon in the set and returns its index.
int OutlineCount() const
Return the number of outlines in the set.
void Move(const VECTOR2I &aVector) override
Simple container to manage line stroke parameters.
double Distance(const VECTOR2< extended_type > &aVector) const
Compute the distance between two vectors.
T EuclideanNorm() const
Compute the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2).
VECTOR2< T > Resize(T aNewLength) const
Return a vector of the same direction, but length specified in aNewLength.
Handle a list of polygons defining a copper zone.
void SetNeedRefill(bool aNeedRefill)
void SetDoNotAllowPads(bool aEnable)
SHAPE_POLY_SET * GetFill(PCB_LAYER_ID aLayer)
void SetDoNotAllowTracks(bool aEnable)
void SetFilledPolysList(PCB_LAYER_ID aLayer, const SHAPE_POLY_SET &aPolysList)
Set the list of filled polygons.
void SetIsFilled(bool isFilled)
bool HasFilledPolysForLayer(PCB_LAYER_ID aLayer) const
void SetLayerSet(const LSET &aLayerSet) override
void SetDoNotAllowVias(bool aEnable)
void SetDoNotAllowFootprints(bool aEnable)
void SetDoNotAllowZoneFills(bool aEnable)
static int GetDefaultHatchPitch()
static constexpr EDA_ANGLE ANGLE_90
static constexpr EDA_ANGLE ANGLE_45
#define THROW_IO_ERROR(msg)
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
size_t CopperLayerToOrdinal(PCB_LAYER_ID aLayer)
Converts KiCad copper layer enum to an ordinal between the front and back layers.
PCB_LAYER_ID
A quick note on layer IDs:
void for_all_pairs(_InputIterator __first, _InputIterator __last, _Function __f)
Apply a function to every possible pair of elements of a sequence.
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
std::function< std::map< wxString, PCB_LAYER_ID >(const std::vector< INPUT_LAYER_DESC > &)> LAYER_MAPPING_HANDLER
Pointer to a function that takes a map of source and KiCad layers and returns a re-mapped version.
std::optional< VECTOR2I > OPT_VECTOR2I
wxString NotSpecifiedPrm()
uint8_t keepoutrestrictions
wxString dielectricmaterial
std::vector< ABOARD6_LAYER_STACKUP > stackup
std::vector< ALTIUM_VERTICE > board_vertices
std::vector< wxString > names
wxString sourceHierachicalPath
wxString sourcefootprintlibrary
wxString sourcedesignator
std::vector< VECTOR2I > textPoint
ALTIUM_DIMENSION_KIND kind
std::vector< VECTOR2I > referencePoint
uint8_t keepoutrestrictions
std::vector< char > m_data
int32_t soldermaskexpansionmanual
std::unique_ptr< APAD6_SIZE_AND_SHAPE > sizeAndShape
ALTIUM_PAD_SHAPE topshape
ALTIUM_MODE pastemaskexpansionmode
ALTIUM_MODE soldermaskexpansionmode
ALTIUM_PAD_SHAPE botshape
ALTIUM_PAD_SHAPE midshape
int32_t pastemaskexpansionmanual
std::vector< ALTIUM_VERTICE > vertices
ALTIUM_POLYGON_HATCHSTYLE hatchstyle
uint8_t keepoutrestrictions
std::vector< ALTIUM_VERTICE > outline
std::vector< std::vector< ALTIUM_VERTICE > > holes
ALTIUM_CONNECT_STYLE polygonconnectStyle
int planeclearanceClearance
int32_t polygonconnectReliefconductorwidth
int32_t polygonconnectAirgapwidth
uint32_t text_offset_width
uint32_t textbox_rect_height
ALTIUM_TEXT_POSITION textbox_rect_justification
uint32_t textbox_rect_width
uint32_t margin_border_width
bool isJustificationValid
ALTIUM_TEXT_TYPE fonttype
uint8_t keepoutrestrictions
int32_t soldermask_expansion_front
bool soldermask_expansion_manual
int32_t soldermask_expansion_back
uint32_t diameter_by_layer[32]
constexpr double IUTomm(int iu) const
constexpr int mmToIU(double mm) const
std::vector< char > decompressedData
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.
double DEG2RAD(double deg)
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
VECTOR2< int32_t > VECTOR2I