sch_easyedapro_parser.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2023 Alex Shvartzkop <[email protected]>
 * Copyright (C) 2023 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 "sch_easyedapro_parser.h"
#include <io/easyedapro/easyedapro_import_utils.h>
 
#include <core/map_helpers.h>
 
#include <sch_io/sch_io_mgr.h>
#include <schematic.h>
#include <sch_sheet.h>
#include <sch_line.h>
#include <sch_bitmap.h>
#include <sch_no_connect.h>
#include <sch_label.h>
#include <sch_junction.h>
#include <sch_edit_frame.h>
#include <sch_shape.h>
#include <string_utils.h>
#include <bezier_curves.h>
#include <wx/base64.h>
#include <wx/url.h>
#include <wx/mstream.h>
#include <gfx_import_utils.h>
#include <import_gfx/svg_import_plugin.h>
#include <import_gfx/graphics_importer_lib_symbol.h>
#include <import_gfx/graphics_importer_sch.h>
 
 
SCH_EASYEDAPRO_PARSER::SCH_EASYEDAPRO_PARSER( SCHEMATIC* aSchematic,
 PROGRESS_REPORTER* aProgressReporter )
{
 m_schematic = aSchematic;
}
 
 
SCH_EASYEDAPRO_PARSER::~SCH_EASYEDAPRO_PARSER()
{
}
 
 
double SCH_EASYEDAPRO_PARSER::Convert( wxString aValue )
{
 double value = 0;
 
 if( !aValue.ToCDouble( &value ) )
 THROW_IO_ERROR( wxString::Format( _( "Failed to parse value: '%s'" ), aValue ) );
 
 return value;
}
 
 
double SCH_EASYEDAPRO_PARSER::SizeToKi( wxString aValue )
{
 return ScaleSize( Convert( aValue ) );
}
 
 
static LINE_STYLE ConvertStrokeStyle( int aStyle )
{
 if( aStyle == 0 )
 return LINE_STYLE::SOLID;
 else if( aStyle == 1 )
 return LINE_STYLE::DASH;
 else if( aStyle == 2 )
 return LINE_STYLE::DOT;
 else if( aStyle == 3 )
 return LINE_STYLE::DASHDOT;
 
 return LINE_STYLE::DEFAULT;
}
 
 
template <typename T>
void SCH_EASYEDAPRO_PARSER::ApplyFontStyle( const std::map<wxString, nlohmann::json>& fontStyles,
 T& text, const wxString& styleStr )
{
 auto it = fontStyles.find( styleStr );
 
 if( it == fontStyles.end() )
 return;
 
 nlohmann::json style = it->second;
 
 if( !style.is_array() )
 return;
 
 if( style.size() < 12 )
 return;
 
 if( style.at( 3 ).is_string() )
 {
 COLOR4D color( style.at( 3 ).get<wxString>() );
 text->SetTextColor( color );
 }
 
 if( style.at( 4 ).is_string() )
 {
 wxString fontname = ( style.at( 4 ) );
 
 if( !fontname.IsSameAs( wxS( "default" ), false ) )
 text->SetFont( KIFONT::FONT::GetFont( fontname ) );
 }
 
 if( style.at( 5 ).is_number() )
 {
 double size = style.at( 5 ).get<double>() * 0.5;
 text->SetTextSize( VECTOR2I( ScaleSize( size ), ScaleSize( size ) ) );
 }
 
 if( style.at( 10 ).is_number() )
 {
 int valign = style.at( 10 );
 
 if( !text->GetText().Contains( wxS( "\n" ) ) )
 {
 if( valign == 0 )
 text->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 else if( valign == 1 )
 text->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 else if( valign == 2 )
 text->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 }
 else
 {
 text->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 // TODO: align by first line
 }
 }
 else
 {
 text->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 }
 
 if( style.at( 11 ).is_number() )
 {
 int halign = style.at( 11 );
 
 if( halign == 0 )
 text->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 else if( halign == 1 )
 text->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 else if( halign == 2 )
 text->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 }
 else
 {
 text->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 }
}
 
 
template <typename T>
void SCH_EASYEDAPRO_PARSER::ApplyLineStyle( const std::map<wxString, nlohmann::json>& lineStyles,
 T& shape, const wxString& styleStr )
{
 auto it = lineStyles.find( styleStr );
 
 if( it == lineStyles.end() )
 return;
 
 nlohmann::json style = it->second;
 
 if( !style.is_array() )
 return;
 
 if( style.size() < 6 )
 return;
 
 STROKE_PARAMS stroke = shape->GetStroke();
 
 if( style.at( 2 ).is_string() )
 {
 wxString colorStr = style.at( 2 ).get<wxString>();
 
 if( !colorStr.empty() && colorStr.starts_with( wxS( "#" ) ) )
 {
 COLOR4D color( colorStr );
 stroke.SetColor( color );
 }
 }
 
 if( style.at( 3 ).is_number() )
 {
 int dashStyle = style.at( 3 );
 stroke.SetLineStyle( ConvertStrokeStyle( dashStyle ) );
 }
 
 if( style.at( 5 ).is_number() )
 {
 double thickness = style.at( 5 );
 stroke.SetWidth( ScaleSize( thickness ) );
 }
 
 shape->SetStroke( stroke );
}
 
 
wxString SCH_EASYEDAPRO_PARSER::ResolveFieldVariables(
 const wxString aInput, const std::map<wxString, wxString>& aDeviceAttributes )
{
 wxString inputText = aInput;
 wxString resolvedText;
 int variableCount = 0;
 
 // Resolve variables
 // ={Variable1}text{Variable2}
 do
 {
 if( !inputText.StartsWith( wxS( "={" ) ) )
 return inputText;
 
 resolvedText.Clear();
 variableCount = 0;
 
 for( size_t i = 1; i < inputText.size(); )
 {
 wxUniChar c = inputText[i++];
 
 if( c == '{' )
 {
 wxString varName;
 bool endFound = false;
 
 while( i < inputText.size() )
 {
 c = inputText[i++];
 
 if( c == '}' )
 {
 endFound = true;
 break;
 }
 
 varName << c;
 }
 
 if( !endFound )
 return inputText;
 
 wxString varValue =
 get_def( aDeviceAttributes, varName, wxString::Format( "{%s!}", varName ) );
 
 resolvedText << varValue;
 variableCount++;
 }
 else
 {
 resolvedText << c;
 }
 }
 inputText = resolvedText;
 
 } while( variableCount > 0 );
 
 return resolvedText;
}
 
 
template <typename T>
void SCH_EASYEDAPRO_PARSER::ApplyAttrToField( const std::map<wxString, nlohmann::json>& fontStyles,
 T* field, const EASYEDAPRO::SCH_ATTR& aAttr,
 bool aIsSym, bool aToSym,
 const std::map<wxString, wxString>& aDeviceAttributes,
 SCH_SYMBOL* aParent )
{
 EDA_TEXT* text = static_cast<EDA_TEXT*>( field );
 
 text->SetText( ResolveFieldVariables( aAttr.value, aDeviceAttributes ) );
 text->SetVisible( aAttr.keyVisible || aAttr.valVisible );
 
 field->SetNameShown( aAttr.keyVisible );
 
 if( aAttr.position )
 {
 field->SetPosition( !aIsSym ? ScalePos( *aAttr.position )
 : ScalePosSym( *aAttr.position ) );
 }
 
 ApplyFontStyle( fontStyles, text, aAttr.fontStyle );
 
 auto parent = aParent;
 if( parent && parent->Type() == SCH_SYMBOL_T )
 {
 int orient = static_cast<SCH_SYMBOL*>( parent )->GetOrientation();
 
 if( orient == SYM_ORIENT_180 )
 {
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 else if( orient == SYM_MIRROR_X + SYM_ORIENT_0 )
 {
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 }
 else if( orient == SYM_MIRROR_Y + SYM_ORIENT_0 )
 {
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 else if( orient == SYM_MIRROR_Y + SYM_ORIENT_180 )
 {
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( text->GetHorizJustify() ) );
 }
 else if( orient == SYM_ORIENT_90 )
 {
 text->SetTextAngle( ANGLE_VERTICAL );
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 if( orient == SYM_ORIENT_270 )
 {
 text->SetTextAngle( ANGLE_VERTICAL );
 }
 else if( orient == SYM_MIRROR_X + SYM_ORIENT_90 )
 {
 text->SetTextAngle( ANGLE_VERTICAL );
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 else if( orient == SYM_MIRROR_X + SYM_ORIENT_270 )
 {
 text->SetTextAngle( ANGLE_VERTICAL );
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 }
 else if( orient == SYM_MIRROR_Y + SYM_ORIENT_90 )
 {
 text->SetTextAngle( ANGLE_VERTICAL );
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 else if( orient == SYM_MIRROR_Y + SYM_ORIENT_270 )
 {
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( text->GetHorizJustify() ) );
 }
 
 if( aAttr.rotation == 90 )
 {
 if( text->GetTextAngle() == ANGLE_HORIZONTAL )
 text->SetTextAngle( ANGLE_VERTICAL );
 else
 text->SetTextAngle( ANGLE_HORIZONTAL );
 
 if( orient == SYM_ORIENT_90 )
 {
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 if( orient == SYM_ORIENT_270 )
 {
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 text->SetHorizJustify( static_cast<GR_TEXT_H_ALIGN_T>( -text->GetHorizJustify() ) );
 }
 else if( orient == SYM_MIRROR_X + SYM_ORIENT_90 )
 {
 text->SetVertJustify( static_cast<GR_TEXT_V_ALIGN_T>( -text->GetVertJustify() ) );
 }
 }
 }
}
 
 
EASYEDAPRO::SYM_INFO SCH_EASYEDAPRO_PARSER::ParseSymbol( const std::vector<nlohmann::json>& aLines )
{
 EASYEDAPRO::SYM_INFO symInfo;
 
 std::unique_ptr<LIB_SYMBOL> ksymbolPtr = std::make_unique<LIB_SYMBOL>( wxEmptyString );
 LIB_SYMBOL* ksymbol = ksymbolPtr.get();
 
 std::map<wxString, nlohmann::json> lineStyles;
 std::map<wxString, nlohmann::json> fontStyles;
 std::map<wxString, int> partUnits;
 
 std::map<int, std::map<wxString, EASYEDAPRO::SCH_ATTR>> unitAttributes;
 std::map<int, std::map<wxString, std::vector<nlohmann::json>>> unitParentedLines;
 
 int totalUnits = 0;
 
 for( const nlohmann::json& line : aLines )
 {
 wxString type = line.at( 0 );
 
 if( type == wxS( "LINESTYLE" ) )
 lineStyles[line.at( 1 )] = line;
 else if( type == wxS( "FONTSTYLE" ) )
 fontStyles[line.at( 1 )] = line;
 else if( type == wxS( "PART" ) )
 partUnits[line.at( 1 )] = ++totalUnits;
 }
 
 symInfo.partUnits = partUnits;
 ksymbol->SetUnitCount( totalUnits, false );
 
 int currentUnit = 1;
 
 for( const nlohmann::json& line : aLines )
 {
 wxString type = line.at( 0 );
 
 if( type == wxS( "PART" ) )
 {
 currentUnit = partUnits.at( line.at( 1 ) );
 }
 else if( type == wxS( "RECT" ) )
 {
 VECTOR2D start( line.at( 2 ), line.at( 3 ) );
 VECTOR2D end( line.at( 4 ), line.at( 5 ) );
 wxString styleStr = line.at( 9 );
 
 auto rect = std::make_unique<SCH_SHAPE>( SHAPE_T::RECTANGLE, LAYER_DEVICE );
 
 rect->SetStart( ScalePosSym( start ) );
 rect->SetEnd( ScalePosSym( end ) );
 
 rect->SetUnit( currentUnit );
 ApplyLineStyle( lineStyles, rect, styleStr );
 
 ksymbol->AddDrawItem( rect.release() );
 }
 else if( type == wxS( "CIRCLE" ) )
 {
 VECTOR2D center( line.at( 2 ), line.at( 3 ) );
 double radius = line.at( 4 );
 wxString styleStr = line.at( 5 );
 
 auto circle = std::make_unique<SCH_SHAPE>( SHAPE_T::CIRCLE, LAYER_DEVICE );
 
 circle->SetCenter( ScalePosSym( center ) );
 circle->SetEnd( circle->GetCenter() + VECTOR2I( ScaleSize( radius ), 0 ) );
 
 circle->SetUnit( currentUnit );
 ApplyLineStyle( lineStyles, circle, styleStr );
 
 ksymbol->AddDrawItem( circle.release() );
 }
 else if( type == wxS( "ARC" ) )
 {
 VECTOR2D start( line.at( 2 ), line.at( 3 ) );
 VECTOR2D mid( line.at( 4 ), line.at( 5 ) );
 VECTOR2D end( line.at( 6 ), line.at( 7 ) );
 wxString styleStr = line.at( 8 );
 
 VECTOR2D kstart = ScalePosSym( start );
 VECTOR2D kmid = ScalePosSym( mid );
 VECTOR2D kend = ScalePosSym( end );
 
 VECTOR2D kcenter = CalcArcCenter( kstart, kmid, kend );
 
 auto shape = std::make_unique<SCH_SHAPE>( SHAPE_T::ARC, LAYER_DEVICE );
 
 shape->SetStart( kstart );
 shape->SetEnd( kend );
 shape->SetCenter( kcenter );
 
 if( SEG( start, end ).Side( mid ) != SEG( kstart, kend ).Side( shape->GetArcMid() ) )
 {
 shape->SetStart( kend );
 shape->SetEnd( kstart );
 }
 
 shape->SetUnit( currentUnit );
 ApplyLineStyle( lineStyles, shape, styleStr );
 
 ksymbol->AddDrawItem( shape.release() );
 }
 else if( type == wxS( "POLY" ) )
 {
 std::vector<double> points = line.at( 2 );
 wxString styleStr = line.at( 4 );
 
 auto shape = std::make_unique<SCH_SHAPE>( SHAPE_T::POLY, LAYER_DEVICE );
 
 for( size_t i = 1; i < points.size(); i += 2 )
 shape->AddPoint( ScalePosSym( VECTOR2D( points[i - 1], points[i] ) ) );
 
 shape->SetUnit( currentUnit );
 ApplyLineStyle( lineStyles, shape, styleStr );
 
 ksymbol->AddDrawItem( shape.release() );
 }
 else if( type == wxS( "TEXT" ) )
 {
 VECTOR2D pos( line.at( 2 ), line.at( 3 ) );
 double angle = line.at( 4 );
 wxString textStr = line.at( 5 );
 wxString fontStyleStr = line.at( 6 );
 
 auto text = std::make_unique<SCH_TEXT>( ScalePosSym( pos ), UnescapeHTML( textStr ),
 LAYER_DEVICE );
 
 text->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 text->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 text->SetTextAngleDegrees( angle );
 
 text->SetUnit( currentUnit );
 ApplyFontStyle( fontStyles, text, fontStyleStr );
 
 ksymbol->AddDrawItem( text.release() );
 }
 else if( type == wxS( "OBJ" ) )
 {
 VECTOR2D start, size;
 wxString mimeType, data;
 //double angle = 0;
 int upsideDown = 0;
 
 if( line.at( 3 ).is_number() )
 {
 start = VECTOR2D( line.at( 3 ), line.at( 4 ) );
 size = VECTOR2D( line.at( 5 ), line.at( 6 ) );
 //angle = line.at( 7 );
 upsideDown = line.at( 8 );
 
 wxString imageUrl = line.at( 9 );
 
 if( imageUrl.BeforeFirst( ':' ) == wxS( "data" ) )
 {
 wxArrayString paramsArr =
 wxSplit( imageUrl.AfterFirst( ':' ).BeforeFirst( ',' ), ';', '\0' );
 
 data = imageUrl.AfterFirst( ',' );
 
 if( paramsArr.size() > 0 )
 {
 mimeType = paramsArr[0];
 }
 }
 }
 else if( line.at( 3 ).is_string() )
 {
 mimeType = line.at( 3 ).get<wxString>().BeforeFirst( ';' );
 
 start = VECTOR2D( line.at( 4 ), line.at( 5 ) );
 size = VECTOR2D( line.at( 6 ), line.at( 7 ) );
 //angle = line.at( 8 );
 data = line.at( 9 ).get<wxString>();
 }
 
 if( mimeType.empty() || data.empty() )
 continue;
 
 wxMemoryBuffer buf = wxBase64Decode( data );
 
 if( mimeType == wxS( "image/svg+xml" ) )
 {
 VECTOR2D offset = ScalePosSym( start );
 
 SVG_IMPORT_PLUGIN svgImportPlugin;
 GRAPHICS_IMPORTER_LIB_SYMBOL libsymImporter( ksymbol, 0 );
 
 svgImportPlugin.SetImporter( &libsymImporter );
 svgImportPlugin.LoadFromMemory( buf );
 
 VECTOR2D imSize( svgImportPlugin.GetImageWidth(),
 svgImportPlugin.GetImageHeight() );
 
 VECTOR2D pixelScale( schIUScale.IUTomm( ScaleSize( size.x ) ) / imSize.x,
 schIUScale.IUTomm( -ScaleSize( size.y ) ) / imSize.y );
 
 if( upsideDown )
 pixelScale.y *= -1;
 
 libsymImporter.SetScale( pixelScale );
 
 VECTOR2D offsetMM( schIUScale.IUTomm( offset.x ), schIUScale.IUTomm( offset.y ) );
 
 libsymImporter.SetImportOffsetMM( offsetMM );
 
 svgImportPlugin.Import();
 
 // TODO: rotation
 for( std::unique_ptr<EDA_ITEM>& item : libsymImporter.GetItems() )
 ksymbol->AddDrawItem( static_cast<SCH_ITEM*>( item.release() ) );
 }
 else
 {
 wxMemoryInputStream memis( buf.GetData(), buf.GetDataLen() );
 
 wxImage::SetDefaultLoadFlags( wxImage::GetDefaultLoadFlags()
 & ~wxImage::Load_Verbose );
 wxImage img;
 if( img.LoadFile( memis, mimeType ) )
 {
 int dimMul = img.GetWidth() * img.GetHeight();
 double maxPixels = 30000;
 
 if( dimMul > maxPixels )
 {
 double scale = sqrt( maxPixels / dimMul );
 img.Rescale( img.GetWidth() * scale, img.GetHeight() * scale );
 }
 
 VECTOR2D pixelScale( ScaleSize( size.x ) / img.GetWidth(),
 -ScaleSize( size.y ) / img.GetHeight() );
 
 // TODO: rotation
 ConvertImageToLibShapes( ksymbol, 0, img, pixelScale, ScalePosSym( start ) );
 }
 }
 }
 else if( type == wxS( "HEAD" ) )
 {
 symInfo.head = line;
 }
 else if( type == wxS( "PIN" ) )
 {
 wxString pinId = line.at( 1 );
 unitParentedLines[currentUnit][pinId].push_back( line );
 }
 else if( type == wxS( "ATTR" ) )
 {
 wxString parentId = line.at( 2 );
 
 if( parentId.empty() )
 {
 EASYEDAPRO::SCH_ATTR attr = line;
 unitAttributes[currentUnit].emplace( attr.key, attr );
 }
 else
 {
 unitParentedLines[currentUnit][parentId].push_back( line );
 }
 }
 }
 
 if( symInfo.head.symbolType == EASYEDAPRO::SYMBOL_TYPE::POWER_PORT
 || symInfo.head.symbolType == EASYEDAPRO::SYMBOL_TYPE::NETPORT )
 {
 ksymbol->SetPower();
 ksymbol->GetReferenceField().SetText( wxS( "#PWR" ) );
 ksymbol->GetReferenceField().SetVisible( false );
 ksymbol->SetKeyWords( wxS( "power-flag" ) );
 ksymbol->SetShowPinNames( false );
 ksymbol->SetShowPinNumbers( false );
 
 if( auto globalNetAttr = get_opt( unitAttributes[1], wxS( "Global Net Name" ) ) )
 {
 ApplyAttrToField( fontStyles, &ksymbol->GetValueField(), *globalNetAttr, true, true );
 
 wxString globalNetname = globalNetAttr->value;
 
 if( !globalNetname.empty() )
 {
 ksymbol->SetDescription( wxString::Format(
 _( "Power symbol creates a global label with name '%s'" ),
 globalNetname ) );
 }
 }
 }
 else
 {
 auto designatorAttr = get_opt( unitAttributes[1], wxS( "Designator" ) );
 
 if( designatorAttr && !designatorAttr->value.empty() )
 {
 wxString symbolPrefix = designatorAttr->value;
 
 if( !symbolPrefix.EndsWith( wxS( "?" ) ) )
 symbolPrefix += wxS( "?" );
 
 ksymbol->GetReferenceField().SetText( symbolPrefix );
 }
 }
 
 for( auto& [unitId, parentedLines] : unitParentedLines )
 {
 for( auto& [pinId, lines] : parentedLines )
 {
 std::optional<EASYEDAPRO::SYM_PIN> epin;
 std::map<wxString, EASYEDAPRO::SCH_ATTR> pinAttributes;
 
 for( const nlohmann::json& line : lines )
 {
 wxString type = line.at( 0 );
 
 if( type == wxS( "ATTR" ) )
 {
 EASYEDAPRO::SCH_ATTR attr = line;
 pinAttributes.emplace( attr.key, attr );
 }
 else if( type == wxS( "PIN" ) )
 {
 epin = line;
 }
 }
 
 if( !epin )
 continue;
 
 EASYEDAPRO::PIN_INFO pinInfo;
 pinInfo.pin = *epin;
 
 std::unique_ptr<SCH_PIN> pin = std::make_unique<SCH_PIN>( ksymbol );
 
 pin->SetUnit( unitId );
 
 pin->SetLength( ScaleSize( epin->length ) );
 pin->SetPosition( ScalePosSym( epin->position ) );
 
 PIN_ORIENTATION orient = PIN_ORIENTATION::PIN_RIGHT;
 
 if( epin->rotation == 0 )
 orient = PIN_ORIENTATION::PIN_RIGHT;
 if( epin->rotation == 90 )
 orient = PIN_ORIENTATION::PIN_UP;
 if( epin->rotation == 180 )
 orient = PIN_ORIENTATION::PIN_LEFT;
 if( epin->rotation == 270 )
 orient = PIN_ORIENTATION::PIN_DOWN;
 
 pin->SetOrientation( orient );
 
 if( symInfo.head.symbolType == EASYEDAPRO::SYMBOL_TYPE::POWER_PORT )
 {
 pin->SetName( ksymbol->GetName() );
 //pin->SetVisible( false );
 }
 else if( auto pinNameAttr = get_opt( pinAttributes, "NAME" ) )
 {
 pin->SetName( pinNameAttr->value );
 pinInfo.name = pinNameAttr->value;
 
 if( !pinNameAttr->valVisible )
 pin->SetNameTextSize( schIUScale.MilsToIU( 1 ) );
 }
 
 if( auto pinNumAttr = get_opt( pinAttributes, "NUMBER" ) )
 {
 pin->SetNumber( pinNumAttr->value );
 pinInfo.number = pinNumAttr->value;
 
 if( !pinNumAttr->valVisible )
 pin->SetNumberTextSize( schIUScale.MilsToIU( 1 ) );
 }
 
 if( symInfo.head.symbolType == EASYEDAPRO::SYMBOL_TYPE::POWER_PORT )
 {
 pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
 }
 else if( auto pinTypeAttr = get_opt( pinAttributes, "Pin Type" ) )
 {
 if( pinTypeAttr->value == wxS( "IN" ) )
 pin->SetType( ELECTRICAL_PINTYPE::PT_INPUT );
 if( pinTypeAttr->value == wxS( "OUT" ) )
 pin->SetType( ELECTRICAL_PINTYPE::PT_OUTPUT );
 if( pinTypeAttr->value == wxS( "BI" ) )
 pin->SetType( ELECTRICAL_PINTYPE::PT_BIDI );
 }
 
 if( get_opt( pinAttributes, "NO_CONNECT" ) )
 pin->SetType( ELECTRICAL_PINTYPE::PT_NC );
 
 if( pin->GetNumberTextSize() * int( pin->GetNumber().size() ) > pin->GetLength() )
 pin->SetNumberTextSize( pin->GetLength() / pin->GetNumber().size() );
 
 symInfo.pins.push_back( pinInfo );
 ksymbol->AddDrawItem( pin.release() );
 }
 }
 
 symInfo.symbolAttr = get_opt( unitAttributes[1], "Symbol" ); // TODO: per-unit
 
 /*BOX2I bbox = ksymbol->GetBodyBoundingBox( 0, 0, true, true );
 bbox.Inflate( schIUScale.MilsToIU( 10 ) );*/
 
 /*ksymbol->GetReferenceField().SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 ksymbol->GetReferenceField().SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 ksymbol->GetReferenceField().SetPosition( VECTOR2I( bbox.GetCenter().x, -bbox.GetTop() ) );
 
 ksymbol->GetValueField().SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 ksymbol->GetValueField().SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 ksymbol->GetValueField().SetPosition( VECTOR2I( bbox.GetCenter().x, -bbox.GetBottom() ) );*/
 
 symInfo.libSymbol = std::move( ksymbolPtr );
 
 return symInfo;
}
 
 
void SCH_EASYEDAPRO_PARSER::ParseSchematic( SCHEMATIC* aSchematic, SCH_SHEET* aRootSheet,
 const nlohmann::json& aProject,
 std::map<wxString, EASYEDAPRO::SYM_INFO>& aSymbolMap,
 const std::map<wxString, EASYEDAPRO::BLOB>& aBlobMap,
 const std::vector<nlohmann::json>& aLines,
 const wxString& aLibName )
{
 std::vector<std::unique_ptr<SCH_ITEM>> createdItems;
 
 std::map<wxString, std::vector<nlohmann::json>> parentedLines;
 std::map<wxString, std::vector<nlohmann::json>> ruleLines;
 
 std::map<wxString, nlohmann::json> lineStyles;
 std::map<wxString, nlohmann::json> fontStyles;
 
 for( const nlohmann::json& line : aLines )
 {
 wxString type = line.at( 0 );
 
 if( type == wxS( "LINESTYLE" ) )
 lineStyles[line.at( 1 )] = line;
 else if( type == wxS( "FONTSTYLE" ) )
 fontStyles[line.at( 1 )] = line;
 }
 
 for( const nlohmann::json& line : aLines )
 {
 wxString type = line.at( 0 );
 
 if( type == wxS( "RECT" ) )
 {
 VECTOR2D start( line.at( 2 ), line.at( 3 ) );
 VECTOR2D end( line.at( 4 ), line.at( 5 ) );
 wxString styleStr = line.at( 9 );
 
 std::unique_ptr<SCH_SHAPE> rect = std::make_unique<SCH_SHAPE>( SHAPE_T::RECTANGLE );
 
 rect->SetStart( ScalePos( start ) );
 rect->SetEnd( ScalePos( end ) );
 
 ApplyLineStyle( lineStyles, rect, styleStr );
 
 createdItems.push_back( std::move( rect ) );
 }
 else if( type == wxS( "CIRCLE" ) )
 {
 VECTOR2D center( line.at( 2 ), line.at( 3 ) );
 double radius = line.at( 4 );
 wxString styleStr = line.at( 5 );
 
 std::unique_ptr<SCH_SHAPE> circle = std::make_unique<SCH_SHAPE>( SHAPE_T::CIRCLE );
 
 circle->SetCenter( ScalePos( center ) );
 circle->SetEnd( circle->GetCenter() + VECTOR2I( ScaleSize( radius ), 0 ) );
 
 ApplyLineStyle( lineStyles, circle, styleStr );
 
 createdItems.push_back( std::move( circle ) );
 }
 else if( type == wxS( "POLY" ) )
 {
 std::vector<double> points = line.at( 2 );
 wxString styleStr = line.at( 4 );
 
 SHAPE_LINE_CHAIN chain;
 
 for( size_t i = 1; i < points.size(); i += 2 )
 chain.Append( ScalePos( VECTOR2D( points[i - 1], points[i] ) ) );
 
 for( int segId = 0; segId < chain.SegmentCount(); segId++ )
 {
 const SEG& seg = chain.CSegment( segId );
 
 std::unique_ptr<SCH_LINE> schLine =
 std::make_unique<SCH_LINE>( seg.A, LAYER_NOTES );
 schLine->SetEndPoint( seg.B );
 
 ApplyLineStyle( lineStyles, schLine, styleStr );
 
 createdItems.push_back( std::move( schLine ) );
 }
 }
 else if( type == wxS( "TEXT" ) )
 {
 VECTOR2D pos( line.at( 2 ), line.at( 3 ) );
 double angle = line.at( 4 );
 wxString textStr = line.at( 5 );
 wxString fontStyleStr = line.at( 6 );
 
 std::unique_ptr<SCH_TEXT> text =
 std::make_unique<SCH_TEXT>( ScalePos( pos ), UnescapeHTML( textStr ) );
 
 text->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 text->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 
 text->SetTextAngleDegrees( angle );
 
 ApplyFontStyle( fontStyles, text, fontStyleStr );
 
 createdItems.push_back( std::move( text ) );
 }
 else if( type == wxS( "OBJ" ) )
 {
 VECTOR2D start, size;
 wxString mimeType, base64Data;
 double angle = 0;
 int flipped = 0;
 
 if( line.at( 3 ).is_number() )
 {
 start = VECTOR2D( line.at( 3 ), line.at( 4 ) );
 size = VECTOR2D( line.at( 5 ), line.at( 6 ) );
 angle = line.at( 7 );
 flipped = line.at( 8 );
 
 wxString imageUrl = line.at( 9 );
 
 if( imageUrl.BeforeFirst( ':' ) == wxS( "data" ) )
 {
 wxArrayString paramsArr =
 wxSplit( imageUrl.AfterFirst( ':' ).BeforeFirst( ',' ), ';', '\0' );
 
 base64Data = imageUrl.AfterFirst( ',' );
 
 if( paramsArr.size() > 0 )
 mimeType = paramsArr[0];
 }
 else if( imageUrl.BeforeFirst( ':' ) == wxS( "blob" ) )
 {
 wxString objectId = imageUrl.AfterLast( ':' );
 
 if( auto blob = get_opt( aBlobMap, objectId ) )
 {
 wxString blobUrl = blob->url;
 
 if( blobUrl.BeforeFirst( ':' ) == wxS( "data" ) )
 {
 wxArrayString paramsArr = wxSplit(
 blobUrl.AfterFirst( ':' ).BeforeFirst( ',' ), ';', '\0' );
 
 base64Data = blobUrl.AfterFirst( ',' );
 
 if( paramsArr.size() > 0 )
 mimeType = paramsArr[0];
 }
 }
 }
 }
 else if( line.at( 3 ).is_string() )
 {
 mimeType = line.at( 3 ).get<wxString>().BeforeFirst( ';' );
 
 start = VECTOR2D( line.at( 4 ), line.at( 5 ) );
 size = VECTOR2D( line.at( 6 ), line.at( 7 ) );
 angle = line.at( 8 );
 base64Data = line.at( 9 ).get<wxString>();
 }
 
 VECTOR2D kstart = ScalePos( start );
 VECTOR2D ksize = ScaleSize( size );
 
 if( mimeType.empty() || base64Data.empty() )
 continue;
 
 wxMemoryBuffer buf = wxBase64Decode( base64Data );
 
 if( mimeType == wxS( "image/svg+xml" ) )
 {
 SVG_IMPORT_PLUGIN svgImportPlugin;
 GRAPHICS_IMPORTER_SCH schImporter;
 
 svgImportPlugin.SetImporter( &schImporter );
 svgImportPlugin.LoadFromMemory( buf );
 
 VECTOR2D imSize( svgImportPlugin.GetImageWidth(),
 svgImportPlugin.GetImageHeight() );
 
 VECTOR2D pixelScale( schIUScale.IUTomm( ScaleSize( size.x ) ) / imSize.x,
 schIUScale.IUTomm( ScaleSize( size.y ) ) / imSize.y );
 
 schImporter.SetScale( pixelScale );
 
 VECTOR2D offsetMM( schIUScale.IUTomm( kstart.x ), schIUScale.IUTomm( kstart.y ) );
 
 schImporter.SetImportOffsetMM( offsetMM );
 
 svgImportPlugin.Import();
 
 for( std::unique_ptr<EDA_ITEM>& item : schImporter.GetItems() )
 {
 SCH_ITEM* schItem = static_cast<SCH_ITEM*>( item.release() );
 
 for( double i = angle; i > 0; i -= 90 )
 {
 if( schItem->Type() == SCH_LINE_T )
 {
 // Lines need special handling for some reason
 schItem->SetFlags( STARTPOINT );
 schItem->Rotate( kstart, false );
 schItem->ClearFlags( STARTPOINT );
 
 schItem->SetFlags( ENDPOINT );
 schItem->Rotate( kstart, false );
 schItem->ClearFlags( ENDPOINT );
 }
 else
 {
 schItem->Rotate( kstart, false );
 }
 }
 
 if( flipped )
 {
 // Lines need special handling for some reason
 if( schItem->Type() == SCH_LINE_T )
 schItem->SetFlags( STARTPOINT | ENDPOINT );
 
 schItem->MirrorHorizontally( kstart.x );
 
 if( schItem->Type() == SCH_LINE_T )
 schItem->ClearFlags( STARTPOINT | ENDPOINT );
 }
 
 createdItems.emplace_back( schItem );
 }
 }
 else
 {
 std::unique_ptr<SCH_BITMAP> bitmap = std::make_unique<SCH_BITMAP>();
 
 wxImage::SetDefaultLoadFlags( wxImage::GetDefaultLoadFlags()
 & ~wxImage::Load_Verbose );
 
 if( bitmap->ReadImageFile( buf ) )
 {
 VECTOR2D kcenter = kstart + ksize / 2;
 
 double scaleFactor = ScaleSize( size.x ) / bitmap->GetSize().x;
 bitmap->SetImageScale( scaleFactor );
 bitmap->SetPosition( kcenter );
 
 for( double i = angle; i > 0; i -= 90 )
 bitmap->Rotate( kstart, false );
 
 if( flipped )
 bitmap->MirrorHorizontally( kstart.x );
 
 createdItems.push_back( std::move( bitmap ) );
 }
 }
 }
 if( type == wxS( "WIRE" ) )
 {
 wxString wireId = line.at( 1 );
 parentedLines[wireId].push_back( line );
 }
 else if( type == wxS( "COMPONENT" ) )
 {
 wxString compId = line.at( 1 );
 parentedLines[compId].push_back( line );
 }
 else if( type == wxS( "ATTR" ) )
 {
 wxString compId = line.at( 2 );
 parentedLines[compId].push_back( line );
 }
 }
 
 for( auto& [parentId, lines] : parentedLines )
 {
 std::optional<EASYEDAPRO::SCH_COMPONENT> component;
 std::optional<EASYEDAPRO::SCH_WIRE> wire;
 std::map<wxString, EASYEDAPRO::SCH_ATTR> attributes;
 
 for( const nlohmann::json& line : lines )
 {
 if( line.at( 0 ) == "COMPONENT" )
 {
 component = line;
 }
 else if( line.at( 0 ) == "WIRE" )
 {
 wire = line;
 }
 else if( line.at( 0 ) == "ATTR" )
 {
 EASYEDAPRO::SCH_ATTR attr = line;
 attributes.emplace( attr.key, attr );
 }
 }
 
 if( component )
 {
 auto deviceAttr = get_opt( attributes, "Device" );
 auto symbolAttr = get_opt( attributes, "Symbol" );
 
 if( !deviceAttr )
 continue;
 
 nlohmann::json compAttrs =
 aProject.at( "devices" ).at( deviceAttr->value ).at( "attributes" );
 
 wxString symbolId;
 
 if( symbolAttr && !symbolAttr->value.IsEmpty() )
 symbolId = symbolAttr->value;
 else
 symbolId = compAttrs.at( "Symbol" ).get<wxString>();
 
 auto it = aSymbolMap.find( symbolId );
 if( it == aSymbolMap.end() )
 {
 wxLogError( "Symbol of '%s' with uuid '%s' not found.", component->name, symbolId );
 continue;
 }
 
 EASYEDAPRO::SYM_INFO& esymInfo = it->second;
 LIB_SYMBOL newLibSymbol = *esymInfo.libSymbol.get();
 
 wxString unitName = component->name;
 
 LIB_ID libId = EASYEDAPRO::ToKiCadLibID( aLibName,
 newLibSymbol.GetLibId().GetLibItemName() );
 
 auto schSym = std::make_unique<SCH_SYMBOL>( newLibSymbol, libId,
 &aSchematic->CurrentSheet(),
 esymInfo.partUnits[unitName] );
 
 schSym->SetFootprintFieldText( newLibSymbol.GetFootprintField().GetText() );
 
 for( double i = component->rotation; i > 0; i -= 90 )
 schSym->Rotate( VECTOR2I(), false );
 
 if( component->mirror )
 schSym->MirrorHorizontally( 0 );
 
 schSym->SetPosition( ScalePos( component->position ) );
 
 if( esymInfo.head.symbolType == EASYEDAPRO::SYMBOL_TYPE::POWER_PORT )
 {
 if( auto globalNetAttr = get_opt( attributes, "Global Net Name" ) )
 {
 ApplyAttrToField( fontStyles, schSym->GetField( VALUE_FIELD ), *globalNetAttr,
 false, true, compAttrs, schSym.get() );
 
 for( SCH_PIN* pin : schSym->GetAllLibPins() )
 pin->SetName( globalNetAttr->value );
 }
 else
 {
 schSym->GetField( VALUE_FIELD )
 ->SetText( newLibSymbol.GetValueField().GetText() );
 }
 
 schSym->SetRef( &aSchematic->CurrentSheet(), wxS( "#PWR?" ) );
 schSym->GetField( REFERENCE_FIELD )->SetVisible( false );
 }
 else if( esymInfo.head.symbolType == EASYEDAPRO::SYMBOL_TYPE::NETPORT )
 {
 auto nameAttr = get_opt( attributes, "Name" );
 
 if( nameAttr )
 {
 std::unique_ptr<SCH_GLOBALLABEL> label = std::make_unique<SCH_GLOBALLABEL>(
 ScalePos( component->position ), nameAttr->value );
 
 SPIN_STYLE spin = SPIN_STYLE::LEFT;
 
 if( esymInfo.symbolAttr )
 {
 wxString symStr = esymInfo.symbolAttr->value;
 
 if( symStr == wxS( "Netport-IN" ) )
 {
 spin = SPIN_STYLE::LEFT;
 label->SetShape( LABEL_FLAG_SHAPE::L_INPUT );
 }
 if( symStr == wxS( "Netport-OUT" ) )
 {
 spin = SPIN_STYLE::RIGHT;
 label->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT );
 }
 if( symStr == wxS( "Netport-BI" ) )
 {
 spin = SPIN_STYLE::RIGHT;
 label->SetShape( LABEL_FLAG_SHAPE::L_BIDI );
 }
 }
 
 for( double i = component->rotation; i > 0; i -= 90 )
 spin = spin.RotateCCW();
 
 label->SetSpinStyle( spin );
 
 nlohmann::json style = fontStyles[nameAttr->fontStyle];
 
 if( !style.is_null() && style.at( 5 ).is_number() )
 {
 double size = style.at( 5 ).get<double>() * 0.5;
 label->SetTextSize( VECTOR2I( ScaleSize( size ), ScaleSize( size ) ) );
 }
 
 createdItems.push_back( std::move( label ) );
 }
 
 continue;
 }
 else
 {
 auto nameAttr = get_opt( attributes, "Name" );
 auto valueAttr = get_opt( attributes, "Value" );
 
 std::optional<EASYEDAPRO::SCH_ATTR> targetValueAttr;
 
 if( valueAttr && !valueAttr->value.empty() && valueAttr->valVisible )
 targetValueAttr = valueAttr;
 else if( nameAttr && !nameAttr->value.empty() && nameAttr->valVisible )
 targetValueAttr = nameAttr;
 else if( valueAttr && !valueAttr->value.empty() )
 targetValueAttr = valueAttr;
 else if( nameAttr && !nameAttr->value.empty() )
 targetValueAttr = nameAttr;
 
 if( targetValueAttr )
 {
 ApplyAttrToField( fontStyles, schSym->GetField( VALUE_FIELD ), *targetValueAttr,
 false, true, compAttrs, schSym.get() );
 }
 
 if( auto descrAttr = get_opt( attributes, "Description" ) )
 {
 ApplyAttrToField( fontStyles, schSym->GetField( DESCRIPTION_FIELD ), *descrAttr,
 false, true, compAttrs, schSym.get() );
 }
 
 if( auto designatorAttr = get_opt( attributes, "Designator" ) )
 {
 ApplyAttrToField( fontStyles, schSym->GetField( REFERENCE_FIELD ),
 *designatorAttr, false, true, compAttrs, schSym.get() );
 
 schSym->SetRef( &aSchematic->CurrentSheet(), designatorAttr->value );
 }
 
 for( auto& [attrKey, attr] : attributes )
 {
 if( attrKey == wxS( "Name" ) || attrKey == wxS( "Value" )
 || attrKey == wxS( "Global Net Name" ) || attrKey == wxS( "Designator" )
 || attrKey == wxS( "Description" ) || attrKey == wxS( "Device" )
 || attrKey == wxS( "Footprint" ) || attrKey == wxS( "Symbol" )
 || attrKey == wxS( "Unique ID" ) )
 {
 continue;
 }
 
 if( attr.value.IsEmpty() )
 continue;
 
 SCH_FIELD* text =
 new SCH_FIELD( schSym.get(), schSym->GetFieldCount(), attrKey );
 
 text->SetPosition( schSym->GetPosition() );
 
 ApplyAttrToField( fontStyles, text, attr, false, true, compAttrs,
 schSym.get() );
 
 schSym->AddField( *text );
 }
 }
 
 for( const EASYEDAPRO::PIN_INFO& pinInfo : esymInfo.pins )
 {
 wxString pinKey = parentId + pinInfo.pin.id;
 auto pinLines = get_opt( parentedLines, pinKey );
 
 if( !pinLines )
 continue;
 
 for( const nlohmann::json& pinLine : *pinLines )
 {
 if( pinLine.at( 0 ) != "ATTR" )
 continue;
 
 EASYEDAPRO::SCH_ATTR attr = pinLine;
 
 if( attr.key != wxS( "NO_CONNECT" ) )
 continue;
 
 if( SCH_PIN* schPin = schSym->GetPin( pinInfo.number ) )
 {
 VECTOR2I pos = schSym->GetPinPhysicalPosition( schPin->GetLibPin() );
 
 std::unique_ptr<SCH_NO_CONNECT> noConn =
 std::make_unique<SCH_NO_CONNECT>( pos );
 
 createdItems.push_back( std::move( noConn ) );
 }
 }
 }
 
 createdItems.push_back( std::move( schSym ) );
 }
 else // Not component
 {
 std::vector<SHAPE_LINE_CHAIN> wireLines;
 
 if( wire )
 {
 for( const std::vector<double>& ptArr : wire->geometry )
 {
 SHAPE_LINE_CHAIN chain;
 
 for( size_t i = 1; i < ptArr.size(); i += 2 )
 chain.Append( ScalePos( VECTOR2D( ptArr[i - 1], ptArr[i] ) ) );
 
 if( chain.PointCount() < 2 )
 continue;
 
 wireLines.push_back( chain );
 
 for( int segId = 0; segId < chain.SegmentCount(); segId++ )
 {
 const SEG& seg = chain.CSegment( segId );
 
 std::unique_ptr<SCH_LINE> schLine =
 std::make_unique<SCH_LINE>( seg.A, LAYER_WIRE );
 schLine->SetEndPoint( seg.B );
 
 createdItems.push_back( std::move( schLine ) );
 }
 }
 }
 
 auto netAttr = get_opt( attributes, "NET" );
 
 if( netAttr )
 {
 if( !netAttr->valVisible )
 continue;
 
 VECTOR2I kpos = ScalePos( *netAttr->position );
 VECTOR2I nearestPos = kpos;
 SEG::ecoord min_dist_sq = VECTOR2I::ECOORD_MAX;
 
 for( const SHAPE_LINE_CHAIN& chain : wireLines )
 {
 VECTOR2I nearestPt = chain.NearestPoint( kpos, false );
 SEG::ecoord dist_sq = ( nearestPt - kpos ).SquaredEuclideanNorm();
 
 if( dist_sq < min_dist_sq )
 {
 min_dist_sq = dist_sq;
 nearestPos = nearestPt;
 }
 }
 
 std::unique_ptr<SCH_LABEL> label = std::make_unique<SCH_LABEL>();
 
 label->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 label->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 
 for( double i = netAttr->rotation; i > 0; i -= 90 )
 label->Rotate90( true );
 
 label->SetPosition( nearestPos );
 label->SetText( netAttr->value );
 
 ApplyFontStyle( fontStyles, label, netAttr->fontStyle );
 
 createdItems.push_back( std::move( label ) );
 }
 }
 }
 
 // Adjust page to content
 BOX2I sheetBBox;
 
 for( std::unique_ptr<SCH_ITEM>& ptr : createdItems )
 {
 if( ptr->Type() == SCH_SYMBOL_T )
 sheetBBox.Merge( static_cast<SCH_SYMBOL*>( ptr.get() )->GetBodyAndPinsBoundingBox() );
 else
 sheetBBox.Merge( ptr->GetBoundingBox() );
 }
 
 SCH_SCREEN* screen = aRootSheet->GetScreen();
 PAGE_INFO pageInfo = screen->GetPageSettings();
 
 int alignGrid = schIUScale.MilsToIU( 50 );
 
 VECTOR2D offset( -sheetBBox.GetLeft(), -sheetBBox.GetTop() );
 offset.x = KiROUND( offset.x / alignGrid ) * alignGrid;
 offset.y = KiROUND( offset.y / alignGrid ) * alignGrid;
 
 pageInfo.SetWidthMils( schIUScale.IUToMils( sheetBBox.GetWidth() ) );
 pageInfo.SetHeightMils( schIUScale.IUToMils( sheetBBox.GetHeight() ) );
 
 screen->SetPageSettings( pageInfo );
 
 for( std::unique_ptr<SCH_ITEM>& ptr : createdItems )
 {
 ptr->Move( offset );
 screen->Append( ptr.release() );
 }
}