/* * This program source code file is part of KiCad, a free EDA CAD application. * * Copyright (C) 2020 Thomas Pointhuber * Copyright (C) 2021-2022 KiCad Developers, see AUTHORS.txt for contributors. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, you may find one here: * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html * or you may search the http://www.gnu.org website for the version 2 license, * or you may write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */ #include #include "altium_parser_sch.h" #include "sch_shape.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static const VECTOR2I GetRelativePosition( const VECTOR2I& aPosition, const SCH_SYMBOL* aSymbol ) { TRANSFORM t = aSymbol->GetTransform().InverseTransform(); return t.TransformCoordinate( aPosition - aSymbol->GetPosition() ); } static COLOR4D GetColorFromInt( int color ) { int red = color & 0x0000FF; int green = ( color & 0x00FF00 ) >> 8; int blue = ( color & 0xFF0000 ) >> 16; return COLOR4D().FromCSSRGBA( red, green, blue, 1.0 ); } static PLOT_DASH_TYPE GetPlotDashType( const ASCH_POLYLINE_LINESTYLE linestyle ) { switch( linestyle ) { case ASCH_POLYLINE_LINESTYLE::SOLID: return PLOT_DASH_TYPE::SOLID; case ASCH_POLYLINE_LINESTYLE::DASHED: return PLOT_DASH_TYPE::DASH; case ASCH_POLYLINE_LINESTYLE::DOTTED: return PLOT_DASH_TYPE::DOT; case ASCH_POLYLINE_LINESTYLE::DASH_DOTTED: return PLOT_DASH_TYPE::DASHDOT; default: return PLOT_DASH_TYPE::DEFAULT; } } static void SetSchShapeFillAndColor( const ASCH_SHAPE_INTERFACE& elem, SCH_SHAPE* shape ) { shape->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); if( !elem.isSolid ) { shape->SetFillMode( FILL_T::NO_FILL ); } else { shape->SetFillMode( FILL_T::FILLED_WITH_COLOR ); shape->SetFillColor( GetColorFromInt( elem.areacolor ) ); } } static void SetLibShapeFillAndColor( const ASCH_SHAPE_INTERFACE& elem, LIB_SHAPE* shape ) { shape->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); if( !elem.isSolid ) { shape->SetFillMode( FILL_T::NO_FILL ); } else if( elem.color == elem.areacolor ) { shape->SetFillMode( FILL_T::FILLED_SHAPE ); } else { shape->SetFillMode( FILL_T::FILLED_WITH_BG_BODYCOLOR ); } } SCH_ALTIUM_PLUGIN::SCH_ALTIUM_PLUGIN() { m_rootSheet = nullptr; m_currentSheet = nullptr; m_schematic = nullptr; m_reporter = &WXLOG_REPORTER::GetInstance(); } SCH_ALTIUM_PLUGIN::~SCH_ALTIUM_PLUGIN() { } const wxString SCH_ALTIUM_PLUGIN::GetName() const { return "Altium"; } const wxString SCH_ALTIUM_PLUGIN::GetFileExtension() const { return "SchDoc"; } const wxString SCH_ALTIUM_PLUGIN::GetLibraryFileExtension() const { return "SchLib"; } int SCH_ALTIUM_PLUGIN::GetModifyHash() const { return 0; } bool SCH_ALTIUM_PLUGIN::CheckHeader( const wxString& aFileName ) { // TODO return true; } wxString SCH_ALTIUM_PLUGIN::getLibName() { if( m_libName.IsEmpty() ) { // Try to come up with a meaningful name m_libName = m_schematic->Prj().GetProjectName(); if( m_libName.IsEmpty() ) { wxFileName fn( m_rootSheet->GetFileName() ); m_libName = fn.GetName(); } if( m_libName.IsEmpty() ) m_libName = "noname"; m_libName += "-altium-import"; m_libName = LIB_ID::FixIllegalChars( m_libName, true ); } return m_libName; } wxFileName SCH_ALTIUM_PLUGIN::getLibFileName() { wxFileName fn( m_schematic->Prj().GetProjectPath(), getLibName(), KiCadSymbolLibFileExtension ); return fn; } SCH_SHEET* SCH_ALTIUM_PLUGIN::Load( const wxString& aFileName, SCHEMATIC* aSchematic, SCH_SHEET* aAppendToMe, const PROPERTIES* aProperties ) { wxASSERT( !aFileName || aSchematic != nullptr ); wxFileName fileName( aFileName ); fileName.SetExt( KiCadSchematicFileExtension ); m_schematic = aSchematic; // Delete on exception, if I own m_rootSheet, according to aAppendToMe std::unique_ptr deleter( aAppendToMe ? nullptr : m_rootSheet ); if( aAppendToMe ) { wxCHECK_MSG( aSchematic->IsValid(), nullptr, "Can't append to a schematic with no root!" ); m_rootSheet = &aSchematic->Root(); } else { m_rootSheet = new SCH_SHEET( aSchematic ); m_rootSheet->SetFileName( fileName.GetFullPath() ); aSchematic->SetRoot( m_rootSheet ); SCH_SHEET_PATH sheetpath; sheetpath.push_back( m_rootSheet ); m_rootSheet->AddInstance( sheetpath ); m_rootSheet->SetPageNumber( sheetpath, "#" ); // We'll update later if we find a // pageNumber record for it } if( !m_rootSheet->GetScreen() ) { SCH_SCREEN* screen = new SCH_SCREEN( m_schematic ); screen->SetFileName( aFileName ); m_rootSheet->SetScreen( screen ); } SYMBOL_LIB_TABLE* libTable = m_schematic->Prj().SchSymbolLibTable(); wxCHECK_MSG( libTable, nullptr, "Could not load symbol lib table." ); m_pi.set( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) ); /// @note No check is being done here to see if the existing symbol library exists so this /// will overwrite the existing one. if( !libTable->HasLibrary( getLibName() ) ) { // Create a new empty symbol library. m_pi->CreateSymbolLib( getLibFileName().GetFullPath() ); wxString libTableUri = "${KIPRJMOD}/" + getLibFileName().GetFullName(); // Add the new library to the project symbol library table. libTable->InsertRow( new SYMBOL_LIB_TABLE_ROW( getLibName(), libTableUri, wxString( "KiCad" ) ) ); // Save project symbol library table. wxFileName fn( m_schematic->Prj().GetProjectPath(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() ); // So output formatter goes out of scope and closes the file before reloading. { FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() ); libTable->Format( &formatter, 0 ); } // Reload the symbol library table. m_schematic->Prj().SetElem( PROJECT::ELEM_SYMBOL_LIB_TABLE, nullptr ); m_schematic->Prj().SchSymbolLibTable(); } m_currentSheet = m_rootSheet; ParseAltiumSch( aFileName ); m_pi->SaveLibrary( getLibFileName().GetFullPath() ); SCH_SCREENS allSheets( m_rootSheet ); allSheets.UpdateSymbolLinks(); // Update all symbol library links for all sheets. allSheets.ClearEditFlags(); return m_rootSheet; } void SCH_ALTIUM_PLUGIN::ParseAltiumSch( const wxString& aFileName ) { ALTIUM_COMPOUND_FILE altiumSchFile( aFileName ); try { ParseStorage( altiumSchFile ); // we need this before parsing the FileHeader ParseFileHeader( altiumSchFile ); } catch( CFB::CFBException& exception ) { THROW_IO_ERROR( exception.what() ); } } void SCH_ALTIUM_PLUGIN::ParseStorage( const ALTIUM_COMPOUND_FILE& aAltiumSchFile ) { const CFB::COMPOUND_FILE_ENTRY* file = aAltiumSchFile.FindStream( { "Storage" } ); if( file == nullptr ) return; ALTIUM_PARSER reader( aAltiumSchFile, file ); std::map properties = reader.ReadProperties(); wxString header = ALTIUM_PARSER::ReadString( properties, "HEADER", "" ); int weight = ALTIUM_PARSER::ReadInt( properties, "WEIGHT", 0 ); if( weight < 0 ) THROW_IO_ERROR( "Storage weight is negative!" ); for( int i = 0; i < weight; i++ ) { m_altiumStorage.emplace_back( reader ); } if( reader.HasParsingError() ) THROW_IO_ERROR( "stream was not parsed correctly!" ); // TODO pointhi: is it possible to have multiple headers in one Storage file? Otherwise // throw IO Error. if( reader.GetRemainingBytes() != 0 ) { m_reporter->Report( wxString::Format( _( "Storage file not fully parsed " "(%d bytes remaining)." ), reader.GetRemainingBytes() ), RPT_SEVERITY_ERROR ); } } void SCH_ALTIUM_PLUGIN::ParseFileHeader( const ALTIUM_COMPOUND_FILE& aAltiumSchFile ) { const CFB::COMPOUND_FILE_ENTRY* file = aAltiumSchFile.FindStream( { "FileHeader" } ); if( file == nullptr ) THROW_IO_ERROR( "FileHeader not found" ); ALTIUM_PARSER reader( aAltiumSchFile, file ); if( reader.GetRemainingBytes() <= 0 ) { THROW_IO_ERROR( "FileHeader does not contain any data" ); } else { std::map properties = reader.ReadProperties(); int recordId = ALTIUM_PARSER::ReadInt( properties, "RECORD", 0 ); ALTIUM_SCH_RECORD record = static_cast( recordId ); if( record != ALTIUM_SCH_RECORD::HEADER ) THROW_IO_ERROR( "Header expected" ); } // Prepare some local variables wxASSERT( m_altiumPortsCurrentSheet.empty() ); wxASSERT( !m_currentTitleBlock ); m_currentTitleBlock = std::make_unique(); // index is required to resolve OWNERINDEX for( int index = 0; reader.GetRemainingBytes() > 0; index++ ) { std::map properties = reader.ReadProperties(); int recordId = ALTIUM_PARSER::ReadInt( properties, "RECORD", 0 ); ALTIUM_SCH_RECORD record = static_cast( recordId ); // see: https://github.com/vadmium/python-altium/blob/master/format.md switch( record ) { case ALTIUM_SCH_RECORD::HEADER: THROW_IO_ERROR( "Header already parsed" ); case ALTIUM_SCH_RECORD::COMPONENT: ParseComponent( index, properties ); break; case ALTIUM_SCH_RECORD::PIN: ParsePin( properties ); break; case ALTIUM_SCH_RECORD::IEEE_SYMBOL: break; case ALTIUM_SCH_RECORD::LABEL: ParseLabel( properties ); break; case ALTIUM_SCH_RECORD::BEZIER: ParseBezier( properties ); break; case ALTIUM_SCH_RECORD::POLYLINE: ParsePolyline( properties ); break; case ALTIUM_SCH_RECORD::POLYGON: ParsePolygon( properties ); break; case ALTIUM_SCH_RECORD::ELLIPSE: break; case ALTIUM_SCH_RECORD::PIECHART: break; case ALTIUM_SCH_RECORD::ROUND_RECTANGLE: ParseRoundRectangle( properties ); break; case ALTIUM_SCH_RECORD::ELLIPTICAL_ARC: break; case ALTIUM_SCH_RECORD::ARC: ParseArc( properties ); break; case ALTIUM_SCH_RECORD::LINE: ParseLine( properties ); break; case ALTIUM_SCH_RECORD::RECTANGLE: ParseRectangle( properties ); break; case ALTIUM_SCH_RECORD::SHEET_SYMBOL: ParseSheetSymbol( index, properties ); break; case ALTIUM_SCH_RECORD::SHEET_ENTRY: ParseSheetEntry( properties ); break; case ALTIUM_SCH_RECORD::POWER_PORT: ParsePowerPort( properties ); break; case ALTIUM_SCH_RECORD::PORT: // Ports are parsed after the sheet was parsed // This is required because we need all electrical connection points before placing. m_altiumPortsCurrentSheet.emplace_back( properties ); break; case ALTIUM_SCH_RECORD::NO_ERC: ParseNoERC( properties ); break; case ALTIUM_SCH_RECORD::NET_LABEL: ParseNetLabel( properties ); break; case ALTIUM_SCH_RECORD::BUS: ParseBus( properties ); break; case ALTIUM_SCH_RECORD::WIRE: ParseWire( properties ); break; case ALTIUM_SCH_RECORD::TEXT_FRAME: ParseTextFrame( properties ); break; case ALTIUM_SCH_RECORD::JUNCTION: ParseJunction( properties ); break; case ALTIUM_SCH_RECORD::IMAGE: ParseImage( properties ); break; case ALTIUM_SCH_RECORD::SHEET: ParseSheet( properties ); break; case ALTIUM_SCH_RECORD::SHEET_NAME: ParseSheetName( properties ); break; case ALTIUM_SCH_RECORD::FILE_NAME: ParseFileName( properties ); break; case ALTIUM_SCH_RECORD::DESIGNATOR: ParseDesignator( properties ); break; case ALTIUM_SCH_RECORD::BUS_ENTRY: ParseBusEntry( properties ); break; case ALTIUM_SCH_RECORD::TEMPLATE: break; case ALTIUM_SCH_RECORD::PARAMETER: ParseParameter( properties ); break; case ALTIUM_SCH_RECORD::WARNING_SIGN: break; case ALTIUM_SCH_RECORD::IMPLEMENTATION_LIST: ParseImplementationList( index, properties ); break; case ALTIUM_SCH_RECORD::IMPLEMENTATION: ParseImplementation( properties ); break; case ALTIUM_SCH_RECORD::RECORD_46: break; case ALTIUM_SCH_RECORD::RECORD_47: break; case ALTIUM_SCH_RECORD::RECORD_48: break; case ALTIUM_SCH_RECORD::NOTE: ParseNote( properties ); break; case ALTIUM_SCH_RECORD::COMPILE_MASK: m_reporter->Report( _( "Compile mask not currently supported." ), RPT_SEVERITY_ERROR ); break; case ALTIUM_SCH_RECORD::RECORD_215: break; case ALTIUM_SCH_RECORD::RECORD_216: break; case ALTIUM_SCH_RECORD::RECORD_217: break; case ALTIUM_SCH_RECORD::RECORD_218: break; case ALTIUM_SCH_RECORD::RECORD_226: break; default: m_reporter->Report( wxString::Format( _( "Unknown Record id: %d." ), recordId ), RPT_SEVERITY_ERROR ); break; } } if( reader.HasParsingError() ) THROW_IO_ERROR( "stream was not parsed correctly!" ); if( reader.GetRemainingBytes() != 0 ) THROW_IO_ERROR( "stream is not fully parsed" ); // assign LIB_SYMBOL -> COMPONENT for( std::pair& symbol : m_symbols ) { auto libSymbolIt = m_libSymbols.find( symbol.first ); if( libSymbolIt == m_libSymbols.end() ) THROW_IO_ERROR( "every symbol should have a symbol attached" ); m_pi->SaveSymbol( getLibFileName().GetFullPath(), new LIB_SYMBOL( *( libSymbolIt->second ) ), m_properties.get() ); symbol.second->SetLibSymbol( libSymbolIt->second ); } // Handle title blocks m_currentSheet->GetScreen()->SetTitleBlock( *m_currentTitleBlock ); m_currentTitleBlock.reset(); // Handle Ports for( const ASCH_PORT& port : m_altiumPortsCurrentSheet ) ParsePort( port ); m_altiumPortsCurrentSheet.clear(); m_symbols.clear(); m_libSymbols.clear(); // Otherwise we cannot save the imported sheet? m_currentSheet->SetModified(); } bool SCH_ALTIUM_PLUGIN::IsComponentPartVisible( int aOwnerindex, int aOwnerpartdisplaymode ) const { const auto& component = m_altiumComponents.find( aOwnerindex ); if( component == m_altiumComponents.end() ) return false; return component->second.displaymode == aOwnerpartdisplaymode; } const ASCH_STORAGE_FILE* SCH_ALTIUM_PLUGIN::GetFileFromStorage( const wxString& aFilename ) const { const ASCH_STORAGE_FILE* nonExactMatch = nullptr; for( const ASCH_STORAGE_FILE& file : m_altiumStorage ) { if( file.filename.IsSameAs( aFilename ) ) return &file; if( file.filename.EndsWith( aFilename ) ) nonExactMatch = &file; } return nonExactMatch; } void SCH_ALTIUM_PLUGIN::ParseComponent( int aIndex, const std::map& aProperties ) { auto pair = m_altiumComponents.insert( { aIndex, ASCH_SYMBOL( aProperties ) } ); const ASCH_SYMBOL& elem = pair.first->second; // TODO: this is a hack until we correctly apply all transformations to every element wxString name = wxString::Format( "%d%s_%s", elem.orientation, elem.isMirrored ? "_mirrored" : "", elem.libreference ); LIB_ID libId = AltiumToKiCadLibID( getLibName(), name ); LIB_SYMBOL* ksymbol = new LIB_SYMBOL( wxEmptyString ); ksymbol->SetName( name ); ksymbol->SetDescription( elem.componentdescription ); ksymbol->SetLibId( libId ); m_libSymbols.insert( { aIndex, ksymbol } ); // each component has its own symbol for now SCH_SYMBOL* symbol = new SCH_SYMBOL(); symbol->SetPosition( elem.location + m_sheetOffset ); // TODO: keep it simple for now, and only set position. //component->SetOrientation( elem.orientation ); symbol->SetLibId( libId ); symbol->SetUnit( elem.currentpartid ); m_currentSheet->GetScreen()->Append( symbol ); m_symbols.insert( { aIndex, symbol } ); } void SCH_ALTIUM_PLUGIN::ParsePin( const std::map& aProperties ) { ASCH_PIN elem( aProperties ); const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Pin's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); LIB_PIN* pin = new LIB_PIN( libSymbolIt->second ); libSymbolIt->second->AddDrawItem( pin ); pin->SetUnit( elem.ownerpartid ); pin->SetName( elem.name ); pin->SetNumber( elem.designator ); pin->SetLength( elem.pinlength ); if( !elem.showDesignator ) pin->SetNumberTextSize( 0 ); if( !elem.showPinName ) pin->SetNameTextSize( 0 ); VECTOR2I pinLocation = elem.location; // the location given is not the connection point! switch( elem.orientation ) { case ASCH_RECORD_ORIENTATION::RIGHTWARDS: pin->SetOrientation( DrawPinOrient::PIN_LEFT ); pinLocation.x += elem.pinlength; break; case ASCH_RECORD_ORIENTATION::UPWARDS: pin->SetOrientation( DrawPinOrient::PIN_DOWN ); pinLocation.y -= elem.pinlength; break; case ASCH_RECORD_ORIENTATION::LEFTWARDS: pin->SetOrientation( DrawPinOrient::PIN_RIGHT ); pinLocation.x -= elem.pinlength; break; case ASCH_RECORD_ORIENTATION::DOWNWARDS: pin->SetOrientation( DrawPinOrient::PIN_UP ); pinLocation.y += elem.pinlength; break; default: m_reporter->Report( _( "Pin has unexpected orientation." ), RPT_SEVERITY_WARNING ); break; } // TODO: position can be sometimes off a little bit! pin->SetPosition( GetRelativePosition( pinLocation + m_sheetOffset, symbol ) ); // TODO: the following fix is even worse for now? // pin->SetPosition( GetRelativePosition( elem.kicadLocation, symbol ) ); switch( elem.electrical ) { case ASCH_PIN_ELECTRICAL::INPUT: pin->SetType( ELECTRICAL_PINTYPE::PT_INPUT ); break; case ASCH_PIN_ELECTRICAL::BIDI: pin->SetType( ELECTRICAL_PINTYPE::PT_BIDI ); break; case ASCH_PIN_ELECTRICAL::OUTPUT: pin->SetType( ELECTRICAL_PINTYPE::PT_OUTPUT ); break; case ASCH_PIN_ELECTRICAL::OPEN_COLLECTOR: pin->SetType( ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR ); break; case ASCH_PIN_ELECTRICAL::PASSIVE: pin->SetType( ELECTRICAL_PINTYPE::PT_PASSIVE ); break; case ASCH_PIN_ELECTRICAL::TRISTATE: pin->SetType( ELECTRICAL_PINTYPE::PT_TRISTATE ); break; case ASCH_PIN_ELECTRICAL::OPEN_EMITTER: pin->SetType( ELECTRICAL_PINTYPE::PT_OPENEMITTER ); break; case ASCH_PIN_ELECTRICAL::POWER: pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN ); break; case ASCH_PIN_ELECTRICAL::UNKNOWN: default: pin->SetType( ELECTRICAL_PINTYPE::PT_UNSPECIFIED ); m_reporter->Report( _( "Pin has unexpected electrical type." ), RPT_SEVERITY_WARNING ); break; } if( elem.symbolOuterEdge == ASCH_PIN_SYMBOL_OUTEREDGE::UNKNOWN ) m_reporter->Report( _( "Pin has unexpected outer edge type." ), RPT_SEVERITY_WARNING ); if( elem.symbolInnerEdge == ASCH_PIN_SYMBOL_INNEREDGE::UNKNOWN ) m_reporter->Report( _( "Pin has unexpected inner edge type." ), RPT_SEVERITY_WARNING ); if( elem.symbolOuterEdge == ASCH_PIN_SYMBOL_OUTEREDGE::NEGATED ) { switch( elem.symbolInnerEdge ) { case ASCH_PIN_SYMBOL_INNEREDGE::CLOCK: pin->SetShape( GRAPHIC_PINSHAPE::INVERTED_CLOCK ); break; default: pin->SetShape( GRAPHIC_PINSHAPE::INVERTED ); break; } } else if( elem.symbolOuterEdge == ASCH_PIN_SYMBOL_OUTEREDGE::LOW_INPUT ) { switch( elem.symbolInnerEdge ) { case ASCH_PIN_SYMBOL_INNEREDGE::CLOCK: pin->SetShape( GRAPHIC_PINSHAPE::CLOCK_LOW ); break; default: pin->SetShape( GRAPHIC_PINSHAPE::INPUT_LOW ); break; } } else if( elem.symbolOuterEdge == ASCH_PIN_SYMBOL_OUTEREDGE::LOW_OUTPUT ) { pin->SetShape( GRAPHIC_PINSHAPE::OUTPUT_LOW ); } else { switch( elem.symbolInnerEdge ) { case ASCH_PIN_SYMBOL_INNEREDGE::CLOCK: pin->SetShape( GRAPHIC_PINSHAPE::CLOCK ); break; default: pin->SetShape( GRAPHIC_PINSHAPE::LINE ); // nothing to do break; } } } void SetTextPositioning( EDA_TEXT* text, ASCH_LABEL_JUSTIFICATION justification, ASCH_RECORD_ORIENTATION orientation ) { int vjustify, hjustify; EDA_ANGLE angle = ANGLE_HORIZONTAL; switch( justification ) { default: case ASCH_LABEL_JUSTIFICATION::UNKNOWN: case ASCH_LABEL_JUSTIFICATION::BOTTOM_LEFT: case ASCH_LABEL_JUSTIFICATION::BOTTOM_CENTER: case ASCH_LABEL_JUSTIFICATION::BOTTOM_RIGHT: vjustify = GR_TEXT_V_ALIGN_BOTTOM; break; case ASCH_LABEL_JUSTIFICATION::CENTER_LEFT: case ASCH_LABEL_JUSTIFICATION::CENTER_CENTER: case ASCH_LABEL_JUSTIFICATION::CENTER_RIGHT: vjustify = GR_TEXT_V_ALIGN_CENTER; break; case ASCH_LABEL_JUSTIFICATION::TOP_LEFT: case ASCH_LABEL_JUSTIFICATION::TOP_CENTER: case ASCH_LABEL_JUSTIFICATION::TOP_RIGHT: vjustify = GR_TEXT_V_ALIGN_TOP; break; } switch( justification ) { default: case ASCH_LABEL_JUSTIFICATION::UNKNOWN: case ASCH_LABEL_JUSTIFICATION::BOTTOM_LEFT: case ASCH_LABEL_JUSTIFICATION::CENTER_LEFT: case ASCH_LABEL_JUSTIFICATION::TOP_LEFT: hjustify = GR_TEXT_H_ALIGN_LEFT; break; case ASCH_LABEL_JUSTIFICATION::BOTTOM_CENTER: case ASCH_LABEL_JUSTIFICATION::CENTER_CENTER: case ASCH_LABEL_JUSTIFICATION::TOP_CENTER: hjustify = GR_TEXT_H_ALIGN_CENTER; break; case ASCH_LABEL_JUSTIFICATION::BOTTOM_RIGHT: case ASCH_LABEL_JUSTIFICATION::CENTER_RIGHT: case ASCH_LABEL_JUSTIFICATION::TOP_RIGHT: hjustify = GR_TEXT_H_ALIGN_RIGHT; break; } switch( orientation ) { case ASCH_RECORD_ORIENTATION::RIGHTWARDS: angle = ANGLE_HORIZONTAL; break; case ASCH_RECORD_ORIENTATION::LEFTWARDS: vjustify *= -1; hjustify *= -1; angle = ANGLE_HORIZONTAL; break; case ASCH_RECORD_ORIENTATION::UPWARDS: angle = ANGLE_VERTICAL; break; case ASCH_RECORD_ORIENTATION::DOWNWARDS: vjustify *= -1; hjustify *= -1; angle = ANGLE_VERTICAL; break; } text->SetVertJustify( static_cast( vjustify ) ); text->SetHorizJustify( static_cast( hjustify ) ); text->SetTextAngle( angle ); } void SCH_ALTIUM_PLUGIN::ParseLabel( const std::map& aProperties ) { ASCH_LABEL elem( aProperties ); if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { std::map variableMap = { { "APPLICATION_BUILDNUMBER", "KICAD_VERSION" }, { "SHEETNUMBER", "#" }, { "SHEETTOTAL", "##" }, { "TITLE", "TITLE" }, // 1:1 maps are sort of useless, but it makes it { "REVISION", "REVISION" }, // easier to see that the list is complete { "DATE", "ISSUE_DATE" }, { "CURRENTDATE", "CURRENT_DATE" }, { "COMPANYNAME", "COMPANY" }, { "DOCUMENTNAME", "FILENAME" }, { "PROJECTNAME", "PROJECTNAME" }, }; wxString kicadText = AltiumSpecialStringsToKiCadVariables( elem.text, variableMap ); SCH_TEXT* textItem = new SCH_TEXT( elem.location + m_sheetOffset, kicadText ); SetTextPositioning( textItem, elem.justification, elem.orientation ); size_t fontId = static_cast( elem.fontId ); if( m_altiumSheet && fontId > 0 && fontId <= m_altiumSheet->fonts.size() ) { const ASCH_SHEET_FONT& font = m_altiumSheet->fonts.at( fontId - 1 ); textItem->SetItalic( font.italic ); textItem->SetBold( font.bold ); textItem->SetTextSize( { font.size / 2, font.size / 2 } ); } textItem->SetFlags(IS_NEW ); m_currentSheet->GetScreen()->Append( textItem ); } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Label's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); LIB_TEXT* textItem = new LIB_TEXT( libSymbolIt->second ); libSymbolIt->second->AddDrawItem( textItem ); textItem->SetUnit( elem.ownerpartid ); textItem->SetPosition( GetRelativePosition( elem.location + m_sheetOffset, symbol ) ); textItem->SetText( elem.text ); SetTextPositioning( textItem, elem.justification, elem.orientation ); size_t fontId = static_cast( elem.fontId ); if( m_altiumSheet && fontId > 0 && fontId <= m_altiumSheet->fonts.size() ) { const ASCH_SHEET_FONT& font = m_altiumSheet->fonts.at( fontId - 1 ); textItem->SetItalic( font.italic ); textItem->SetBold( font.bold ); textItem->SetTextSize( { font.size / 2, font.size / 2 } ); } } } void SCH_ALTIUM_PLUGIN::ParseTextFrame( const std::map& aProperties ) { ASCH_TEXT_FRAME elem( aProperties ); SCH_TEXT* text = new SCH_TEXT( elem.location + m_sheetOffset, elem.text ); switch( elem.alignment ) { default: case ASCH_TEXT_FRAME_ALIGNMENT::LEFT: text->SetTextSpinStyle( TEXT_SPIN_STYLE::SPIN::RIGHT ); break; case ASCH_TEXT_FRAME_ALIGNMENT::CENTER: // No support for centered text in Eeschema yet... text->SetTextSpinStyle( TEXT_SPIN_STYLE::SPIN::RIGHT ); break; case ASCH_TEXT_FRAME_ALIGNMENT::RIGHT: text->SetTextSpinStyle( TEXT_SPIN_STYLE::SPIN::LEFT ); break; } // JEY TODO: set size and word-wrap once KiCad supports wrapped text. // JEY TODO: set border and background color once KiCad supports them. size_t fontId = static_cast( elem.fontId ); if( m_altiumSheet && fontId > 0 && fontId <= m_altiumSheet->fonts.size() ) { const ASCH_SHEET_FONT& font = m_altiumSheet->fonts.at( fontId - 1 ); text->SetItalic( font.italic ); text->SetBold( font.bold ); text->SetTextSize( { font.size / 2, font.size / 2 } ); } text->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( text ); } void SCH_ALTIUM_PLUGIN::ParseNote( const std::map& aProperties ) { ASCH_NOTE elem( aProperties ); SCH_TEXT* text = new SCH_TEXT( elem.location + m_sheetOffset, elem.text ); switch( elem.alignment ) { default: case ASCH_TEXT_FRAME_ALIGNMENT::LEFT: text->SetTextSpinStyle( TEXT_SPIN_STYLE::SPIN::RIGHT ); break; case ASCH_TEXT_FRAME_ALIGNMENT::CENTER: // No support for centered text in Eeschema yet... text->SetTextSpinStyle( TEXT_SPIN_STYLE::SPIN::RIGHT ); break; case ASCH_TEXT_FRAME_ALIGNMENT::RIGHT: text->SetTextSpinStyle( TEXT_SPIN_STYLE::SPIN::LEFT ); break; } // TODO: set size and word-wrap once KiCad supports wrapped text. // TODO: set border and background color once KiCad supports them. // TODO: need some sort of property system for storing author.... size_t fontId = static_cast( elem.fontId ); if( m_altiumSheet && fontId > 0 && fontId <= m_altiumSheet->fonts.size() ) { const ASCH_SHEET_FONT& font = m_altiumSheet->fonts.at( fontId - 1 ); text->SetItalic( font.italic ); text->SetBold( font.bold ); text->SetTextSize( { font.size / 2, font.size / 2 } ); } text->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( text ); } void SCH_ALTIUM_PLUGIN::ParseBezier( const std::map& aProperties ) { ASCH_BEZIER elem( aProperties ); if( elem.points.size() < 2 ) { m_reporter->Report( wxString::Format( _( "Bezier has %d control points. At least 2 are " "expected." ), static_cast( elem.points.size() ) ), RPT_SEVERITY_WARNING ); return; } if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { for( size_t i = 0; i + 1 < elem.points.size(); i += 3 ) { if( i + 2 == elem.points.size() ) { // special case: single line SCH_LINE* line = new SCH_LINE( elem.points.at( i ) + m_sheetOffset, SCH_LAYER_ID::LAYER_NOTES ); line->SetEndPoint( elem.points.at( i + 1 ) + m_sheetOffset ); line->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); line->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( line ); } else { // simulate Bezier using line segments std::vector bezierPoints; std::vector polyPoints; for( size_t j = i; j < elem.points.size() && j < i + 4; j++ ) bezierPoints.push_back( elem.points.at( j ) ); BEZIER_POLY converter( bezierPoints ); converter.GetPoly( polyPoints ); for( size_t k = 0; k + 1 < polyPoints.size(); k++ ) { SCH_LINE* line = new SCH_LINE( polyPoints.at( k ) + m_sheetOffset, SCH_LAYER_ID::LAYER_NOTES ); line->SetEndPoint( polyPoints.at( k + 1 ) + m_sheetOffset ); line->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); line->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( line ); } } } } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Bezier's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); for( size_t i = 0; i + 1 < elem.points.size(); i += 3 ) { if( i + 2 == elem.points.size() ) { // special case: single line LIB_SHAPE* line = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::POLY ); libSymbolIt->second->AddDrawItem( line ); line->SetUnit( elem.ownerpartid ); for( size_t j = i; j < elem.points.size() && j < i + 2; j++ ) { line->AddPoint( GetRelativePosition( elem.points.at( j ) + m_sheetOffset, symbol ) ); } line->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); } else if( i + 3 == elem.points.size() ) { // TODO: special case of a single line with an extra point? // I haven't a clue what this is all about, but the sample document we have in // https://gitlab.com/kicad/code/kicad/-/issues/8974 responds best by treating it // as another single line special case. LIB_SHAPE* line = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::POLY ); libSymbolIt->second->AddDrawItem( line ); line->SetUnit( elem.ownerpartid ); for( size_t j = i; j < elem.points.size() && j < i + 2; j++ ) { line->AddPoint( GetRelativePosition( elem.points.at( j ) + m_sheetOffset, symbol ) ); } line->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); } else { // Bezier always has exactly 4 control points LIB_SHAPE* bezier = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::BEZIER ); libSymbolIt->second->AddDrawItem( bezier ); bezier->SetUnit( elem.ownerpartid ); for( size_t j = i; j < elem.points.size() && j < i + 4; j++ ) { VECTOR2I pos = GetRelativePosition( elem.points.at( j ) + m_sheetOffset, symbol ); switch( j - i ) { case 0: bezier->SetStart( pos ); break; case 1: bezier->SetBezierC1( pos ); break; case 2: bezier->SetBezierC2( pos ); break; case 3: bezier->SetEnd( pos ); break; default: break; // Can't get here but silence warnings } } bezier->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); } } } } void SCH_ALTIUM_PLUGIN::ParsePolyline( const std::map& aProperties ) { ASCH_POLYLINE elem( aProperties ); if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { SCH_SHAPE* poly = new SCH_SHAPE( SHAPE_T::POLY ); for( VECTOR2I& point : elem.points ) poly->AddPoint( point + m_sheetOffset ); poly->SetStroke( STROKE_PARAMS( elem.lineWidth, GetPlotDashType( elem.linestyle ) ) ); poly->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( poly ); } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Polyline's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); LIB_SHAPE* line = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::POLY ); libSymbolIt->second->AddDrawItem( line ); line->SetUnit( elem.ownerpartid ); for( VECTOR2I& point : elem.points ) line->AddPoint( GetRelativePosition( point + m_sheetOffset, symbol ) ); line->SetStroke( STROKE_PARAMS( elem.lineWidth, GetPlotDashType( elem.linestyle ) ) ); } } void SCH_ALTIUM_PLUGIN::ParsePolygon( const std::map& aProperties ) { ASCH_POLYGON elem( aProperties ); if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { SCH_SHAPE* poly = new SCH_SHAPE( SHAPE_T::POLY ); for( VECTOR2I& point : elem.points ) poly->AddPoint( point + m_sheetOffset ); poly->AddPoint( elem.points.front() + m_sheetOffset ); SetSchShapeFillAndColor( elem, poly ); poly->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( poly ); } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Polygon's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); LIB_SHAPE* line = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::POLY ); libSymbolIt->second->AddDrawItem( line ); line->SetUnit( elem.ownerpartid ); for( VECTOR2I& point : elem.points ) line->AddPoint( GetRelativePosition( point + m_sheetOffset, symbol ) ); line->AddPoint( GetRelativePosition( elem.points.front() + m_sheetOffset, symbol ) ); SetLibShapeFillAndColor( elem, line ); } } void SCH_ALTIUM_PLUGIN::ParseRoundRectangle( const std::map& aProperties ) { ASCH_ROUND_RECTANGLE elem( aProperties ); VECTOR2I sheetTopRight = elem.topRight + m_sheetOffset; VECTOR2I sheetBottomLeft = elem.bottomLeft + m_sheetOffset; if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { // TODO: misses rounded edges SCH_SHAPE* rect = new SCH_SHAPE( SHAPE_T::RECT ); rect->SetPosition( sheetTopRight ); rect->SetEnd( sheetBottomLeft ); SetSchShapeFillAndColor( elem, rect ); rect->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( rect ); } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Rounded rectangle's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); // TODO: misses rounded edges LIB_SHAPE* rect = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::RECT ); libSymbolIt->second->AddDrawItem( rect ); rect->SetUnit( elem.ownerpartid ); rect->SetPosition( GetRelativePosition( elem.topRight + m_sheetOffset, symbol ) ); rect->SetEnd( GetRelativePosition( elem.bottomLeft + m_sheetOffset, symbol ) ); SetLibShapeFillAndColor( elem, rect ); } } void SCH_ALTIUM_PLUGIN::ParseArc( const std::map& aProperties ) { ASCH_ARC elem( aProperties ); if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { if( elem.startAngle == 0 && ( elem.endAngle == 0 || elem.endAngle == 360 ) ) { SCH_SHAPE* circle = new SCH_SHAPE( SHAPE_T::CIRCLE ); circle->SetPosition( elem.center + m_sheetOffset ); circle->SetEnd( circle->GetPosition() + VECTOR2I( elem.radius, 0 ) ); circle->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); m_currentSheet->GetScreen()->Append( circle ); } else { SCH_SHAPE* arc = new SCH_SHAPE( SHAPE_T::ARC ); EDA_ANGLE includedAngle( elem.endAngle - elem.startAngle, DEGREES_T ); EDA_ANGLE startAngle( elem.endAngle, DEGREES_T ); VECTOR2I startOffset( KiROUND( elem.radius * startAngle.Cos() ), -KiROUND( elem.radius * startAngle.Sin() ) ); arc->SetCenter( elem.center + m_sheetOffset ); arc->SetStart( elem.center + startOffset + m_sheetOffset ); arc->SetArcAngleAndEnd( includedAngle.Normalize(), true ); arc->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); m_currentSheet->GetScreen()->Append( arc ); } } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Arc's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); if( elem.startAngle == 0 && ( elem.endAngle == 0 || elem.endAngle == 360 ) ) { LIB_SHAPE* circle = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::CIRCLE ); libSymbolIt->second->AddDrawItem( circle ); circle->SetUnit( elem.ownerpartid ); circle->SetPosition( GetRelativePosition( elem.center + m_sheetOffset, symbol ) ); circle->SetEnd( circle->GetPosition() + VECTOR2I( elem.radius, 0 ) ); circle->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); } else { LIB_SHAPE* arc = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::ARC ); libSymbolIt->second->AddDrawItem( arc ); arc->SetUnit( elem.ownerpartid ); arc->SetCenter( GetRelativePosition( elem.center + m_sheetOffset, symbol ) ); VECTOR2I arcStart( elem.radius, 0 ); RotatePoint( arcStart, -EDA_ANGLE( elem.startAngle, DEGREES_T ) ); arcStart += arc->GetCenter(); arc->SetStart( arcStart ); VECTOR2I arcEnd( elem.radius, 0 ); RotatePoint( arcEnd, -EDA_ANGLE( elem.endAngle, DEGREES_T ) ); arcEnd += arc->GetCenter(); arc->SetEnd( arcEnd ); arc->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); } } } void SCH_ALTIUM_PLUGIN::ParseLine( const std::map& aProperties ) { ASCH_LINE elem( aProperties ); if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { // close polygon SCH_LINE* line = new SCH_LINE( elem.point1 + m_sheetOffset, SCH_LAYER_ID::LAYER_NOTES ); line->SetEndPoint( elem.point2 + m_sheetOffset ); line->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); // TODO? line->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( line ); } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Line's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); LIB_SHAPE* line = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::POLY ); libSymbolIt->second->AddDrawItem( line ); line->SetUnit( elem.ownerpartid ); line->AddPoint( GetRelativePosition( elem.point1 + m_sheetOffset, symbol ) ); line->AddPoint( GetRelativePosition( elem.point2 + m_sheetOffset, symbol ) ); line->SetStroke( STROKE_PARAMS( elem.lineWidth, PLOT_DASH_TYPE::SOLID ) ); } } void SCH_ALTIUM_PLUGIN::ParseRectangle( const std::map& aProperties ) { ASCH_RECTANGLE elem( aProperties ); VECTOR2I sheetTopRight = elem.topRight + m_sheetOffset; VECTOR2I sheetBottomLeft = elem.bottomLeft + m_sheetOffset; if( elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { SCH_SHAPE* rect = new SCH_SHAPE( SHAPE_T::RECT ); rect->SetPosition( sheetTopRight ); rect->SetEnd( sheetBottomLeft ); SetSchShapeFillAndColor( elem, rect ); rect->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( rect ); } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Rectangle's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } if( !IsComponentPartVisible( elem.ownerindex, elem.ownerpartdisplaymode ) ) return; SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); LIB_SHAPE* rect = new LIB_SHAPE( libSymbolIt->second, SHAPE_T::RECT ); libSymbolIt->second->AddDrawItem( rect ); rect->SetUnit( elem.ownerpartid ); rect->SetPosition( GetRelativePosition( sheetTopRight, symbol ) ); rect->SetEnd( GetRelativePosition( sheetBottomLeft, symbol ) ); SetLibShapeFillAndColor( elem, rect ); } } void SCH_ALTIUM_PLUGIN::ParseSheetSymbol( int aIndex, const std::map& aProperties ) { ASCH_SHEET_SYMBOL elem( aProperties ); SCH_SHEET* sheet = new SCH_SHEET( m_currentSheet, elem.location + m_sheetOffset ); SCH_SCREEN* screen = new SCH_SCREEN( m_schematic ); sheet->SetSize( elem.size ); sheet->SetBorderColor( GetColorFromInt( elem.color ) ); if( elem.isSolid ) sheet->SetBackgroundColor( GetColorFromInt( elem.areacolor ) ); sheet->SetScreen( screen ); sheet->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( sheet ); SCH_SHEET_PATH sheetpath; m_rootSheet->LocatePathOfScreen( m_currentSheet->GetScreen(), &sheetpath ); sheetpath.push_back( sheet ); sheet->AddInstance( sheetpath ); sheet->SetPageNumber( sheetpath, "#" ); // We'll update later if we find a pageNumber // record for it m_sheets.insert( { aIndex, sheet } ); } void SCH_ALTIUM_PLUGIN::ParseSheetEntry( const std::map& aProperties ) { ASCH_SHEET_ENTRY elem( aProperties ); const auto& sheetIt = m_sheets.find( elem.ownerindex ); if( sheetIt == m_sheets.end() ) { m_reporter->Report( wxString::Format( _( "Sheet entry's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } SCH_SHEET_PIN* sheetPin = new SCH_SHEET_PIN( sheetIt->second ); sheetIt->second->AddPin( sheetPin ); sheetPin->SetText( elem.name ); sheetPin->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED ); //sheetPin->SetTextSpinStyle( getSpinStyle( term.OrientAngle, false ) ); //sheetPin->SetPosition( getKiCadPoint( term.Position ) ); VECTOR2I pos = sheetIt->second->GetPosition(); wxSize size = sheetIt->second->GetSize(); switch( elem.side ) { default: case ASCH_SHEET_ENTRY_SIDE::LEFT: sheetPin->SetPosition( { pos.x, pos.y + elem.distanceFromTop } ); sheetPin->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT ); sheetPin->SetSide( SHEET_SIDE::LEFT ); break; case ASCH_SHEET_ENTRY_SIDE::RIGHT: sheetPin->SetPosition( { pos.x + size.x, pos.y + elem.distanceFromTop } ); sheetPin->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT ); sheetPin->SetSide( SHEET_SIDE::RIGHT ); break; case ASCH_SHEET_ENTRY_SIDE::TOP: sheetPin->SetPosition( { pos.x + elem.distanceFromTop, pos.y } ); sheetPin->SetTextSpinStyle( TEXT_SPIN_STYLE::UP ); sheetPin->SetSide( SHEET_SIDE::TOP ); break; case ASCH_SHEET_ENTRY_SIDE::BOTTOM: sheetPin->SetPosition( { pos.x + elem.distanceFromTop, pos.y + size.y } ); sheetPin->SetTextSpinStyle( TEXT_SPIN_STYLE::BOTTOM ); sheetPin->SetSide( SHEET_SIDE::BOTTOM ); break; } switch( elem.iotype ) { default: case ASCH_PORT_IOTYPE::UNSPECIFIED: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED ); break; case ASCH_PORT_IOTYPE::OUTPUT: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT ); break; case ASCH_PORT_IOTYPE::INPUT: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_INPUT ); break; case ASCH_PORT_IOTYPE::BIDI: sheetPin->SetShape( LABEL_FLAG_SHAPE::L_BIDI ); break; } } VECTOR2I HelperGeneratePowerPortGraphics( LIB_SYMBOL* aKsymbol, ASCH_POWER_PORT_STYLE aStyle, REPORTER* aReporter ) { if( aStyle == ASCH_POWER_PORT_STYLE::CIRCLE || aStyle == ASCH_POWER_PORT_STYLE::ARROW ) { LIB_SHAPE* line1 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line1 ); line1->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line1->AddPoint( { 0, 0 } ); line1->AddPoint( { 0, Mils2iu( -50 ) } ); if( aStyle == ASCH_POWER_PORT_STYLE::CIRCLE ) { LIB_SHAPE* circle = new LIB_SHAPE( aKsymbol, SHAPE_T::CIRCLE ); aKsymbol->AddDrawItem( circle ); circle->SetStroke( STROKE_PARAMS( Mils2iu( 5 ), PLOT_DASH_TYPE::SOLID ) ); circle->SetPosition( { Mils2iu( 0 ), Mils2iu( -75 ) } ); circle->SetEnd( circle->GetPosition() + VECTOR2I( Mils2iu( 25 ), 0 ) ); } else { LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -25 ), Mils2iu( -50 ) } ); line2->AddPoint( { Mils2iu( 25 ), Mils2iu( -50 ) } ); line2->AddPoint( { Mils2iu( 0 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( -25 ), Mils2iu( -50 ) } ); } return { 0, Mils2iu( 150 ) }; } else if( aStyle == ASCH_POWER_PORT_STYLE::WAVE ) { LIB_SHAPE* line = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line ); line->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line->AddPoint( { 0, 0 } ); line->AddPoint( { 0, Mils2iu( -72 ) } ); LIB_SHAPE* bezier = new LIB_SHAPE( aKsymbol, SHAPE_T::BEZIER ); aKsymbol->AddDrawItem( bezier ); bezier->SetStroke( STROKE_PARAMS( Mils2iu( 5 ), PLOT_DASH_TYPE::SOLID ) ); bezier->AddPoint( { Mils2iu( 30 ), Mils2iu( -50 ) } ); bezier->AddPoint( { Mils2iu( 30 ), Mils2iu( -87 ) } ); bezier->AddPoint( { Mils2iu( -30 ), Mils2iu( -63 ) } ); bezier->AddPoint( { Mils2iu( -30 ), Mils2iu( -100 ) } ); return { 0, Mils2iu( 150 ) }; } else if( aStyle == ASCH_POWER_PORT_STYLE::POWER_GROUND || aStyle == ASCH_POWER_PORT_STYLE::SIGNAL_GROUND || aStyle == ASCH_POWER_PORT_STYLE::EARTH || aStyle == ASCH_POWER_PORT_STYLE::GOST_ARROW ) { LIB_SHAPE* line1 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line1 ); line1->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line1->AddPoint( { 0, 0 } ); line1->AddPoint( { 0, Mils2iu( -100 ) } ); if( aStyle == ASCH_POWER_PORT_STYLE::POWER_GROUND ) { LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -100 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 100 ), Mils2iu( -100 ) } ); LIB_SHAPE* line3 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line3 ); line3->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line3->AddPoint( { Mils2iu( -70 ), Mils2iu( -130 ) } ); line3->AddPoint( { Mils2iu( 70 ), Mils2iu( -130 ) } ); LIB_SHAPE* line4 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line4 ); line4->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line4->AddPoint( { Mils2iu( -40 ), Mils2iu( -160 ) } ); line4->AddPoint( { Mils2iu( 40 ), Mils2iu( -160 ) } ); LIB_SHAPE* line5 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line5 ); line5->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line5->AddPoint( { Mils2iu( -10 ), Mils2iu( -190 ) } ); line5->AddPoint( { Mils2iu( 10 ), Mils2iu( -190 ) } ); } else if( aStyle == ASCH_POWER_PORT_STYLE::SIGNAL_GROUND ) { LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -100 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 100 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 0 ), Mils2iu( -200 ) } ); line2->AddPoint( { Mils2iu( -100 ), Mils2iu( -100 ) } ); } else if( aStyle == ASCH_POWER_PORT_STYLE::EARTH ) { LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -150 ), Mils2iu( -200 ) } ); line2->AddPoint( { Mils2iu( -100 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 100 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 50 ), Mils2iu( -200 ) } ); LIB_SHAPE* line3 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line3 ); line3->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line3->AddPoint( { Mils2iu( 0 ), Mils2iu( -100 ) } ); line3->AddPoint( { Mils2iu( -50 ), Mils2iu( -200 ) } ); } else // ASCH_POWER_PORT_STYLE::GOST_ARROW { LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -25 ), Mils2iu( -50 ) } ); line2->AddPoint( { Mils2iu( 0 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 25 ), Mils2iu( -50 ) } ); return { 0, Mils2iu( 150 ) }; // special case } return { 0, Mils2iu( 250 ) }; } else if( aStyle == ASCH_POWER_PORT_STYLE::GOST_POWER_GROUND || aStyle == ASCH_POWER_PORT_STYLE::GOST_EARTH ) { LIB_SHAPE* line1 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line1 ); line1->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line1->AddPoint( { 0, 0 } ); line1->AddPoint( { 0, Mils2iu( -160 ) } ); LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -100 ), Mils2iu( -160 ) } ); line2->AddPoint( { Mils2iu( 100 ), Mils2iu( -160 ) } ); LIB_SHAPE* line3 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line3 ); line3->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line3->AddPoint( { Mils2iu( -60 ), Mils2iu( -200 ) } ); line3->AddPoint( { Mils2iu( 60 ), Mils2iu( -200 ) } ); LIB_SHAPE* line4 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line4 ); line4->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line4->AddPoint( { Mils2iu( -20 ), Mils2iu( -240 ) } ); line4->AddPoint( { Mils2iu( 20 ), Mils2iu( -240 ) } ); if( aStyle == ASCH_POWER_PORT_STYLE::GOST_POWER_GROUND ) return { 0, Mils2iu( 300 ) }; LIB_SHAPE* circle = new LIB_SHAPE( aKsymbol, SHAPE_T::CIRCLE ); aKsymbol->AddDrawItem( circle ); circle->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); circle->SetPosition( { Mils2iu( 0 ), Mils2iu( -160 ) } ); circle->SetEnd( circle->GetPosition() + VECTOR2I( Mils2iu( 120 ), 0 ) ); return { 0, Mils2iu( 350 ) }; } else if( aStyle == ASCH_POWER_PORT_STYLE::GOST_BAR ) { LIB_SHAPE* line1 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line1 ); line1->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line1->AddPoint( { 0, 0 } ); line1->AddPoint( { 0, Mils2iu( -200 ) } ); LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -100 ), Mils2iu( -200 ) } ); line2->AddPoint( { Mils2iu( 100 ), Mils2iu( -200 ) } ); return { 0, Mils2iu( 250 ) }; } else { if( aStyle != ASCH_POWER_PORT_STYLE::BAR ) { aReporter->Report( _( "Power Port has unknown style, use bar instead." ), RPT_SEVERITY_WARNING ); } LIB_SHAPE* line1 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line1 ); line1->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line1->AddPoint( { 0, 0 } ); line1->AddPoint( { 0, Mils2iu( -100 ) } ); LIB_SHAPE* line2 = new LIB_SHAPE( aKsymbol, SHAPE_T::POLY ); aKsymbol->AddDrawItem( line2 ); line2->SetStroke( STROKE_PARAMS( Mils2iu( 10 ), PLOT_DASH_TYPE::SOLID ) ); line2->AddPoint( { Mils2iu( -50 ), Mils2iu( -100 ) } ); line2->AddPoint( { Mils2iu( 50 ), Mils2iu( -100 ) } ); return { 0, Mils2iu( 150 ) }; } } void SCH_ALTIUM_PLUGIN::ParsePowerPort( const std::map& aProperties ) { ASCH_POWER_PORT elem( aProperties ); LIB_ID libId = AltiumToKiCadLibID( getLibName(), elem.text ); LIB_SYMBOL* libSymbol = nullptr; const auto& powerSymbolIt = m_powerSymbols.find( elem.text ); if( powerSymbolIt != m_powerSymbols.end() ) { libSymbol = powerSymbolIt->second; // cache hit } else { libSymbol = new LIB_SYMBOL( wxEmptyString ); libSymbol->SetPower(); libSymbol->SetName( elem.text ); libSymbol->GetReferenceField().SetText( "#PWR" ); libSymbol->GetValueField().SetText( elem.text ); libSymbol->GetValueField().SetVisible( true ); libSymbol->SetDescription( wxString::Format( _( "Power symbol creates a global " "label with name '%s'" ), elem.text ) ); libSymbol->SetKeyWords( "power-flag" ); libSymbol->SetLibId( libId ); // generate graphic LIB_PIN* pin = new LIB_PIN( libSymbol ); libSymbol->AddDrawItem( pin ); pin->SetName( elem.text ); pin->SetPosition( { 0, 0 } ); pin->SetLength( 0 ); // marks the pin as a global label pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN ); pin->SetVisible( false ); VECTOR2I valueFieldPos = HelperGeneratePowerPortGraphics( libSymbol, elem.style, m_reporter ); libSymbol->GetValueField().SetPosition( valueFieldPos ); // this has to be done after parsing the LIB_SYMBOL! m_pi->SaveSymbol( getLibFileName().GetFullPath(), libSymbol, m_properties.get() ); m_powerSymbols.insert( { elem.text, libSymbol } ); } SCH_SHEET_PATH sheetpath; m_rootSheet->LocatePathOfScreen( m_currentSheet->GetScreen(), &sheetpath ); // each symbol has its own powerSymbolIt for now SCH_SYMBOL* symbol = new SCH_SYMBOL(); symbol->SetRef( &sheetpath, "#PWR?" ); symbol->SetValue( elem.text ); symbol->SetLibId( libId ); symbol->SetLibSymbol( new LIB_SYMBOL( *libSymbol ) ); SCH_FIELD* valueField = symbol->GetField( VALUE_FIELD ); valueField->SetVisible( elem.showNetName ); // TODO: Why do I need to set this a second time? valueField->SetPosition( libSymbol->GetValueField().GetPosition() ); symbol->SetPosition( elem.location + m_sheetOffset ); switch( elem.orientation ) { case ASCH_RECORD_ORIENTATION::RIGHTWARDS: symbol->SetOrientation( SYMBOL_ORIENTATION_T::SYM_ORIENT_90 ); valueField->SetTextAngle( ANGLE_VERTICAL ); valueField->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT ); break; case ASCH_RECORD_ORIENTATION::UPWARDS: symbol->SetOrientation( SYMBOL_ORIENTATION_T::SYM_ORIENT_180 ); valueField->SetTextAngle( ANGLE_HORIZONTAL ); valueField->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER ); break; case ASCH_RECORD_ORIENTATION::LEFTWARDS: symbol->SetOrientation( SYMBOL_ORIENTATION_T::SYM_ORIENT_270 ); valueField->SetTextAngle( ANGLE_VERTICAL ); valueField->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT ); break; case ASCH_RECORD_ORIENTATION::DOWNWARDS: symbol->SetOrientation( SYMBOL_ORIENTATION_T::SYM_ORIENT_0 ); valueField->SetTextAngle( ANGLE_HORIZONTAL ); valueField->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER ); break; default: m_reporter->Report( _( "Pin has unexpected orientation." ), RPT_SEVERITY_WARNING ); break; } m_currentSheet->GetScreen()->Append( symbol ); } void SCH_ALTIUM_PLUGIN::ParsePort( const ASCH_PORT& aElem ) { bool isHarness = !aElem.harnessType.IsEmpty(); VECTOR2I start = aElem.location + m_sheetOffset; VECTOR2I end = start; switch( aElem.style ) { default: case ASCH_PORT_STYLE::NONE_HORIZONTAL: case ASCH_PORT_STYLE::LEFT: case ASCH_PORT_STYLE::RIGHT: case ASCH_PORT_STYLE::LEFT_RIGHT: end.x += aElem.width; break; case ASCH_PORT_STYLE::NONE_VERTICAL: case ASCH_PORT_STYLE::TOP: case ASCH_PORT_STYLE::BOTTOM: case ASCH_PORT_STYLE::TOP_BOTTOM: end.y -= aElem.width; break; } // Check which connection points exists in the schematic SCH_SCREEN* screen = m_currentSheet->GetScreen(); bool startIsWireTerminal = screen->IsTerminalPoint( start, LAYER_WIRE ); bool startIsBusTerminal = screen->IsTerminalPoint( start, LAYER_BUS ); bool endIsWireTerminal = screen->IsTerminalPoint( end, LAYER_WIRE ); bool endIsBusTerminal = screen->IsTerminalPoint( end, LAYER_BUS ); // check if any of the points is a terminal point // TODO: there seems a problem to detect approximated connections towards component pins? bool connectionFound = startIsWireTerminal || startIsBusTerminal || endIsWireTerminal || endIsBusTerminal; if( !isHarness && !connectionFound ) { m_reporter->Report( wxString::Format( _( "Port %s has no connections." ), aElem.name ), RPT_SEVERITY_WARNING ); } // Select label position. In case both match, we will add a line later. VECTOR2I position = ( startIsWireTerminal || startIsBusTerminal ) ? start : end; SCH_LABEL_BASE* label; if( isHarness ) { label = new SCH_DIRECTIVE_LABEL( position ); std::vector& fields = label->GetFields(); fields.emplace_back( SCH_FIELD( { 0, 0 }, 0, label, wxT( "Harness" ) ) ); fields[0].SetText( aElem.harnessType ); fields[0].SetVisible( true ); } // TODO: detect correct label type depending on sheet settings, etc. //{ // label = new SCH_HIERLABEL( elem.location + m_sheetOffset, elem.name ); //} else { label = new SCH_GLOBALLABEL( position, aElem.name ); } switch( aElem.iotype ) { default: case ASCH_PORT_IOTYPE::UNSPECIFIED: label->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED ); break; case ASCH_PORT_IOTYPE::OUTPUT: label->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT ); break; case ASCH_PORT_IOTYPE::INPUT: label->SetShape( LABEL_FLAG_SHAPE::L_INPUT ); break; case ASCH_PORT_IOTYPE::BIDI: label->SetShape( LABEL_FLAG_SHAPE::L_BIDI ); break; } switch( aElem.style ) { default: case ASCH_PORT_STYLE::NONE_HORIZONTAL: case ASCH_PORT_STYLE::LEFT: case ASCH_PORT_STYLE::RIGHT: case ASCH_PORT_STYLE::LEFT_RIGHT: if( ( startIsWireTerminal || startIsBusTerminal ) ) label->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT ); else label->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT ); break; case ASCH_PORT_STYLE::NONE_VERTICAL: case ASCH_PORT_STYLE::TOP: case ASCH_PORT_STYLE::BOTTOM: case ASCH_PORT_STYLE::TOP_BOTTOM: if( ( startIsWireTerminal || startIsBusTerminal ) ) label->SetTextSpinStyle( TEXT_SPIN_STYLE::UP ); else label->SetTextSpinStyle( TEXT_SPIN_STYLE::BOTTOM ); break; } label->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( label ); // This is a hack, for the case both connection points are valid: add a small wire if( ( startIsWireTerminal && endIsWireTerminal ) ) { SCH_LINE* wire = new SCH_LINE( start, SCH_LAYER_ID::LAYER_WIRE ); wire->SetEndPoint( end ); wire->SetLineWidth( Mils2iu( 2 ) ); wire->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( wire ); } else if( startIsBusTerminal && endIsBusTerminal ) { SCH_LINE* wire = new SCH_LINE( start, SCH_LAYER_ID::LAYER_BUS ); wire->SetEndPoint( end ); wire->SetLineWidth( Mils2iu( 2 ) ); wire->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( wire ); } } void SCH_ALTIUM_PLUGIN::ParseNoERC( const std::map& aProperties ) { ASCH_NO_ERC elem( aProperties ); if( elem.isActive ) { SCH_NO_CONNECT* noConnect = new SCH_NO_CONNECT( elem.location + m_sheetOffset ); noConnect->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( noConnect ); } } void SCH_ALTIUM_PLUGIN::ParseNetLabel( const std::map& aProperties ) { ASCH_NET_LABEL elem( aProperties ); SCH_LABEL* label = new SCH_LABEL( elem.location + m_sheetOffset, elem.text ); switch( elem.orientation ) { case ASCH_RECORD_ORIENTATION::RIGHTWARDS: label->SetTextSpinStyle( TEXT_SPIN_STYLE::RIGHT ); break; case ASCH_RECORD_ORIENTATION::UPWARDS: label->SetTextSpinStyle( TEXT_SPIN_STYLE::UP ); break; case ASCH_RECORD_ORIENTATION::LEFTWARDS: label->SetTextSpinStyle( TEXT_SPIN_STYLE::LEFT ); break; case ASCH_RECORD_ORIENTATION::DOWNWARDS: label->SetTextSpinStyle( TEXT_SPIN_STYLE::BOTTOM ); break; default: break; } label->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( label ); } void SCH_ALTIUM_PLUGIN::ParseBus( const std::map& aProperties ) { ASCH_BUS elem( aProperties ); for( size_t i = 0; i + 1 < elem.points.size(); i++ ) { SCH_LINE* bus = new SCH_LINE( elem.points.at( i ) + m_sheetOffset, SCH_LAYER_ID::LAYER_BUS ); bus->SetEndPoint( elem.points.at( i + 1 ) + m_sheetOffset ); bus->SetLineWidth( elem.lineWidth ); bus->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( bus ); } } void SCH_ALTIUM_PLUGIN::ParseWire( const std::map& aProperties ) { ASCH_WIRE elem( aProperties ); for( size_t i = 0; i + 1 < elem.points.size(); i++ ) { SCH_LINE* wire = new SCH_LINE( elem.points.at( i ) + m_sheetOffset, SCH_LAYER_ID::LAYER_WIRE ); wire->SetEndPoint( elem.points.at( i + 1 ) + m_sheetOffset ); wire->SetLineWidth( elem.lineWidth ); wire->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( wire ); } } void SCH_ALTIUM_PLUGIN::ParseJunction( const std::map& aProperties ) { ASCH_JUNCTION elem( aProperties ); SCH_JUNCTION* junction = new SCH_JUNCTION( elem.location + m_sheetOffset ); junction->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( junction ); } void SCH_ALTIUM_PLUGIN::ParseImage( const std::map& aProperties ) { ASCH_IMAGE elem( aProperties ); VECTOR2I center = ( elem.location + elem.corner ) / 2 + m_sheetOffset; std::unique_ptr bitmap = std::make_unique( center ); if( elem.embedimage ) { const ASCH_STORAGE_FILE* storageFile = GetFileFromStorage( elem.filename ); if( !storageFile ) { wxString msg = wxString::Format( _( "Embedded file %s not found in storage." ), elem.filename ); m_reporter->Report( msg, RPT_SEVERITY_ERROR ); return; } wxString storagePath = wxFileName::CreateTempFileName( "kicad_import_" ); // As wxZlibInputStream is not seekable, we need to write a temporary file wxMemoryInputStream fileStream( storageFile->data.data(), storageFile->data.size() ); wxZlibInputStream zlibInputStream( fileStream ); wxFFileOutputStream outputStream( storagePath ); outputStream.Write( zlibInputStream ); outputStream.Close(); if( !bitmap->ReadImageFile( storagePath ) ) { m_reporter->Report( wxString::Format( _( "Error reading image %s." ), storagePath ), RPT_SEVERITY_ERROR ); return; } // Remove temporary file wxRemoveFile( storagePath ); } else { if( !wxFileExists( elem.filename ) ) { m_reporter->Report( wxString::Format( _( "File not found %s." ), elem.filename ), RPT_SEVERITY_ERROR ); return; } if( !bitmap->ReadImageFile( elem.filename ) ) { m_reporter->Report( wxString::Format( _( "Error reading image %s." ), elem.filename ), RPT_SEVERITY_ERROR ); return; } } // we only support one scale, thus we need to select one in case it does not keep aspect ratio wxSize currentImageSize = bitmap->GetSize(); VECTOR2I expectedImageSize = elem.location - elem.corner; double scaleX = std::abs( static_cast( expectedImageSize.x ) / currentImageSize.x ); double scaleY = std::abs( static_cast( expectedImageSize.y ) / currentImageSize.y ); bitmap->SetImageScale( std::min( scaleX, scaleY ) ); bitmap->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( bitmap.release() ); } void SCH_ALTIUM_PLUGIN::ParseSheet( const std::map& aProperties ) { m_altiumSheet = std::make_unique( aProperties ); PAGE_INFO pageInfo; bool isPortrait = m_altiumSheet->sheetOrientation == ASCH_SHEET_WORKSPACEORIENTATION::PORTRAIT; switch( m_altiumSheet->sheetSize ) { default: case ASCH_SHEET_SIZE::A4: pageInfo.SetType( "A4", isPortrait ); break; case ASCH_SHEET_SIZE::A3: pageInfo.SetType( "A3", isPortrait ); break; case ASCH_SHEET_SIZE::A2: pageInfo.SetType( "A2", isPortrait ); break; case ASCH_SHEET_SIZE::A1: pageInfo.SetType( "A1", isPortrait ); break; case ASCH_SHEET_SIZE::A0: pageInfo.SetType( "A0", isPortrait ); break; case ASCH_SHEET_SIZE::A: pageInfo.SetType( "A", isPortrait ); break; case ASCH_SHEET_SIZE::B: pageInfo.SetType( "B", isPortrait ); break; case ASCH_SHEET_SIZE::C: pageInfo.SetType( "C", isPortrait ); break; case ASCH_SHEET_SIZE::D: pageInfo.SetType( "D", isPortrait ); break; case ASCH_SHEET_SIZE::E: pageInfo.SetType( "E", isPortrait ); break; case ASCH_SHEET_SIZE::LETTER: pageInfo.SetType( "USLetter", isPortrait ); break; case ASCH_SHEET_SIZE::LEGAL: pageInfo.SetType( "USLegal", isPortrait ); break; case ASCH_SHEET_SIZE::TABLOID: pageInfo.SetType( "A3", isPortrait ); break; case ASCH_SHEET_SIZE::ORCAD_A: pageInfo.SetType( "A", isPortrait ); break; case ASCH_SHEET_SIZE::ORCAD_B: pageInfo.SetType( "B", isPortrait ); break; case ASCH_SHEET_SIZE::ORCAD_C: pageInfo.SetType( "C", isPortrait ); break; case ASCH_SHEET_SIZE::ORCAD_D: pageInfo.SetType( "D", isPortrait ); break; case ASCH_SHEET_SIZE::ORCAD_E: pageInfo.SetType( "E", isPortrait ); break; } m_currentSheet->GetScreen()->SetPageSettings( pageInfo ); m_sheetOffset = { 0, pageInfo.GetHeightIU() }; } void SCH_ALTIUM_PLUGIN::ParseSheetName( const std::map& aProperties ) { ASCH_SHEET_NAME elem( aProperties ); const auto& sheetIt = m_sheets.find( elem.ownerindex ); if( sheetIt == m_sheets.end() ) { m_reporter->Report( wxString::Format( _( "Sheetname's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } SCH_FIELD& sheetNameField = sheetIt->second->GetFields()[SHEETNAME]; sheetNameField.SetPosition( elem.location + m_sheetOffset ); sheetNameField.SetText( elem.text ); sheetNameField.SetVisible( !elem.isHidden ); SetTextPositioning( &sheetNameField, ASCH_LABEL_JUSTIFICATION::BOTTOM_LEFT, elem.orientation ); } void SCH_ALTIUM_PLUGIN::ParseFileName( const std::map& aProperties ) { ASCH_FILE_NAME elem( aProperties ); const auto& sheetIt = m_sheets.find( elem.ownerindex ); if( sheetIt == m_sheets.end() ) { m_reporter->Report( wxString::Format( _( "Filename's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } SCH_FIELD& filenameField = sheetIt->second->GetFields()[SHEETFILENAME]; filenameField.SetPosition( elem.location + m_sheetOffset ); // If last symbols are ".sChDoC", change them to ".kicad_sch" if( ( elem.text.Right( GetFileExtension().length() + 1 ).Lower() ) == ( "." + GetFileExtension().Lower() ) ) { elem.text.RemoveLast( GetFileExtension().length() ); elem.text += KiCadSchematicFileExtension; } filenameField.SetText( elem.text ); filenameField.SetVisible( !elem.isHidden ); SetTextPositioning( &filenameField, ASCH_LABEL_JUSTIFICATION::BOTTOM_LEFT, elem.orientation ); } void SCH_ALTIUM_PLUGIN::ParseDesignator( const std::map& aProperties ) { ASCH_DESIGNATOR elem( aProperties ); const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 m_reporter->Report( wxString::Format( _( "Designator's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); SCH_SHEET_PATH sheetpath; m_rootSheet->LocatePathOfScreen( m_currentSheet->GetScreen(), &sheetpath ); // Graphics symbols have no reference. '#GRAPHIC' allows them to not have footprint associated. // Note: not all unnamed imported symbols are necessarilly graphics. bool emptyRef = elem.text.IsEmpty(); symbol->SetRef( &sheetpath, emptyRef ? "#GRAPHIC" : elem.text ); SCH_FIELD* field = symbol->GetField( VALUE_FIELD ); if ( emptyRef ) field->SetVisible( false ); field = symbol->GetField( REFERENCE_FIELD ); if ( emptyRef ) field->SetVisible( false ); field->SetPosition( elem.location + m_sheetOffset ); SetTextPositioning( field, elem.justification, elem.orientation ); } void SCH_ALTIUM_PLUGIN::ParseBusEntry( const std::map& aProperties ) { ASCH_BUS_ENTRY elem( aProperties ); SCH_BUS_WIRE_ENTRY* busWireEntry = new SCH_BUS_WIRE_ENTRY( elem.location + m_sheetOffset ); VECTOR2I vector = elem.corner - elem.location; busWireEntry->SetSize( { vector.x, vector.y } ); busWireEntry->SetFlags( IS_NEW ); m_currentSheet->GetScreen()->Append( busWireEntry ); } void SCH_ALTIUM_PLUGIN::ParseParameter( const std::map& aProperties ) { ASCH_PARAMETER elem( aProperties ); // TODO: fill in replacements from variant, sheet and project std::map variableMap = { { "COMMENT", "VALUE" }, { "VALUE", "ALTIUM_VALUE" }, }; if( elem.ownerindex <= 0 && elem.ownerpartid == ALTIUM_COMPONENT_NONE ) { // This is some sheet parameter if( elem.text == "*" ) return; // indicates parameter not set? wxString paramName = elem.name.Upper(); if( paramName == "SHEETNUMBER" ) { SCH_SHEET_PATH sheetpath; m_rootSheet->LocatePathOfScreen( m_currentSheet->GetScreen(), &sheetpath ); m_rootSheet->SetPageNumber( sheetpath, elem.text ); } else if( paramName == "TITLE" ) { m_currentTitleBlock->SetTitle( elem.text ); } else if( paramName == "REVISION" ) { m_currentTitleBlock->SetRevision( elem.text ); } else if( paramName == "DATE" ) { m_currentTitleBlock->SetDate( elem.text ); } else if( paramName == "COMPANYNAME" ) { m_currentTitleBlock->SetCompany( elem.text ); } else { m_schematic->Prj().GetTextVars()[ paramName ] = elem.text; } } else { const auto& libSymbolIt = m_libSymbols.find( elem.ownerindex ); if( libSymbolIt == m_libSymbols.end() ) { // TODO: e.g. can depend on Template (RECORD=39 return; } SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); SCH_FIELD* field = nullptr; wxString upperName = elem.name.Upper(); if( upperName == "COMMENT" ) { field = symbol->GetField( VALUE_FIELD ); } else { int fieldIdx = symbol->GetFieldCount(); wxString fieldName = elem.name.Upper(); if( fieldName.IsEmpty() ) { int disambiguate = 1; do { fieldName = wxString::Format( "ALTIUM_UNNAMED_%d", disambiguate++ ); } while( !symbol->GetFieldText( fieldName ).IsEmpty() ); } else if( fieldName == "VALUE" ) { fieldName = "ALTIUM_VALUE"; } field = symbol->AddField( SCH_FIELD( VECTOR2I(), fieldIdx, symbol, fieldName ) ); } wxString kicadText = AltiumSpecialStringsToKiCadVariables( elem.text, variableMap ); field->SetText( kicadText ); field->SetPosition( elem.location + m_sheetOffset ); field->SetVisible( !elem.isHidden ); SetTextPositioning( field, elem.justification, elem.orientation ); } } void SCH_ALTIUM_PLUGIN::ParseImplementationList( int aIndex, const std::map& aProperties ) { ASCH_IMPLEMENTATION_LIST elem( aProperties ); m_altiumImplementationList.emplace( aIndex, elem.ownerindex ); } void SCH_ALTIUM_PLUGIN::ParseImplementation( const std::map& aProperties ) { ASCH_IMPLEMENTATION elem( aProperties ); // Only get footprint, currently assigned only if( ( elem.type == "PCBLIB" ) && ( elem.isCurrent ) ) { const auto& implementationOwnerIt = m_altiumImplementationList.find( elem.ownerindex ); if( implementationOwnerIt == m_altiumImplementationList.end() ) { m_reporter->Report( wxString::Format( _( "Implementation's owner (%d) not found." ), elem.ownerindex ), RPT_SEVERITY_ERROR ); return; } const auto& libSymbolIt = m_libSymbols.find( implementationOwnerIt->second ); if( libSymbolIt == m_libSymbols.end() ) { m_reporter->Report( wxString::Format( _( "Footprint's owner (%d) not found." ), implementationOwnerIt->second ), RPT_SEVERITY_ERROR ); return; } LIB_ID fpLibId = AltiumToKiCadLibID( elem.libname, elem.name ); wxArrayString fpFilters; fpFilters.Add( fpLibId.Format() ); libSymbolIt->second->SetFPFilters( fpFilters ); // TODO: not ideal as we overwrite it SCH_SYMBOL* symbol = m_symbols.at( libSymbolIt->first ); symbol->SetFootprint( fpLibId.Format() ); } }