29#include <wx/filename.h>
31#include <wx/tokenzr.h>
32#include <wx/wfstream.h>
33#include <wx/txtstrm.h>
34#include <wx/xml/xml.h>
89 bbox.
Merge( item->GetBoundingBox() );
98 return aPinName.BeforeFirst(
'@' );
111 wxCHECK( currentSheet,
nullptr );
156 for(
const std::unique_ptr<ELAYER>& elayer : aLayers )
175 switch ( elayer->number)
205 int roti = int( eagleDegrees );
215 wxASSERT_MSG(
false, wxString::Format( wxT(
"Unhandled orientation (%d degrees)" ),
224 bool aMirror,
bool aSpin,
int aAbsDegress )
226 int align = aEagleAlignment;
228 if( aRelDegress == 90 )
232 else if( aRelDegress == 180 )
236 else if( aRelDegress == 270 )
242 if( aMirror ==
true )
244 if( aAbsDegress == 90 || aAbsDegress == 270 )
255 else if( aAbsDegress == 0 || aAbsDegress == 180 )
328 m_rootSheet( nullptr ),
329 m_schematic( nullptr ),
349 const std::map<std::string, UTF8>* aProperties )
351 wxASSERT( !aFileName || aSchematic !=
nullptr );
371 wxXmlNode* currentNode = xmlDocument.GetRoot();
377 unique_ptr<SCH_SHEET> deleter( aAppendToMe ?
nullptr :
m_rootSheet );
384 wxCHECK_MSG( aSchematic->
IsValid(),
nullptr,
385 wxT(
"Can't append to a schematic with no root!" ) );
396 if( sheetPath.Last() == aAppendToMe )
426 wxCHECK_MSG( libTable,
nullptr, wxT(
"Could not load symbol lib table." ) );
428 m_pi.reset( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
436 wxString libTableUri = wxT(
"${KIPRJMOD}/" ) +
getLibFileName().GetFullName();
449 libTable->
Format( &formatter, 0 );
457 m_eagleDoc = std::make_unique<EAGLE_DOC>( currentNode,
this );
476 const wxString& aLibraryPath,
477 const std::map<std::string, UTF8>* aProperties )
488 for(
const auto& [symName, libSymbol] : it->second.KiCadSymbols )
489 aSymbolNameList.push_back( symName );
495 const wxString& aLibraryPath,
496 const std::map<std::string, UTF8>* aProperties )
507 for(
const auto& [symName, libSymbol] : it->second.KiCadSymbols )
508 aSymbolList.push_back( libSymbol.get() );
514 const std::map<std::string, UTF8>* aProperties )
525 auto it2 = it->second.KiCadSymbols.find( aAliasName );
527 if( it2 != it->second.KiCadSymbols.end() )
528 return it2->second.get();
537 wxFileName fn( aLibraryPath );
539 if( fn.IsFileReadable() && fn.GetModificationTime().IsValid() )
540 return fn.GetModificationTime().GetValue().GetValue();
571 std::unique_ptr<EAGLE_DOC> doc = std::make_unique<EAGLE_DOC>( xmlDocument.GetRoot(),
this );
575 m_version = ( doc->version.IsEmpty() ) ? wxString( wxS(
"0.0" ) ) : doc->version;
587 wxXmlDocument xmlDocument;
588 wxFFileInputStream stream(
m_filename.GetFullPath() );
593 wxString::Format(
_(
"Unable to read file '%s'." ),
m_filename.GetFullPath() ) );
597 wxTextInputStream
text( stream );
598 wxString line =
text.ReadLine();
600 if( !line.StartsWith( wxT(
"<?xml" ) ) && !line.StartsWith( wxT(
"<!--" ) ) )
602 THROW_IO_ERROR( wxString::Format(
_(
"'%s' is an Eagle binary-format file; "
603 "only Eagle XML-format files can be imported." ),
607 if( !xmlDocument.Load( stream ) )
610 wxString::Format(
_(
"Unable to read file '%s'." ),
m_filename.GetFullPath() ) );
619 wxCHECK( aDrawing, );
623 if( aDrawing->library )
631 if( aDrawing->schematic )
638 for(
const std::unique_ptr<ESHEET>& esheet : aSchematic.
sheets )
640 for(
const std::unique_ptr<ENET>& enet : esheet->nets )
642 wxString netName = enet->netname;
651 for(
const auto& [modname, emodule] : aSchematic.
modules )
653 for(
const std::unique_ptr<ESHEET>& esheet : emodule->sheets )
655 for(
const std::unique_ptr<ENET>& enet : esheet->nets )
657 wxString netName = enet->netname;
672 if( aSchematic.
sheets.empty() )
676 for(
const auto& [
name, epart] : aSchematic.
parts )
679 for(
const auto& [modName, emodule] : aSchematic.
modules )
681 for(
const auto& [partName, epart] : emodule->parts )
687 for(
const auto& [libName, elibrary] : aSchematic.
libraries )
690 elib->
name = elibrary->GetName();
702 size_t sheetCount = aSchematic.
sheets.size();
710 for(
const std::unique_ptr<ESHEET>& esheet : aSchematic.
sheets )
717 std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>(
m_rootSheet, pos );
719 sheet->SetScreen( screen );
722 wxCHECK2( sheet && screen,
continue );
724 wxString pageNo = wxString::Format( wxT(
"%d" ),
m_sheetIndex );
734 wxCHECK2( currentScreen,
continue );
737 currentScreen->
Append( sheet.release() );
752 for(
const std::unique_ptr<ESHEET>& esheet : aSchematic.
sheets )
764 int maxY = sheetBbox.
GetY();
771 const SCH_SYMBOL* origSymbol = cmp.second.cmp;
773 for(
auto& unitEntry : cmp.second.units )
775 if( unitEntry.second ==
false )
779 int unit = unitEntry.first;
780 const wxString reference = origSymbol->
GetField( FIELD_T::REFERENCE )->
GetText();
783 symbol->SetUnitSelection( &sheetpath, unit );
784 symbol->SetUnit( unit );
785 symbol->SetOrientation( 0 );
786 symbol->AddHierarchicalReference( sheetpath.
Path(), reference, unit );
789 BOX2I cmpBbox = symbol->GetBoundingBox();
790 int posY = newCmpPosition.
y + cmpBbox.
GetHeight();
791 symbol->SetPosition(
VECTOR2I( newCmpPosition.
x, posY ) );
793 maxY = std::max( maxY, posY );
795 if( newCmpPosition.
x >= pageSizeIU.
x )
813 wxCHECK( sheet && screen, );
817 std::string filename;
824 if( aSheet->description )
825 sheet->
SetName( aSheet->description.value().text );
830 replace( filename.begin(), filename.end(),
' ',
'_' );
832 fn.SetName( filename );
838 for(
const auto& [
name, moduleinst] : aSheet->moduleinsts )
845 for(
const std::unique_ptr<EPOLYGON>& epoly : aSheet->plain->polygons )
848 for(
const std::unique_ptr<EWIRE>& ewire : aSheet->plain->wires )
854 for(
const std::unique_ptr<ETEXT>& etext : aSheet->plain->texts )
857 for(
const std::unique_ptr<ECIRCLE>& ecircle : aSheet->plain->circles )
860 for(
const std::unique_ptr<ERECT>& erectangle : aSheet->plain->rectangles )
863 for(
const std::unique_ptr<EFRAME>& eframe : aSheet->plain->frames )
865 std::vector<SCH_ITEM*> frameItems;
876 for(
const std::unique_ptr<EINSTANCE>& einstance : aSheet->instances )
884 for(
const std::unique_ptr<EBUS>& ebus : aSheet->busses )
893 for(
const std::unique_ptr<ENET>& enet : aSheet->nets )
896 wxString netName = enet->netname;
897 wxString netClass = wxString::Format( wxS(
"%i" ), enet->netcode );
916 if( pageSizeIU.
x < targetSheetSize.
x )
919 if( pageSizeIU.
y < targetSheetSize.
y )
926 VECTOR2I sheetcentre( pageSizeIU.
x / 2, pageSizeIU.
y / 2 );
930 VECTOR2I translation = sheetcentre - itemsCentre;
944 std::vector<SCH_ITEM*> allItems;
946 std::copy( screen->
Items().
begin(), screen->
Items().
end(), std::back_inserter( allItems ) );
950 item->SetPosition( item->GetPosition() + translation );
968 wxCHECK( currentSheet &¤tScreen, );
974 auto it =
m_eagleDoc->drawing->schematic->modules.find( aModuleInstance->moduleinst );
977 if( it ==
m_eagleDoc->drawing->schematic->modules.end() )
979 THROW_IO_ERROR( wxString::Format(
_(
"No module instance '%s' found in schematic "
981 aModuleInstance->name,
m_filename.GetFullPath() ) );
985 fn.SetName( aModuleInstance->moduleinst );
989 VECTOR2I size( it->second->dx.ToSchUnits(), it->second->dy.ToSchUnits() );
991 int halfX =
KiROUND( size.
x / 2.0 );
992 int halfY =
KiROUND( size.
y / 2.0 );
994 VECTOR2I pos( aModuleInstance->x.ToSchUnits() - halfX,
995 -aModuleInstance->y.ToSchUnits() - halfY );
997 std::unique_ptr<SCH_SHEET> newSheet = std::make_unique<SCH_SHEET>( currentSheet, pos, size );
1005 if( schFile->GetFileName() == fn.GetFullPath() )
1007 newScreen = schFile;
1012 bool isNewSchFile = ( newScreen == nullptr );
1020 wxCHECK( newSheet && newScreen, );
1022 newSheet->SetScreen( newScreen );
1023 newSheet->SetFileName( fn.GetFullName() );
1024 newSheet->SetName( aModuleInstance->name );
1026 for(
const auto& [portName, port] : it->second->ports )
1029 int pinOffset = port->coord.ToSchUnits();
1032 if( port->side ==
"left" )
1034 side = SHEET_SIDE::LEFT;
1036 pinPos.
y = pos.
y + halfY - pinOffset;
1037 portExtWireEndpoint = pinPos;
1038 portExtWireEndpoint.
x -= portExtWireLength;
1040 else if( port->side ==
"right" )
1042 side = SHEET_SIDE::RIGHT;
1043 pinPos.
x = pos.
x + size.
x;
1044 pinPos.
y = pos.
y + halfY - pinOffset;
1045 portExtWireEndpoint = pinPos;
1046 portExtWireEndpoint.
x += portExtWireLength;
1048 else if( port->side ==
"top" )
1050 side = SHEET_SIDE::TOP;
1051 pinPos.
x = pos.
x + halfX + pinOffset;
1053 portExtWireEndpoint = pinPos;
1054 portExtWireEndpoint.
y -= portExtWireLength;
1056 else if( port->side ==
"bottom" )
1058 side = SHEET_SIDE::BOTTOM;
1059 pinPos.
x = pos.
x + halfX + pinOffset;
1060 pinPos.
y = pos.
y + size.
y;
1061 portExtWireEndpoint = pinPos;
1062 portExtWireEndpoint.
y += portExtWireLength;
1067 currentScreen->
Append( portExtWire );
1071 if( port->direction )
1073 if( *port->direction ==
"in" )
1074 pinType = LABEL_FLAG_SHAPE::L_INPUT;
1075 else if( *port->direction ==
"out" )
1076 pinType = LABEL_FLAG_SHAPE::L_OUTPUT;
1077 else if( *port->direction ==
"io" )
1078 pinType = LABEL_FLAG_SHAPE::L_BIDI;
1079 else if( *port->direction ==
"hiz" )
1080 pinType = LABEL_FLAG_SHAPE::L_TRISTATE;
1082 pinType = LABEL_FLAG_SHAPE::L_UNSPECIFIED;
1094 newSheet->AddPin( sheetPin );
1097 wxString pageNo = wxString::Format( wxT(
"%d" ),
m_sheetIndex );
1099 newSheet->SetParent( currentSheet );
1102 currentScreen->
Append( newSheet.release() );
1104 m_modules.push_back( it->second.get() );
1110 for(
const std::unique_ptr<ESHEET>& esheet : it->second->sheets )
1120 wxCHECK2( emoduleInst,
continue );
1122 refPrefix += emoduleInst->name + wxS(
":" );
1133 wxCHECK2( symbol && !symbol->
GetInstances().empty(),
continue );
1136 wxString newReference = refPrefix + inst.
m_Reference.AfterLast(
':' );
1150 std::vector<SCH_ITEM*>& aItems )
1152 int xMin = aFrame->x1.ToSchUnits();
1153 int xMax = aFrame->x2.ToSchUnits();
1154 int yMin = -aFrame->y1.ToSchUnits();
1155 int yMax = -aFrame->y2.ToSchUnits();
1158 std::swap( xMin, xMax );
1161 std::swap( yMin, yMax );
1169 aItems.push_back( lines );
1171 if( !( aFrame->border_left ==
false ) )
1178 aItems.push_back( lines );
1181 int height = yMax - yMin;
1185 double rowSpacing = height / double( aFrame->rows );
1186 double legendPosY = yMin + ( rowSpacing / 2 );
1188 for( i = 1; i < aFrame->rows; i++ )
1190 int newY =
KiROUND( yMin + ( rowSpacing * (
double) i ) );
1194 aItems.push_back( lines );
1197 char legendChar =
'A';
1199 for( i = 0; i < aFrame->rows; i++ )
1205 legendText->
SetText( wxString( legendChar ) );
1208 aItems.push_back( legendText );
1210 legendPosY += rowSpacing;
1214 if( !( aFrame->border_right ==
false ) )
1221 aItems.push_back( lines );
1224 int height = yMax - yMin;
1228 double rowSpacing = height / double( aFrame->rows );
1229 double legendPosY = yMin + ( rowSpacing / 2 );
1231 for( i = 1; i < aFrame->rows; i++ )
1233 int newY =
KiROUND( yMin + ( rowSpacing * (
double) i ) );
1237 aItems.push_back( lines );
1240 char legendChar =
'A';
1242 for( i = 0; i < aFrame->rows; i++ )
1248 legendText->
SetText( wxString( legendChar ) );
1251 aItems.push_back( legendText );
1253 legendPosY += rowSpacing;
1257 if( !( aFrame->border_top ==
false ) )
1264 aItems.push_back( lines );
1267 int width = xMax - xMin;
1271 double columnSpacing = width / double( aFrame->columns );
1272 double legendPosX = xMin + ( columnSpacing / 2 );
1274 for( i = 1; i < aFrame->columns; i++ )
1276 int newX =
KiROUND( xMin + ( columnSpacing * (
double) i ) );
1280 aItems.push_back( lines );
1283 char legendChar =
'1';
1285 for( i = 0; i < aFrame->columns; i++ )
1291 legendText->
SetText( wxString( legendChar ) );
1294 aItems.push_back( legendText );
1296 legendPosX += columnSpacing;
1300 if( !( aFrame->border_bottom ==
false ) )
1307 aItems.push_back( lines );
1310 int width = xMax - xMin;
1314 double columnSpacing = width / double( aFrame->columns );
1315 double legendPosX = xMin + ( columnSpacing / 2 );
1317 for( i = 1; i < aFrame->columns; i++ )
1319 int newX =
KiROUND( xMin + ( columnSpacing * (
double) i ) );
1323 aItems.push_back( lines );
1326 char legendChar =
'1';
1328 for( i = 0; i < aFrame->columns; i++ )
1334 legendText->
SetText( wxString( legendChar ) );
1337 aItems.push_back( legendText );
1339 legendPosX += columnSpacing;
1346 const wxString& netName,
1347 const wxString& aNetClass )
1354 size_t segmentCount = aSegments.size();
1356 for(
const std::unique_ptr<ESEGMENT>& esegment : aSegments )
1358 bool labelled =
false;
1359 bool firstWireFound =
false;
1365 for(
const std::unique_ptr<EWIRE>& ewire : esegment->wires )
1374 if( !firstWireFound )
1376 firstWire = thisWire;
1377 firstWireFound =
true;
1383 if( !desc.labels.empty() && desc.labels.front()->GetText() == netName )
1386 for(
const SEG& seg : desc.segs )
1395 segDesc.
segs.push_back( thisWire );
1399 for(
const std::unique_ptr<EJUNCTION>& ejunction : esegment->junctions )
1402 for(
const std::unique_ptr<ELABEL>& elabel : esegment->labels )
1407 wxASSERT( segDesc.
labels.empty()
1410 segDesc.
labels.push_back( label );
1414 for(
const std::unique_ptr<EPINREF>& epinref : esegment->pinRefs )
1416 wxString part = epinref->part;
1417 wxString
pin = epinref->pin;
1419 auto powerPort =
m_powerPorts.find( wxT(
"#" ) + part );
1431 if( !labelled && firstWireFound )
1433 std::unique_ptr<SCH_LABEL_BASE> label;
1438 else if( segmentCount > 1 )
1443 label->SetPosition( firstWire.
A );
1448 if( firstWire.
B.
x > firstWire.
A.
x )
1453 screen->
Append( label.release() );
1462 std::unique_ptr<SCH_SHAPE> poly = std::make_unique<SCH_SHAPE>( SHAPE_T::POLY );
1466 for(
const std::unique_ptr<EVERTEX>& evertex : aPolygon->vertices )
1468 pt =
VECTOR2I( evertex->x.ToSchUnits(), -evertex->y.ToSchUnits() );
1474 poly->GetPolyShape().Append( arc, -1, -1,
ARC_ACCURACY );
1478 poly->AddPoint( pt );
1482 prev_curve = evertex->curve;
1485 poly->SetLayer(
kiCadLayer( aPolygon->layer ) );
1486 poly->SetStroke(
STROKE_PARAMS( aPolygon->width.ToSchUnits(), LINE_STYLE::SOLID ) );
1487 poly->SetFillMode( FILL_T::FILLED_SHAPE );
1489 return poly.release();
1497 start.
x = aWire->x1.ToSchUnits();
1498 start.
y = -aWire->y1.ToSchUnits();
1499 end.
x = aWire->x2.ToSchUnits();
1500 end.
y = -aWire->y2.ToSchUnits();
1503 endpoints =
SEG( start,
end );
1507 std::unique_ptr<SCH_SHAPE> arc = std::make_unique<SCH_SHAPE>( SHAPE_T::ARC );
1510 arc->SetCenter(
center );
1511 arc->SetStart( start );
1516 arc->SetStroke(
STROKE_PARAMS( aWire->width.ToSchUnits(), LINE_STYLE::SOLID ) );
1518 return arc.release();
1522 std::unique_ptr<SCH_LINE> line = std::make_unique<SCH_LINE>();
1524 line->SetStartPoint( start );
1525 line->SetEndPoint(
end );
1526 line->SetLayer(
kiCadLayer( aWire->layer ) );
1527 line->SetStroke(
STROKE_PARAMS( aWire->width.ToSchUnits(), LINE_STYLE::SOLID ) );
1529 return line.release();
1536 std::unique_ptr<SCH_SHAPE>
circle = std::make_unique<SCH_SHAPE>( SHAPE_T::CIRCLE );
1537 VECTOR2I center( aCircle->x.ToSchUnits(), -aCircle->y.ToSchUnits() );
1550 std::unique_ptr<SCH_SHAPE> rectangle = std::make_unique<SCH_SHAPE>( SHAPE_T::RECTANGLE );
1552 rectangle->SetLayer(
kiCadLayer( aRectangle->layer ) );
1553 rectangle->SetPosition(
VECTOR2I( aRectangle->x1.ToSchUnits(), -aRectangle->y1.ToSchUnits() ) );
1554 rectangle->SetEnd(
VECTOR2I( aRectangle->x2.ToSchUnits(), -aRectangle->y2.ToSchUnits() ) );
1556 if( aRectangle->rot )
1558 VECTOR2I pos( rectangle->GetPosition() );
1565 rectangle->SetPosition( pos );
1566 rectangle->SetEnd(
end );
1570 rectangle->SetFillMode( FILL_T::FILLED_SHAPE );
1572 return rectangle.release();
1578 std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();
1580 VECTOR2I pos( aJunction->x.ToSchUnits(), -aJunction->y.ToSchUnits() );
1582 junction->SetPosition( pos );
1584 return junction.release();
1589 const wxString& aNetName )
1591 VECTOR2I elabelpos( aLabel->x.ToSchUnits(), -aLabel->y.ToSchUnits() );
1596 std::unique_ptr<SCH_LABEL_BASE> label;
1599 KiROUND( aLabel->size.ToSchUnits() * 0.7 ) );
1605 label = std::make_unique<SCH_HIERLABEL>();
1608 const auto it =
m_modules.back()->ports.find( aNetName );
1612 if( it->second->direction )
1614 wxString direction = *it->second->direction;
1616 if( direction ==
"in" )
1617 type = LABEL_SHAPE::LABEL_INPUT;
1618 else if( direction ==
"out" )
1619 type = LABEL_SHAPE::LABEL_OUTPUT;
1620 else if( direction ==
"io" )
1621 type = LABEL_SHAPE::LABEL_BIDI;
1622 else if( direction ==
"hiz" )
1623 type = LABEL_SHAPE::LABEL_TRISTATE;
1625 type = LABEL_SHAPE::LABEL_PASSIVE;
1630 label->SetLabelShape( type );
1635 label = std::make_unique<SCH_LABEL>();
1641 label = std::make_unique<SCH_GLOBALLABEL>();
1646 label = std::make_unique<SCH_LABEL>();
1650 label->SetPosition( elabelpos );
1651 label->SetTextSize( textSize );
1656 for(
int i = 0; i <
KiROUND( aLabel->rot->degrees / 90.0 ) %4; ++i )
1657 label->Rotate90(
false );
1659 if( aLabel->rot->mirror )
1660 label->MirrorSpinStyle(
false );
1663 return label.release();
1667std::pair<VECTOR2I, const SEG*>
1669 const std::vector<SEG>& aLines )
const
1672 const SEG* nearestLine =
nullptr;
1674 double d, mindistance = std::numeric_limits<double>::max();
1677 for(
const SEG& line : aLines )
1682 if( d < mindistance )
1685 nearestPoint = testpoint;
1686 nearestLine = &line;
1689 testpoint = line.Center();
1692 if( d < mindistance )
1695 nearestPoint = testpoint;
1696 nearestLine = &line;
1702 if( d < mindistance )
1705 nearestPoint = testpoint;
1706 nearestLine = &line;
1710 return std::make_pair( nearestPoint, nearestLine );
1715 const std::map<wxString, std::unique_ptr<EPART>>& aParts )
1717 wxCHECK( aInstance, );
1723 const auto partIt = aParts.find( aInstance->part );
1725 if( partIt == aParts.end() )
1727 Report( wxString::Format(
_(
"Error parsing Eagle file. Could not find '%s' "
1728 "instance but it is referenced in the schematic." ),
1735 const std::unique_ptr<EPART>& epart = partIt->second;
1737 wxString libName = epart->library;
1740 if( epart->libraryUrn )
1741 libName += wxS(
"_" ) + epart->libraryUrn->assetId;
1743 wxString gatename = epart->deviceset + wxS(
"_" ) + epart->device + wxS(
"_" ) +
1745 wxString symbolname = wxString( epart->deviceset + epart->device );
1746 symbolname.Replace( wxT(
"*" ), wxEmptyString );
1754 wxString altSymbolName = libName + wxT(
"_" ) + symbolname;
1757 wxString libIdSymbolName = altSymbolName;
1763 Report( wxString::Format( wxS(
"Eagle library '%s' not found while looking up symbol for "
1764 "deviceset '%s', device '%s', and gate '%s." ),
1765 libName, epart->deviceset, epart->device, aInstance->gate ) );
1769 const auto gateIt = libIt->second.GateToUnitMap.find( gatename );
1771 if( gateIt == libIt->second.GateToUnitMap.end() )
1773 Report( wxString::Format( wxS(
"Symbol not found for deviceset '%s', device '%s', and "
1774 "gate '%s in library '%s'." ),
1775 epart->deviceset, epart->device, aInstance->gate, libName ) );
1779 int unit = gateIt->second;
1784 auto p = elib->
package.find( kisymbolname );
1786 if( p != elib->
package.end() )
1787 package = p->second;
1790 std::map<std::string, UTF8> properties;
1793 LIB_SYMBOL* part = m_pi->LoadSymbol( getLibFileName().GetFullPath(), altSymbolName, &properties );
1797 part = m_pi->LoadSymbol( getLibFileName().GetFullPath(), kisymbolname, &properties );
1798 libIdSymbolName = kisymbolname;
1803 Report( wxString::Format(
_(
"Could not find '%s' in the imported library." ),
1809 LIB_ID libId( getLibName(), libIdSymbolName );
1810 std::unique_ptr<SCH_SYMBOL> symbol = std::make_unique<SCH_SYMBOL>();
1811 symbol->SetLibId( libId );
1812 symbol->SetUnit( unit );
1813 symbol->SetPosition(
VECTOR2I( aInstance->x.ToSchUnits(), -aInstance->y.ToSchUnits() ) );
1816 if( !package.IsEmpty() )
1818 wxString footprint = m_schematic->Project().GetProjectName() + wxT(
":" ) + package;
1819 symbol->GetField( FIELD_T::FOOTPRINT )->SetText( footprint );
1822 if( aInstance->rot )
1826 if( aInstance->rot->mirror )
1827 symbol->MirrorHorizontally( aInstance->x.ToSchUnits() );
1830 std::vector<SCH_FIELD*> partFields;
1833 for(
const SCH_FIELD* partField : partFields )
1837 if( partField->IsMandatory() )
1838 symbolField = symbol->GetField( partField->GetId() );
1840 symbolField = symbol->GetField( partField->GetName() );
1842 wxCHECK2( symbolField,
continue );
1845 symbolField->
SetTextPos( symbol->GetPosition() + partField->GetTextPos() );
1850 wxString reference = package.IsEmpty() ?
'#' + aInstance->part : aInstance->part;
1853 if( reference.find_last_not_of( wxT(
"0123456789" ) ) == ( reference.Length()-1 ) )
1854 reference.Append( wxT(
"0" ) );
1859 if( reference.find_first_not_of( wxT(
"0123456789" ) ) != 0 )
1860 reference.Prepend( wxT(
"UNK" ) );
1864 if( aInstance->part.find_first_not_of( wxT(
"#" ) ) != 0 )
1865 reference.Prepend( wxT(
"UNK" ) );
1867 SCH_FIELD* referenceField = symbol->GetField( FIELD_T::REFERENCE );
1868 referenceField->
SetText( reference );
1870 SCH_FIELD* valueField = symbol->GetField( FIELD_T::VALUE );
1871 bool userValue = m_userValue.at( libIdSymbolName );
1875 getEagleSymbolFieldAttributes( aInstance, wxS(
">NAME" ), referenceField );
1876 getEagleSymbolFieldAttributes( aInstance, wxS(
">VALUE" ), valueField );
1879 if( epart->value && !epart->value.CGet().IsEmpty() )
1881 valueField->
SetText( *epart->value );
1885 valueField->
SetText( kisymbolname );
1891 for(
const auto& [ attrName, attr ] : epart->attributes )
1893 SCH_FIELD newField( symbol.get(), FIELD_T::USER );
1897 if( !symbol->GetFields().empty() )
1898 newField.
SetTextPos( symbol->GetFields().back().GetPosition() );
1901 newField.
SetText( *attr->value );
1905 symbol->AddField( newField );
1908 for(
const auto& [variantName, variant] : epart->variants )
1910 SCH_FIELD* field = symbol->AddField( *symbol->GetField( FIELD_T::VALUE ) );
1911 field->
SetName( wxT(
"VARIANT_" ) + variant->name );
1913 if( variant->value )
1914 field->
SetText( *variant->value );
1919 bool valueAttributeFound =
false;
1920 bool nameAttributeFound =
false;
1923 for(
auto& [
name, eattr] : aInstance->attributes )
1927 if( eattr->name.Lower() == wxT(
"name" ) )
1929 field = symbol->GetField( FIELD_T::REFERENCE );
1930 nameAttributeFound =
true;
1932 else if( eattr->name.Lower() == wxT(
"value" ) )
1934 field = symbol->GetField( FIELD_T::VALUE );
1935 valueAttributeFound =
true;
1939 field = symbol->GetField( eattr->name );
1949 int absdegrees = eattr->rot ? eattr->rot->degrees : 0;
1950 bool mirror = eattr->rot ? eattr->rot->mirror :
false;
1952 if( aInstance->rot && aInstance->rot->mirror )
1955 bool spin = eattr->rot ? eattr->rot->spin :
false;
1960 int rotation = aInstance->rot ? aInstance->rot->degrees : 0;
1961 int reldegrees = ( absdegrees - rotation + 360.0 );
1969 if( aInstance->smashed && aInstance->smashed.Get() )
1971 symbol->GetField( FIELD_T::VALUE )->SetVisible( valueAttributeFound );
1972 symbol->GetField( FIELD_T::REFERENCE )->SetVisible( nameAttributeFound );
1981 for(
const EMODULEINST* emoduleInst : m_moduleInstances )
1983 wxCHECK2( emoduleInst,
continue );
1985 refPrefix += emoduleInst->name + wxS(
":" );
1988 symbol->AddHierarchicalReference( m_sheetPath.Path(), refPrefix + reference, unit );
1994 wxCHECK( libSymbol, );
1996 symbol->SetLibSymbol(
new LIB_SYMBOL( *libSymbol ) );
1998 for(
const SCH_PIN*
pin : symbol->GetLibPins() )
1999 m_connPoints[symbol->GetPinPhysicalPosition(
pin )].emplace(
pin );
2002 m_powerPorts[ reference ] = symbol->GetField( FIELD_T::VALUE )->GetText();
2004 symbol->ClearFlags();
2006 screen->
Append( symbol.release() );
2012 wxCHECK( aLibrary && aEagleLibrary,
nullptr );
2018 wxString prefix = edeviceset->prefix ? edeviceset->prefix.Get() : wxString( wxT(
"" ) );
2019 wxString deviceSetDescr;
2021 if( edeviceset->description )
2025 for(
const std::unique_ptr<EDEVICE>& edevice : edeviceset->devices )
2028 wxString symbolName = edeviceset->name + edevice->name;
2029 symbolName.Replace( wxT(
"*" ), wxEmptyString );
2030 wxASSERT( !symbolName.IsEmpty() );
2033 if( edevice->package )
2034 aEagleLibrary->
package[symbolName] = edevice->package.Get();
2037 std::unique_ptr<LIB_SYMBOL> libSymbol = std::make_unique<LIB_SYMBOL>( symbolName );
2040 int gate_count =
static_cast<int>( edeviceset->gates.size() );
2041 libSymbol->SetUnitCount( gate_count );
2042 libSymbol->LockUnits(
true );
2044 SCH_FIELD* reference = libSymbol->GetField( FIELD_T::REFERENCE );
2046 if( prefix.length() == 0 )
2054 reference->
SetText( edevice->package ? prefix :
'#' + prefix );
2057 libSymbol->GetValueField().SetVisible(
true );
2060 bool ispower =
false;
2062 for(
const auto& [gateName, egate] : edeviceset->gates )
2064 const auto it = aLibrary->
symbols.find( egate->symbol );
2066 if( it == aLibrary->
symbols.end() )
2068 Report( wxString::Format( wxS(
"Eagle symbol '%s' not found in library '%s'." ),
2069 egate->symbol, aLibrary->
GetName() ) );
2073 wxString gateMapName = edeviceset->name + wxS(
"_" ) + edevice->name +
2074 wxS(
"_" ) + egate->name;
2076 ispower =
loadSymbol( it->second, libSymbol, edevice, gateindex, egate->name );
2081 libSymbol->SetUnitCount( gate_count );
2083 if( gate_count == 1 && ispower )
2084 libSymbol->SetGlobalPower();
2087 if( edevice->package )
2101 wxString packageString = libName + wxT(
":" ) + aEagleLibrary->
package[symbolName];
2103 libSymbol->GetFootprintField().SetText( packageString );
2106 wxString libName = libSymbol->GetName();
2107 libSymbol->SetName( libName );
2108 libSymbol->SetDescription( deviceSetDescr );
2118 libName = aEagleLibrary->
name + wxT(
"_" ) + libName;
2120 libSymbol->SetName( libName );
2124 std::map<std::string, UTF8> properties;
2138 aEagleLibrary->
KiCadSymbols[ libName ] = std::move( libSymbol );
2142 m_userValue.emplace( std::make_pair( libName, edeviceset->uservalue ==
true ) );
2146 return aEagleLibrary;
2151 std::unique_ptr<LIB_SYMBOL>& aSymbol,
2152 const std::unique_ptr<EDEVICE>& aDevice,
int aGateNumber,
2153 const wxString& aGateName )
2155 wxCHECK( aEsymbol && aSymbol && aDevice,
false );
2157 std::vector<SCH_ITEM*> items;
2159 bool showRefDes =
false;
2160 bool showValue =
false;
2161 bool ispower =
false;
2164 for(
const std::unique_ptr<ECIRCLE>& ecircle : aEsymbol->circles )
2167 for(
const std::unique_ptr<EPIN>& epin : aEsymbol->pins )
2169 std::unique_ptr<SCH_PIN>
pin(
loadPin( aSymbol, epin, aGateNumber ) );
2172 pin->SetType( ELECTRICAL_PINTYPE::PT_BIDI );
2174 if( epin->direction )
2178 if( epin->direction->Lower() == pinDir.first )
2180 pin->SetType( pinDir.second );
2182 if( pinDir.first == wxT(
"sup" ) )
2191 if( aDevice->connects.size() != 0 )
2193 for(
const std::unique_ptr<ECONNECT>& connect : aDevice->connects )
2195 if( connect->gate == aGateName &&
pin->GetName() == connect->pin )
2197 wxArrayString pads = wxSplit( wxString( connect->pad ),
' ' );
2199 pin->SetUnit( aGateNumber );
2202 if( pads.GetCount() > 1 )
2204 pin->SetNumberTextSize( 0 );
2207 for(
unsigned i = 0; i < pads.GetCount(); i++ )
2211 wxString padname( pads[i] );
2213 aSymbol->AddDrawItem( apin );
2222 pin->SetUnit( aGateNumber );
2223 pin->SetNumber( wxString::Format( wxT(
"%i" ), pincount ) );
2224 aSymbol->AddDrawItem(
pin.release() );
2228 for(
const std::unique_ptr<EPOLYGON>& epolygon : aEsymbol->polygons )
2231 for(
const std::unique_ptr<ERECT>& erectangle : aEsymbol->rectangles )
2234 for(
const std::unique_ptr<ETEXT>& etext : aEsymbol->texts )
2236 std::unique_ptr<SCH_TEXT> libtext(
loadSymbolText( aSymbol, etext, aGateNumber ) );
2238 if( libtext->GetText() == wxT(
"${REFERENCE}" ) )
2244 showRefDes = etext->text == wxT(
">NAME" );
2246 else if( libtext->GetText() == wxT(
"${VALUE}" ) )
2252 showValue = etext->text == wxT(
">VALUE" );
2256 aSymbol->AddDrawItem( libtext.release() );
2260 for(
const std::unique_ptr<EWIRE>& ewire : aEsymbol->wires )
2261 aSymbol->AddDrawItem(
loadSymbolWire( aSymbol, ewire, aGateNumber ) );
2263 for(
const std::unique_ptr<EFRAME>& eframe : aEsymbol->frames )
2265 std::vector<SCH_ITEM*> frameItems;
2271 item->SetParent( aSymbol.get() );
2272 item->SetUnit( aGateNumber );
2273 aSymbol->AddDrawItem( item );
2277 aSymbol->GetReferenceField().SetVisible( showRefDes );
2278 aSymbol->GetValueField().SetVisible( showValue );
2280 return pincount == 1 ? ispower :
false;
2285 const std::unique_ptr<ECIRCLE>& aCircle,
2288 wxCHECK( aSymbol && aCircle,
nullptr );
2292 VECTOR2I center( aCircle->x.ToSchUnits(), -aCircle->y.ToSchUnits() );
2294 circle->SetParent( aSymbol.get() );
2298 circle->SetUnit( aGateNumber );
2305 const std::unique_ptr<ERECT>& aRectangle,
2308 wxCHECK( aSymbol && aRectangle,
nullptr );
2313 rectangle->
SetPosition(
VECTOR2I( aRectangle->x1.ToSchUnits(), -aRectangle->y1.ToSchUnits() ) );
2314 rectangle->
SetEnd(
VECTOR2I( aRectangle->x2.ToSchUnits(), -aRectangle->y2.ToSchUnits() ) );
2316 if( aRectangle->rot )
2329 rectangle->
SetUnit( aGateNumber );
2339 const std::unique_ptr<EWIRE>& aWire,
int aGateNumber )
2341 wxCHECK( aSymbol && aWire,
nullptr );
2345 begin.
x = aWire->x1.ToSchUnits();
2346 begin.
y = -aWire->y1.ToSchUnits();
2347 end.
x = aWire->x2.ToSchUnits();
2348 end.
y = -aWire->y2.ToSchUnits();
2367 ( aWire->width.ToSchUnits() /
radius );
2368 begin =
center + centerStartVector;
2402 const std::unique_ptr<EPOLYGON>& aPolygon,
2405 wxCHECK( aSymbol && aPolygon,
nullptr );
2413 for(
const std::unique_ptr<EVERTEX>& evertex : aPolygon->vertices )
2415 pt =
VECTOR2I( evertex->x.ToSchUnits(), evertex->y.ToSchUnits() );
2429 prev_curve = evertex->curve;
2441 const std::unique_ptr<EPIN>& aPin,
int aGateNumber )
2443 wxCHECK( aSymbol && aPin,
nullptr );
2445 std::unique_ptr<SCH_PIN>
pin = std::make_unique<SCH_PIN>( aSymbol.get() );
2446 pin->SetPosition(
VECTOR2I( aPin->x.ToSchUnits(), -aPin->y.ToSchUnits() ) );
2447 pin->SetName( aPin->name );
2448 pin->SetUnit( aGateNumber );
2450 int roti = aPin->rot ? aPin->rot->degrees : 0;
2454 case 0:
pin->SetOrientation( PIN_ORIENTATION::PIN_RIGHT );
break;
2455 case 90:
pin->SetOrientation( PIN_ORIENTATION::PIN_UP );
break;
2456 case 180:
pin->SetOrientation( PIN_ORIENTATION::PIN_LEFT );
break;
2457 case 270:
pin->SetOrientation( PIN_ORIENTATION::PIN_DOWN );
break;
2458 default: wxFAIL_MSG( wxString::Format( wxT(
"Unhandled orientation (%d degrees)." ), roti ) );
2465 wxString length = aPin->length.Get();
2467 if( length == wxT(
"short" ) )
2469 else if( length == wxT(
"middle" ) )
2471 else if( length == wxT(
"long" ) )
2473 else if( length == wxT(
"point" ) )
2484 wxString visible = aPin->visible.Get();
2486 if( visible == wxT(
"off" ) )
2488 pin->SetNameTextSize( 0 );
2489 pin->SetNumberTextSize( 0 );
2491 else if( visible == wxT(
"pad" ) )
2493 pin->SetNameTextSize( 0 );
2495 else if( visible == wxT(
"pin" ) )
2497 pin->SetNumberTextSize( 0 );
2507 if( aPin->function )
2509 wxString function = aPin->function.Get();
2511 if( function == wxT(
"dot" ) )
2512 pin->SetShape( GRAPHIC_PINSHAPE::INVERTED );
2513 else if( function == wxT(
"clk" ) )
2514 pin->SetShape( GRAPHIC_PINSHAPE::CLOCK );
2515 else if( function == wxT(
"dotclk" ) )
2516 pin->SetShape( GRAPHIC_PINSHAPE::INVERTED_CLOCK );
2519 return pin.release();
2524 const std::unique_ptr<ETEXT>& aText,
int aGateNumber )
2526 wxCHECK( aSymbol && aText,
nullptr );
2528 std::unique_ptr<SCH_TEXT> libtext = std::make_unique<SCH_TEXT>();
2530 libtext->SetParent( aSymbol.get() );
2531 libtext->SetUnit( aGateNumber );
2532 libtext->SetPosition(
VECTOR2I( aText->x.ToSchUnits(), -aText->y.ToSchUnits() ) );
2534 const wxString& eagleText = aText->text;
2535 wxString adjustedText;
2536 wxStringTokenizer tokenizer( eagleText,
"\r\n" );
2539 while( tokenizer.HasMoreTokens() )
2541 wxString tmp =
interpretText( tokenizer.GetNextToken().Trim(
true ).Trim(
false ) );
2543 if( tokenizer.HasMoreTokens() )
2546 adjustedText += tmp;
2549 libtext->SetText( adjustedText.IsEmpty() ? wxString( wxS(
"~" ) ) : adjustedText );
2553 return libtext.release();
2559 wxCHECK( aText,
nullptr );
2561 std::unique_ptr<SCH_TEXT> schtext = std::make_unique<SCH_TEXT>();
2563 const wxString& eagleText = aText->text;
2564 wxString adjustedText;
2565 wxStringTokenizer tokenizer( eagleText,
"\r\n" );
2568 while( tokenizer.HasMoreTokens() )
2570 wxString tmp =
interpretText( tokenizer.GetNextToken().Trim(
true ).Trim(
false ) );
2572 if( tokenizer.HasMoreTokens() )
2575 adjustedText += tmp;
2578 schtext->SetText( adjustedText.IsEmpty() ? wxString( wxS(
"\" \"" ) )
2581 schtext->SetPosition(
VECTOR2I( aText->x.ToSchUnits(), -aText->y.ToSchUnits() ) );
2583 schtext->SetItalic(
false );
2585 return schtext.release();
2590 const std::unique_ptr<ETEXT>& aAttributes )
const
2592 wxCHECK( aText && aAttributes, );
2597 if( aAttributes->ratio && aAttributes->ratio.CGet() > 12 )
2601 int degrees = aAttributes->rot ? aAttributes->rot->degrees : 0;
2602 bool mirror = aAttributes->rot ? aAttributes->rot->mirror :
false;
2603 bool spin = aAttributes->rot ? aAttributes->rot->spin :
false;
2611 wxCHECK( aField && aText, );
2635 auto onIntersection =
2644 for(
SCH_TEXT* label : segDesc.labels )
2647 const SEG* segAttached = segDesc.LabelAttached( label );
2649 if( segAttached && !onIntersection( labelPos ) )
2663 VECTOR2I wireDirection( segAttached->
B - segAttached->
A );
2665 const VECTOR2I origPos( labelPos );
2668 bool checkPositive =
true, checkNegative =
true,
move =
false;
2672 while( ( !
move || onIntersection( labelPos ) ) && ( checkPositive || checkNegative ) )
2677 if( trial % 2 == 1 )
2679 labelPos =
VECTOR2I( origPos + wireDirection * trial / 2 );
2680 move = checkPositive = segAttached->
Contains( labelPos );
2684 labelPos =
VECTOR2I( origPos - wireDirection * trial / 2 );
2685 move = checkNegative = segAttached->
Contains( labelPos );
2721 wxFileInputStream input( aFileName );
2726 wxTextInputStream
text( input );
2728 for(
int i = 0; i < 8; i++ )
2733 if(
text.ReadLine().Contains( wxS(
"<eagle" ) ) )
2751 if( !item->IsType( { SCH_LABEL_LOCATE_ANY_T } ) )
2755 item->SetPosition( aNewEndPoint );
2768 std::vector<SCH_LINE*> buses;
2769 std::vector<SCH_LINE*> wires;
2780 buses.push_back( line );
2781 else if( line->
IsWire() )
2782 wires.push_back( line );
2787 VECTOR2I wireStart = wire->GetStartPoint();
2788 VECTOR2I wireEnd = wire->GetEndPoint();
2792 VECTOR2I busStart = bus->GetStartPoint();
2793 VECTOR2I busEnd = bus->GetEndPoint();
2796 [](
int signX,
int signY ) ->
VECTOR2I
2808 if( wireStart.
y == wireEnd.
y && busStart.
x == busEnd.
x )
2812 if( testBusHit( wireStart ) )
2816 if( wireEnd.
x < busStart.
x )
2823 VECTOR2I p = wireStart + entrySize( -1, 0 );
2825 if( testBusHit( wireStart + entrySize( 0, -1 ) ) )
2834 screen->
Append( busEntry );
2836 wire->SetStartPoint( p );
2838 else if( testBusHit( wireStart + entrySize( 0, 1 ) ) )
2847 screen->
Append( busEntry );
2849 wire->SetStartPoint( p );
2864 VECTOR2I p = wireStart + entrySize( 1, 0 );
2866 if( testBusHit( wireStart + entrySize( 0, -1 ) ) )
2875 screen->
Append( busEntry );
2877 wire->SetStartPoint( p );
2879 else if( testBusHit( wireStart + entrySize( 0, 1 ) ) )
2888 screen->
Append( busEntry );
2890 wire->SetStartPoint( p );
2901 else if( testBusHit( wireEnd ) )
2905 if( wireStart.
x < busStart.
x )
2912 VECTOR2I p = wireEnd + entrySize( -1, 0 );
2914 if( testBusHit( wireEnd + entrySize( 0, -1 ) ) )
2923 screen->
Append( busEntry );
2925 wire->SetEndPoint( p );
2927 else if( testBusHit( wireEnd + entrySize( 0, -1 ) ) )
2936 screen->
Append( busEntry );
2937 moveLabels( wire, wireEnd + entrySize( -1, 0 ) );
2938 wire->SetEndPoint( wireEnd + entrySize( -1, 0 ) );
2953 VECTOR2I p = wireEnd + entrySize( 1, 0 );
2955 if( testBusHit( wireEnd + entrySize( 0, -1 ) ) )
2964 screen->
Append( busEntry );
2966 wire->SetEndPoint( p );
2968 else if( testBusHit( wireEnd + entrySize( 0, 1 ) ) )
2977 screen->
Append( busEntry );
2979 wire->SetEndPoint( p );
2991 else if( wireStart.
x == wireEnd.
x && busStart.
y == busEnd.
y )
2995 if( testBusHit( wireStart ) )
2999 if( wireEnd.
y < busStart.
y )
3007 VECTOR2I p = wireStart + entrySize( 0, -1 );
3009 if( testBusHit( wireStart + entrySize( -1, 0 ) ) )
3019 screen->
Append( busEntry );
3021 wire->SetStartPoint( p );
3023 else if( testBusHit( wireStart + entrySize( 1, 0 ) ) )
3033 screen->
Append( busEntry );
3035 wire->SetStartPoint( p );
3051 VECTOR2I p = wireStart + entrySize( 0, 1 );
3053 if( testBusHit( wireStart + entrySize( -1, 0 ) ) )
3063 screen->
Append( busEntry );
3065 wire->SetStartPoint( p );
3067 else if( testBusHit( wireStart + entrySize( 1, 0 ) ) )
3077 screen->
Append( busEntry );
3079 wire->SetStartPoint( p );
3090 else if( testBusHit( wireEnd ) )
3094 if( wireStart.
y < busStart.
y )
3102 VECTOR2I p = wireEnd + entrySize( 0, -1 );
3104 if( testBusHit( wireEnd + entrySize( -1, 0 ) ) )
3114 screen->
Append( busEntry );
3116 wire->SetEndPoint( p );
3118 else if( testBusHit( wireEnd + entrySize( 1, 0 ) ) )
3128 screen->
Append( busEntry );
3130 wire->SetEndPoint( p );
3146 VECTOR2I p = wireEnd + entrySize( 0, 1 );
3148 if( testBusHit( wireEnd + entrySize( -1, 0 ) ) )
3158 screen->
Append( busEntry );
3160 wire->SetEndPoint( p );
3162 else if( testBusHit( wireEnd + entrySize( 1, 0 ) ) )
3172 screen->
Append( busEntry );
3174 wire->SetEndPoint( p );
3190 if( testBusHit( wireStart ) )
3192 VECTOR2I wirevector = wireStart - wireEnd;
3194 if( wirevector.
x > 0 )
3196 if( wirevector.
y > 0 )
3198 VECTOR2I p = wireStart + entrySize( -1, -1 );
3201 screen->
Append( busEntry );
3204 wire->SetStartPoint( p );
3208 VECTOR2I p = wireStart + entrySize( -1, 1 );
3211 screen->
Append( busEntry );
3214 wire->SetStartPoint( p );
3219 if( wirevector.
y > 0 )
3221 VECTOR2I p = wireStart + entrySize( 1, -1 );
3224 screen->
Append( busEntry );
3227 wire->SetStartPoint( p );
3231 VECTOR2I p = wireStart + entrySize( 1, 1 );
3234 screen->
Append( busEntry );
3237 wire->SetStartPoint( p );
3243 else if( testBusHit( wireEnd ) )
3245 VECTOR2I wirevector = wireStart - wireEnd;
3247 if( wirevector.
x > 0 )
3249 if( wirevector.
y > 0 )
3251 VECTOR2I p = wireEnd + entrySize( 1, 1 );
3254 screen->
Append( busEntry );
3257 wire->SetEndPoint( p );
3261 VECTOR2I p = wireEnd + entrySize( 1, -1 );
3264 screen->
Append( busEntry );
3267 wire->SetEndPoint( p );
3272 if( wirevector.
y > 0 )
3274 VECTOR2I p = wireEnd + entrySize( -1, 1 );
3277 screen->
Append( busEntry );
3280 wire->SetEndPoint( p );
3284 VECTOR2I p = wireEnd + entrySize( -1, -1 );
3287 screen->
Append( busEntry );
3290 wire->SetEndPoint( p );
3304 wxCHECK( aLabel,
nullptr );
3308 for(
const SEG& seg : segs )
3310 if( seg.Contains( labelPos ) )
3322 wxCHECK( aSymbol && aPin,
false );
3330 const auto& items = pointIt->second;
3332 wxCHECK( items.find( aPin ) != items.end(),
false );
3334 return items.size() > 1;
3348 int unit = aSymbol->
GetUnit();
3349 const wxString reference = aSymbol->
GetField( FIELD_T::REFERENCE )->
GetText();
3351 std::set<int> missingUnits;
3356 if(
pin->GetType() == ELECTRICAL_PINTYPE::PT_POWER_IN )
3358 bool pinInUnit = !unit ||
pin->GetUnit() == unit;
3372 switch(
pin->GetOrientation() )
3375 case PIN_ORIENTATION::PIN_RIGHT:
3378 case PIN_ORIENTATION::PIN_LEFT:
3381 case PIN_ORIENTATION::PIN_UP:
3384 case PIN_ORIENTATION::PIN_DOWN:
3389 aScreen->
Append( netLabel );
3392 else if( aUpdateSet )
3397 wxASSERT(
pin->GetUnit() );
3398 missingUnits.insert(
pin->GetUnit() );
3411 entry.
cmp = aSymbol;
3412 entry.
units.emplace( unit,
false );
3417 cmpIt->second.units[unit] =
false;
3420 if( !missingUnits.empty() )
3423 entry.
cmp = aSymbol;
3426 for(
int i : missingUnits )
3428 if( entry.
units.find( i ) != entry.
units.end() )
3429 entry.
units.emplace( i,
true );
3441 wxString ret = wxT(
"{" );
3443 wxStringTokenizer tokenizer( aEagleName, wxT(
"," ) );
3445 while( tokenizer.HasMoreTokens() )
3447 wxString member = tokenizer.GetNextToken();
3454 if( member.Freq(
'!' ) % 2 > 0 )
3455 member << wxT(
"!" );
3457 ret << member << wxS(
" " );
3472 std::unique_ptr<EPART>& epart =
m_eagleDoc->drawing->schematic->parts[aInstance->part];
3474 if( !epart || epart->deviceset.IsEmpty() )
3477 std::unique_ptr<ELIBRARY>& elibrary =
m_eagleDoc->drawing->schematic->libraries[epart->library];
3482 std::unique_ptr<EDEVICE_SET>& edeviceset = elibrary->devicesets[epart->deviceset];
3487 std::unique_ptr<EGATE>& egate = edeviceset->gates[aInstance->gate];
3492 std::unique_ptr<ESYMBOL>& esymbol = elibrary->symbols[egate->symbol];
3495 return esymbol.get();
3502 const wxString& aEagleFieldName,
3505 wxCHECK( aField && !aEagleFieldName.
IsEmpty(), );
3511 for(
const std::unique_ptr<ETEXT>&
text : esymbol->
texts )
3513 if(
text->text == aEagleFieldName )
3516 VECTOR2I pos(
text->x.ToSchUnits() + aInstance->x.ToSchUnits(),
3517 -
text->y.ToSchUnits() - aInstance->y.ToSchUnits() );
3519 bool mirror =
text->rot ?
text->rot->mirror :
false;
3521 if( aInstance->rot && aInstance->rot->mirror )
3525 pos.
y = -aInstance->y.ToSchUnits() +
text->y.ToSchUnits();
constexpr EDA_IU_SCALE schIUScale
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
constexpr coord_type GetY() const
constexpr size_type GetWidth() const
constexpr Vec Centre() const
constexpr BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
constexpr size_type GetHeight() const
constexpr coord_type GetLeft() const
constexpr const SizeVec & GetSize() const
constexpr coord_type GetBottom() const
void SetFlags(EDA_ITEM_FLAGS aMask)
virtual void SetParent(EDA_ITEM *aParent)
void SetCenter(const VECTOR2I &aCenter)
SHAPE_POLY_SET & GetPolyShape()
const VECTOR2I & GetEnd() const
Return the ending point of the graphic.
void SetStart(const VECTOR2I &aStart)
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 SetFillMode(FILL_T aFill)
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
const EDA_ANGLE & GetTextAngle() const
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
virtual const wxString & GetText() const
Return the string associated with the text object.
void SetTextPos(const VECTOR2I &aPoint)
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
GR_TEXT_H_ALIGN_T GetHorizJustify() const
virtual void SetVisible(bool aVisible)
void SetBold(bool aBold)
Set the text to be bold - this will also update the font if needed.
GR_TEXT_V_ALIGN_T GetVertJustify() const
virtual void SetText(const wxString &aText)
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.
VECTOR2I GetTextSize() const
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
EE_TYPE Overlapping(const BOX2I &aRect) const
iterator end()
Return a read/write iterator that points to one past the last element in the EE_RTREE.
iterator begin()
Return a read/write iterator that points to the first.
EE_TYPE OfType(KICAD_T aType) const
static std::shared_ptr< ERC_ITEM > Create(int aErrorCode)
Constructs an ERC_ITEM for the given error code.
REPORTER * m_reporter
Reporter to log errors/warnings to, may be nullptr.
PROGRESS_REPORTER * m_progressReporter
Progress reporter to track the progress of the operation, may be nullptr.
virtual bool CanReadLibrary(const wxString &aFileName) const
Checks if this IO object can read the specified library file/directory.
virtual void Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)
A logical library item identifier and consists of various portions much like a URI.
static UTF8 FixIllegalChars(const UTF8 &aLibItemName, bool aLib)
Replace illegal LIB_ID item name characters with underscores '_'.
Define a library symbol object.
void GetFields(std::vector< SCH_FIELD * > &aList, bool aVisibleOnly=false) const override
Populate a std::vector with SCH_FIELDs, sorted in ordinal order.
bool IsGlobalPower() const override
int GetUnitCount() const override
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library table.
bool InsertRow(LIB_TABLE_ROW *aRow, bool doReplace=false)
Adds aRow if it does not already exist or if doReplace is true.
static bool ParseBusVector(const wxString &aBus, wxString *aName, std::vector< wxString > *aMemberList)
Parse a bus vector (e.g.
Describe the page size and margins of a paper page on which to eventually print or plot.
void SetHeightMils(double aHeightInMils)
const VECTOR2D GetSizeIU(double aIUScale) const
Gets the page size in internal units.
void SetWidthMils(double aWidthInMils)
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
virtual void SetNumPhases(int aNumPhases)=0
Set the number of phases.
virtual void Report(const wxString &aMessage)=0
Display aMessage in the progress bar dialog.
static SYMBOL_LIB_TABLE * SchSymbolLibTable(PROJECT *aProject)
Accessor for project symbol library table.
virtual void SetElem(PROJECT::ELEM aIndex, _ELEM *aElem)
virtual const wxString GetProjectPath() const
Return the full path of the project.
virtual const wxString GetProjectName() const
Return the short name of the project.
Holds all the data relating to one schematic.
PROJECT & Project() const
Return a reference to the project this schematic is part of.
void SetRoot(SCH_SHEET *aRootSheet)
Initialize the schematic with a new root sheet.
bool IsValid() const
A simple test if the schematic is loaded, not a complete one.
Class for a wire to bus entry.
void ImportValues(const SCH_FIELD &aSource)
Copy parameters from a SCH_FIELD source.
bool IsEmpty()
Return true if both the name and value of the field are empty.
void SetPosition(const VECTOR2I &aPosition) override
void SetName(const wxString &aName)
void SetText(const wxString &aText) override
void SetSpinStyle(SPIN_STYLE aSpinStyle) override
std::unique_ptr< EAGLE_DOC > m_eagleDoc
SCH_ITEM * loadWire(const std::unique_ptr< EWIRE > &aWire, SEG &endpoints)
void loadTextAttributes(EDA_TEXT *aText, const std::unique_ptr< ETEXT > &aAttributes) const
void loadModuleInstance(const std::unique_ptr< EMODULEINST > &aModuleInstance)
SCH_TEXT * loadLabel(const std::unique_ptr< ELABEL > &aLabel, const wxString &aNetName)
void ensureLoadedLibrary(const wxString &aLibraryPath)
void loadSchematic(const ESCHEMATIC &aSchematic)
SCH_TEXT * loadPlainText(const std::unique_ptr< ETEXT > &aSchText)
void loadSheet(const std::unique_ptr< ESHEET > &aSheet)
void loadLayerDefs(const std::vector< std::unique_ptr< ELAYER > > &aLayers)
const ESYMBOL * getEagleSymbol(const std::unique_ptr< EINSTANCE > &aInstance)
EAGLE_LIBRARY * loadLibrary(const ELIBRARY *aLibrary, EAGLE_LIBRARY *aEagleLib)
wxXmlDocument loadXmlDocument(const wxString &aFileName)
wxString translateEagleBusName(const wxString &aEagleName) const
Translate an Eagle-style bus name into one that is KiCad-compatible.
void loadFieldAttributes(SCH_FIELD *aField, const SCH_TEXT *aText) const
Move net labels that are detached from any wire to the nearest wire.
std::map< wxString, wxString > m_powerPorts
map from symbol reference to global label equivalent
SCH_SHEET_PATH m_sheetPath
The current sheet path of the schematic being loaded.
wxString m_libName
Library name to save symbols.
SCH_TEXT * loadSymbolText(std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< ETEXT > &aText, int aGateNumber)
std::pair< VECTOR2I, const SEG * > findNearestLinePoint(const VECTOR2I &aPoint, const std::vector< SEG > &aLines) const
std::map< wxString, long long > m_timestamps
void loadInstance(const std::unique_ptr< EINSTANCE > &aInstance, const std::map< wxString, std::unique_ptr< EPART > > &aParts)
LIB_SYMBOL * LoadSymbol(const wxString &aLibraryPath, const wxString &aAliasName, const std::map< std::string, UTF8 > *aProperties) override
Load a LIB_SYMBOL object having aPartName from the aLibraryPath containing a library format that this...
std::unordered_map< wxString, bool > m_userValue
deviceset/@uservalue for device.
int GetModifyHash() const override
Return the modification hash from the library cache.
std::map< wxString, int > m_netCounts
std::map< wxString, EAGLE_LIBRARY > m_eagleLibs
bool loadSymbol(const std::unique_ptr< ESYMBOL > &aEsymbol, std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< EDEVICE > &aDevice, int aGateNumber, const wxString &aGateName)
SCH_SHEET * getCurrentSheet()
void loadDrawing(const std::unique_ptr< EDRAWING > &aDrawing)
void EnumerateSymbolLib(wxArrayString &aSymbolNameList, const wxString &aLibraryPath, const std::map< std::string, UTF8 > *aProperties) override
Populate a list of LIB_SYMBOL alias names contained within the library aLibraryPath.
SCH_SHAPE * loadSymbolPolyLine(std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< EPOLYGON > &aPolygon, int aGateNumber)
std::vector< VECTOR2I > m_wireIntersections
Wires and labels of a single connection (segment in Eagle nomenclature)
std::map< VECTOR2I, std::set< const EDA_ITEM * > > m_connPoints
The fully parsed Eagle schematic file.
void loadSegments(const std::vector< std::unique_ptr< ESEGMENT > > &aSegments, const wxString &aNetName, const wxString &aNetClass)
bool checkConnections(const SCH_SYMBOL *aSymbol, const SCH_PIN *aPin) const
IO_RELEASER< SCH_IO > m_pi
PI to create KiCad symbol library.
SCH_SHAPE * loadRectangle(const std::unique_ptr< ERECT > &aRect)
void addBusEntries()
This function finds best way to place a bus entry symbol for when an Eagle wire segment ends on an Ea...
bool CanReadSchematicFile(const wxString &aFileName) const override
Checks if this SCH_IO can read the specified schematic file.
void addImplicitConnections(SCH_SYMBOL *aSymbol, SCH_SCREEN *aScreen, bool aUpdateSet)
Create net labels to emulate implicit connections in Eagle.
std::map< int, SCH_LAYER_ID > m_layerMap
SCH_LAYER_ID kiCadLayer(int aEagleLayer)
Return the matching layer or return LAYER_NOTES.
SCH_SHEET * LoadSchematicFile(const wxString &aFileName, SCHEMATIC *aSchematic, SCH_SHEET *aAppendToMe=nullptr, const std::map< std::string, UTF8 > *aProperties=nullptr) override
Load information from some input file format that this SCH_IO implementation knows about,...
SCH_PIN * loadPin(std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< EPIN > &aPin, int aGateNumber)
SCH_SHAPE * loadCircle(const std::unique_ptr< ECIRCLE > &aCircle)
wxFileName getLibFileName()
Checks if there are other wires or pins at the position of the tested pin.
SCH_SHAPE * loadSymbolRectangle(std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< ERECT > &aRectangle, int aGateNumber)
SCH_JUNCTION * loadJunction(const std::unique_ptr< EJUNCTION > &aJunction)
wxString m_version
Eagle file version.
void getEagleSymbolFieldAttributes(const std::unique_ptr< EINSTANCE > &aInstance, const wxString &aEagleFieldName, SCH_FIELD *aField)
std::map< wxString, const EPART * > m_partlist
void moveLabels(SCH_LINE *aWire, const VECTOR2I &aNewEndPoint)
Move any labels on the wire to the new end point of the wire.
bool checkHeader(const wxString &aFileName) const
SCHEMATIC * m_schematic
Passed to Load(), the schematic object being loaded.
void countNets(const ESCHEMATIC &aSchematic)
SCH_SHEET * m_rootSheet
The root sheet of the schematic being loaded.
SCH_SHAPE * loadPolyLine(const std::unique_ptr< EPOLYGON > &aPolygon)
SCH_SHAPE * loadSymbolCircle(std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< ECIRCLE > &aCircle, int aGateNumber)
SCH_SCREEN * getCurrentScreen()
bool CanReadLibrary(const wxString &aFileName) const override
Checks if this IO object can read the specified library file/directory.
std::map< wxString, EAGLE_MISSING_CMP > m_missingCmps
void loadFrame(const std::unique_ptr< EFRAME > &aFrame, std::vector< SCH_ITEM * > &aItems)
std::vector< SEG_DESC > m_segments
Nets as defined in the <nets> sections of an Eagle schematic file.
std::vector< EMODULE * > m_modules
The current module stack being loaded.
std::vector< EMODULEINST * > m_moduleInstances
SCH_ITEM * loadSymbolWire(std::unique_ptr< LIB_SYMBOL > &aSymbol, const std::unique_ptr< EWIRE > &aWire, int aGateNumber)
long long getLibraryTimestamp(const wxString &aLibraryPath) const
static const char * PropBuffering
The property used internally by the plugin to enable cache buffering which prevents the library file ...
Base class that schematic file and library loading and saving plugins should derive from.
virtual bool CanReadSchematicFile(const wxString &aFileName) const
Checks if this SCH_IO can read the specified schematic file.
Base class for any item which can be embedded within the SCHEMATIC container class,...
SCH_ITEM * Duplicate(bool addToParentGroup, SCH_COMMIT *aCommit=nullptr, bool doClone=false) const
Routine to create a new copy of given item.
virtual void SetUnit(int aUnit)
void SetShape(LABEL_FLAG_SHAPE aShape)
void SetPosition(const VECTOR2I &aPosition) override
Segment description base class to describe items which have 2 end points (track, wire,...
bool IsWire() const
Return true if the line is a wire.
const BOX2I GetBoundingBox() const override
Return the orthogonal bounding box of this object for display purposes.
VECTOR2I GetEndPoint() const
VECTOR2I GetStartPoint() const
bool IsBus() const
Return true if the line is a bus.
void SetEndPoint(const VECTOR2I &aPosition)
void SetNumber(const wxString &aNumber)
Container class that holds multiple SCH_SCREEN objects in a hierarchy.
void UpdateSymbolLinks(REPORTER *aReporter=nullptr)
Initialize the LIB_SYMBOL reference for each SCH_SYMBOL found in the full schematic.
const PAGE_INFO & GetPageSettings() const
void Append(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
void SetPageSettings(const PAGE_INFO &aPageSettings)
EE_RTREE & Items()
Get the full RTree, usually for iterating.
const KIID & GetUuid() const
void SetFileName(const wxString &aFileName)
Set the file name for this screen to aFileName.
void Update(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Update aItem's bounding box in the tree.
void SetPosition(const VECTOR2I &aPos) override
void SetStroke(const STROKE_PARAMS &aStroke) override
VECTOR2I GetCenter() const
void AddPoint(const VECTOR2I &aPosition)
VECTOR2I GetPosition() const override
A container for handling SCH_SHEET_PATH objects in a flattened hierarchy.
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
KIID_PATH Path() const
Get the sheet path as an KIID_PATH.
SCH_SCREEN * LastScreen()
void SetPageNumber(const wxString &aPageNumber)
Set the sheet instance user definable page number.
SCH_SHEET * Last() const
Return a pointer to the last SCH_SHEET of the list.
void push_back(SCH_SHEET *aSheet)
Forwarded method from std::vector.
void pop_back()
Forwarded method from std::vector.
Define a sheet pin (label) used in sheets to create hierarchical schematics.
void SetPosition(const VECTOR2I &aPosition) override
void SetSide(SHEET_SIDE aEdge)
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
void SetFileName(const wxString &aFilename)
wxString GetFileName() const
Return the filename corresponding to this sheet.
bool LocatePathOfScreen(SCH_SCREEN *aScreen, SCH_SHEET_PATH *aList)
Search the existing hierarchy for an instance of screen loaded from aFileName.
void SetName(const wxString &aName)
SCH_SCREEN * GetScreen() const
void SetScreen(SCH_SCREEN *aScreen)
Set the SCH_SCREEN associated with this sheet to aScreen.
void AutoplaceFields(SCH_SCREEN *aScreen, AUTOPLACE_ALGO aAlgo) override
const std::vector< SCH_SYMBOL_INSTANCE > & GetInstances() const
void AddHierarchicalReference(const KIID_PATH &aPath, const wxString &aRef, int aUnit)
Add a full hierarchical reference to this symbol.
std::unique_ptr< LIB_SYMBOL > & GetLibSymbolRef()
VECTOR2I GetPinPhysicalPosition(const SCH_PIN *Pin) const
SCH_FIELD * GetField(FIELD_T aFieldType)
Return a mandatory field in this symbol.
VECTOR2I GetPosition() const override
void SetPosition(const VECTOR2I &aPosition) override
OPT_VECTOR2I Intersect(const SEG &aSeg, bool aIgnoreEndpoints=false, bool aLines=false) const
Compute intersection point of segment (this) with segment aSeg.
bool Contains(const SEG &aSeg) const
SHAPE_ARC & ConstructFromStartEndAngle(const VECTOR2I &aStart, const VECTOR2I &aEnd, const EDA_ANGLE &aAngle, double aWidth=0)
Construct this arc from the given start, end and angle.
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)
Simple container to manage line stroke parameters.
Hold a record identifying a symbol library accessed by the appropriate symbol library SCH_IO object i...
static const wxString GetSymbolLibTableFileName()
virtual void Format(OUTPUTFORMATTER *aOutput, int aIndentLevel) const override
Generate the table in s-expression format to aOutput with an indentation level of aIndentLevel.
LIB_SYMBOL * LoadSymbol(const wxString &aNickname, const wxString &aName)
Load a LIB_SYMBOL having aName from the library given by aNickname.
double Distance(const VECTOR2< extended_type > &aVector) const
Compute the distance between two vectors.
VECTOR2< T > Resize(T aNewLength) const
Return a vector of the same direction, but length specified in aNewLength.
static REPORTER & GetInstance()
static void SetReporter(REPORTER *aReporter)
Set the reporter to use for reporting font substitution warnings.
#define DEFAULT_SCH_ENTRY_SIZE
The default text size in mils. (can be changed in preference menu)
wxString escapeName(const wxString &aNetName)
Translates Eagle special characters to their counterparts in KiCad.
wxString interpretText(const wxString &aText)
Interprets special characters in Eagle text and converts them to KiCAD notation.
size_t GetNodeCount(const wxXmlNode *aNode)
Fetch the number of XML nodes within aNode.
VECTOR2I ConvertArcCenter(const VECTOR2I &aStart, const VECTOR2I &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC.
wxString convertDescription(wxString aDescr)
Converts Eagle's HTML description into KiCad description format.
static constexpr EDA_ANGLE ANGLE_VERTICAL
#define IGNORE_PARENT_GROUP
#define IS_NEW
New item, just created.
@ ERCE_BUS_ENTRY_NEEDED
Importer failed to auto-place a bus entry.
static const std::string KiCadSchematicFileExtension
static const std::string KiCadSymbolLibFileExtension
#define THROW_IO_ERROR(msg)
SCH_LAYER_ID
Eeschema drawing layers.
@ PT_INPUT
usual pin input: must be connected
@ PT_NC
not connected (must be left open)
@ PT_TRISTATE
tri state bus pin
@ PT_BIDI
input or output (like port for a microprocessor)
@ PT_OPENCOLLECTOR
pin type open collector
@ PT_POWER_IN
power input (GND, VCC for ICs). Must be connected to a power output.
@ PT_PASSIVE
pin for passive symbols: must be connected, and can be connected to any pin.
static wxString extractNetName(const wxString &aPinName)
static const std::map< wxString, ELECTRICAL_PINTYPE > pinDirectionsMap
Map of EAGLE pin type values to KiCad pin type values.
static SYMBOL_ORIENTATION_T kiCadComponentRotation(float eagleDegrees)
static void eagleToKicadAlignment(EDA_TEXT *aText, int aEagleAlignment, int aRelDegress, bool aMirror, bool aSpin, int aAbsDegress)
static BOX2I getSheetBbox(SCH_SHEET *aSheet)
Extract the net name part from a pin name (e.g. return 'GND' for pin named 'GND@2')
Definition of the SCH_SHEET_PATH and SCH_SHEET_LIST classes for Eeschema.
SHEET_SIDE
Define the edge of the sheet that the sheet pin is positioned.
std::optional< VECTOR2I > OPT_VECTOR2I
wxString UnescapeString(const wxString &aSource)
bool ReplaceIllegalFileNameChars(std::string *aName, int aReplaceChar)
Checks aName for illegal file name characters.
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
wxString UnescapeHTML(const wxString &aString)
Return a new wxString unescaped from HTML format.
std::map< wxString, std::unique_ptr< LIB_SYMBOL > > KiCadSymbols
std::unordered_map< wxString, wxString > package
std::unordered_map< wxString, int > GateToUnitMap
Map Eagle gate unit number (which are strings) to KiCad library symbol unit number.
constexpr int IUToMils(int iu) const
constexpr int MilsToIU(int mils) const
constexpr int mmToIU(double mm) const
std::map< wxString, std::unique_ptr< EDEVICE_SET > > devicesets
wxString GetName() const
Fetch the fully unique library name.
std::map< wxString, std::unique_ptr< ESYMBOL > > symbols
std::map< wxString, std::unique_ptr< EMODULE > > modules
std::vector< std::unique_ptr< ESHEET > > sheets
std::map< wxString, std::unique_ptr< EPART > > parts
std::map< wxString, std::unique_ptr< ELIBRARY > > libraries
std::vector< std::unique_ptr< ETEXT > > texts
Map references to missing symbol units data.
std::map< int, bool > units
Segments representing wires for intersection checking.
std::vector< SCH_TEXT * > labels
const SEG * LabelAttached(const SCH_TEXT *aLabel) const
< Test if a particular label is attached to any of the stored segments
A simple container for schematic symbol instance information.
SYMBOL_ORIENTATION_T
enum used in RotationMiroir()
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)
bool TestSegmentHit(const VECTOR2I &aRefPoint, const VECTOR2I &aStart, const VECTOR2I &aEnd, int aDist)
Test if aRefPoint is with aDistance on the line defined by aStart and aEnd.
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.
VECTOR2< int32_t > VECTOR2I
Definition of file extensions used in Kicad.