A SCH_PLUGIN derivation for loading schematic files created before the new s-expression file format. More...

#include <sch_legacy_plugin.h>

Inheritance diagram for SCH_LEGACY_PLUGIN:

Public Member Functions
	SCH_LEGACY_PLUGIN ()

virtual	~SCH_LEGACY_PLUGIN ()

const wxString	GetName () const override
	Return a brief hard coded name for this SCH_PLUGIN. More...

const wxString	GetFileExtension () const override
	Return the file extension for the SCH_PLUGIN. More...

const wxString	GetLibraryFileExtension () const override
	Return the library file extension for the SCH_PLUGIN object. More...

int	GetModifyHash () const override
	Return the modification hash from the library cache. More...

SCH_SHEET *	Load (const wxString &aFileName, SCHEMATIC aSchematic, SCH_SHEET aAppendToMe=nullptr, const PROPERTIES *aProperties=nullptr) override
	Load information from some input file format that this SCH_PLUGIN implementation knows about, into either a new SCH_SHEET or an existing one. More...

void	LoadContent (LINE_READER &aReader, SCH_SCREEN *aScreen, int version=EESCHEMA_VERSION)

void	Save (const wxString &aFileName, SCH_SHEET aScreen, SCHEMATIC aSchematic, const PROPERTIES *aProperties=nullptr) override
	Write aSchematic to a storage file in a format that this SCH_PLUGIN implementation knows about, or it can be used to write a portion of aSchematic to a special kind of export file. More...

void	Format (SCH_SHEET *aSheet)

void	Format (SELECTION aSelection, OUTPUTFORMATTER aFormatter)

void	EnumerateSymbolLib (wxArrayString &aSymbolNameList, const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
	Populate a list of LIB_PART alias names contained within the library aLibraryPath. More...

void	EnumerateSymbolLib (std::vector< LIB_PART * > &aSymbolList, const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
	Populate a list of LIB_PART aliases contained within the library aLibraryPath. More...

LIB_PART *	LoadSymbol (const wxString &aLibraryPath, const wxString &aAliasName, const PROPERTIES *aProperties=nullptr) override
	Load a LIB_PART object having aPartName from the aLibraryPath containing a library format that this SCH_PLUGIN knows about. More...

void	SaveSymbol (const wxString &aLibraryPath, const LIB_PART aSymbol, const PROPERTIES aProperties=nullptr) override
	Write aSymbol to an existing library located at aLibraryPath. More...

void	DeleteSymbol (const wxString &aLibraryPath, const wxString &aSymbolName, const PROPERTIES *aProperties=nullptr) override
	Delete the entire LIB_PART associated with aAliasName from the library aLibraryPath. More...

void	CreateSymbolLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
	Create a new empty symbol library at aLibraryPath. More...

bool	DeleteSymbolLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
	Delete an existing symbol library and returns true if successful, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason. More...

void	SaveLibrary (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override

bool	CheckHeader (const wxString &aFileName) override
	Return true if the first line in aFileName begins with the expected header. More...

bool	IsSymbolLibWritable (const wxString &aLibraryPath) override
	Return true if the library at aLibraryPath is writable. More...

const wxString &	GetError () const override
	Return an error string to the caller. More...

virtual void	SetReporter (REPORTER *aReporter)
	Set an optional reporter for warnings/errors. More...

virtual void	SymbolLibOptions (PROPERTIES *aListToAppendTo) const
	Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions. More...

Static Public Member Functions
static LIB_PART *	ParsePart (LINE_READER &aReader, int majorVersion=0, int minorVersion=0)

static void	FormatPart (LIB_PART *aPart, OUTPUTFORMATTER &aFormatter)

Static Public Attributes
static const char *	PropBuffering = "buffering"
	The property used internally by the plugin to enable cache buffering which prevents the library file from being written every time the cache is changed. More...

static const char *	PropNoDocFile = "no_doc_file"
	The property used internally by the plugin to disable writing the library documentation (.dcm) file when saving the library cache. More...

Protected Member Functions
void	init (SCHEMATIC aSchematic, const PROPERTIES aProperties=nullptr)
	initialize PLUGIN like a constructor would. More...

Protected Attributes
int	m_version
	Version of file being loaded. More...

wxString	m_error
	For throwing exceptions or errors on partial schematic loads. More...

wxString	m_path
	Root project path for loading child sheets. More...

std::stack< wxString >	m_currentPath
	Stack to maintain nested sheet paths. More...

SCH_SHEET *	m_rootSheet
	The root sheet of the schematic being loaded.. More...

OUTPUTFORMATTER *	m_out
	The output formatter for saving SCH_SCREEN objects. More...

SCH_LEGACY_PLUGIN_CACHE *	m_cache

SCHEMATIC *	m_schematic
	Passed to Load(), the schematic object being loaded. More...

Private Member Functions
void	loadHierarchy (SCH_SHEET *aSheet)

void	loadHeader (LINE_READER &aReader, SCH_SCREEN *aScreen)

void	loadPageSettings (LINE_READER &aReader, SCH_SCREEN *aScreen)

void	loadFile (const wxString &aFileName, SCH_SCREEN *aScreen)

SCH_SHEET *	loadSheet (LINE_READER &aReader)

SCH_BITMAP *	loadBitmap (LINE_READER &aReader)

SCH_JUNCTION *	loadJunction (LINE_READER &aReader)

SCH_NO_CONNECT *	loadNoConnect (LINE_READER &aReader)

SCH_LINE *	loadWire (LINE_READER &aReader)

SCH_BUS_ENTRY_BASE *	loadBusEntry (LINE_READER &aReader)

SCH_TEXT *	loadText (LINE_READER &aReader)

SCH_COMPONENT *	loadComponent (LINE_READER &aReader)

std::shared_ptr< BUS_ALIAS >	loadBusAlias (LINE_READER &aReader, SCH_SCREEN *aScreen)

void	saveComponent (SCH_COMPONENT *aComponent)

void	saveField (SCH_FIELD *aField)

void	saveBitmap (SCH_BITMAP *aBitmap)

void	saveSheet (SCH_SHEET *aSheet)

void	saveJunction (SCH_JUNCTION *aJunction)

void	saveNoConnect (SCH_NO_CONNECT *aNoConnect)

void	saveBusEntry (SCH_BUS_ENTRY_BASE *aBusEntry)

void	saveLine (SCH_LINE *aLine)

void	saveText (SCH_TEXT *aText)

void	saveBusAlias (std::shared_ptr< BUS_ALIAS > aAlias)

void	cacheLib (const wxString &aLibraryFileName, const PROPERTIES *aProperties)

bool	writeDocFile (const PROPERTIES *aProperties)

bool	isBuffering (const PROPERTIES *aProperties)

Detailed Description

A SCH_PLUGIN derivation for loading schematic files created before the new s-expression file format.

The legacy parser and formatter attempt to be compatible with the legacy file format. The original parser was very forgiving in that it would parse only part of a keyword. So "$C", "$Co", and "$Com" could be used for "$Comp" and the old parser would allow this. This parser is not that forgiving and sticks to the legacy file format document.

As with all SCH_PLUGINs there is no UI dependencies i.e. windowing calls allowed.

Definition at line 63 of file sch_legacy_plugin.h.

Constructor & Destructor Documentation

◆ SCH_LEGACY_PLUGIN()

SCH_LEGACY_PLUGIN::SCH_LEGACY_PLUGIN ( )

Definition at line 581 of file sch_legacy_plugin.cpp.

 {
     init( NULL );
 }

References init(), and NULL.

◆ ~SCH_LEGACY_PLUGIN()

SCH_LEGACY_PLUGIN::~SCH_LEGACY_PLUGIN ( )

virtual

Definition at line 587 of file sch_legacy_plugin.cpp.

 {
     delete m_cache;
 }

References m_cache.

Member Function Documentation

◆ cacheLib()

void SCH_LEGACY_PLUGIN::cacheLib	(	const wxString &	aLibraryFileName,
		const PROPERTIES *	aProperties
	)

private

Definition at line 4220 of file sch_legacy_plugin.cpp.

 {
     if( !m_cache || !m_cache->IsFile( aLibraryFileName ) || m_cache->IsFileChanged() )
     {
         // a spectacular episode in memory management:
         delete m_cache;
         m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryFileName );
 
         // Because m_cache is rebuilt, increment PART_LIBS::s_modify_generation
         // to modify the hash value that indicate component to symbol links
         // must be updated.
         PART_LIBS::IncrementModifyGeneration();
 
         if( !isBuffering( aProperties ) )
             m_cache->Load();
     }
 }

References PART_LIBS::IncrementModifyGeneration(), isBuffering(), SCH_LEGACY_PLUGIN_CACHE::IsFile(), SCH_LEGACY_PLUGIN_CACHE::IsFileChanged(), SCH_LEGACY_PLUGIN_CACHE::Load(), and m_cache.

Referenced by DeleteSymbol(), EnumerateSymbolLib(), LoadSymbol(), and SaveSymbol().

◆ CheckHeader()

bool SCH_LEGACY_PLUGIN::CheckHeader ( const wxString & aFileName )

overridevirtual

Return true if the first line in aFileName begins with the expected header.

Parameters

aFileName is the name of the file to use as input

Reimplemented from SCH_PLUGIN.

Definition at line 4417 of file sch_legacy_plugin.cpp.

 {
     // Open file and check first line
     wxTextFile tempFile;
 
     tempFile.Open( aFileName );
     wxString firstline;
     // read the first line
     firstline = tempFile.GetFirstLine();
     tempFile.Close();
 
     return firstline.StartsWith( "EESchema" );
 }

◆ CreateSymbolLib()

void SCH_LEGACY_PLUGIN::CreateSymbolLib	(	const wxString &	aLibraryPath,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Create a new empty symbol library at aLibraryPath.

It is an error to attempt to create an existing library or to attempt to create on a "read only" location.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several footprints.
aProperties	is an associative array that can be used to tell the library create function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR if there is a problem finding the library, or creating it.

Reimplemented from SCH_PLUGIN.

Definition at line 4352 of file sch_legacy_plugin.cpp.

 {
     if( wxFileExists( aLibraryPath ) )
     {
         THROW_IO_ERROR( wxString::Format(
             _( "symbol library \"%s\" already exists, cannot create a new library" ),
             aLibraryPath.GetData() ) );
     }
 
     LOCALE_IO toggle;
 
     delete m_cache;
     m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryPath );
     m_cache->SetModified();
     m_cache->Save( writeDocFile( aProperties ) );
     m_cache->Load();    // update m_writable and m_mod_time
 }

References _, Format(), SCH_LEGACY_PLUGIN_CACHE::Load(), m_cache, SCH_LEGACY_PLUGIN_CACHE::Save(), SCH_LEGACY_PLUGIN_CACHE::SetModified(), THROW_IO_ERROR, and writeDocFile().

◆ DeleteSymbol()

void SCH_LEGACY_PLUGIN::DeleteSymbol	(	const wxString &	aLibraryPath,
		const wxString &	aSymbolName,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Delete the entire LIB_PART associated with aAliasName from the library aLibraryPath.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several symbols.
aSymbolName	is the name of a LIB_PART associated with it's root LIB_PART object to delete from the specified library.
aProperties	is an associative array that can be used to tell the library delete function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR if there is a problem finding the alias or the library or deleting it.

Reimplemented from SCH_PLUGIN.

Definition at line 4338 of file sch_legacy_plugin.cpp.

 {
     LOCALE_IO toggle;     // toggles on, then off, the C locale.
 
     cacheLib( aLibraryPath, aProperties );
 
     m_cache->DeleteSymbol( aSymbolName );
 
     if( !isBuffering( aProperties ) )
         m_cache->Save( writeDocFile( aProperties ) );
 }

References cacheLib(), SCH_LEGACY_PLUGIN_CACHE::DeleteSymbol(), isBuffering(), m_cache, SCH_LEGACY_PLUGIN_CACHE::Save(), and writeDocFile().

◆ DeleteSymbolLib()

bool SCH_LEGACY_PLUGIN::DeleteSymbolLib	(	const wxString &	aLibraryPath,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Delete an existing symbol library and returns true if successful, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason.

Parameters

aLibraryPath	is a locator for the "library", usually a directory or file which will contain symbols.
aProperties	is an associative array that can be used to tell the library delete implementation function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns: true if library deleted or false if library did not exist.

Exceptions

IO_ERROR if there is a problem deleting an existing library.

Reimplemented from SCH_PLUGIN.

Definition at line 4372 of file sch_legacy_plugin.cpp.

 {
     wxFileName fn = aLibraryPath;
 
     if( !fn.FileExists() )
         return false;
 
     // Some of the more elaborate wxRemoveFile() crap puts up its own wxLog dialog
     // we don't want that.  we want bare metal portability with no UI here.
     if( wxRemove( aLibraryPath ) )
     {
         THROW_IO_ERROR( wxString::Format( _( "library \"%s\" cannot be deleted" ),
                                           aLibraryPath.GetData() ) );
     }
 
     if( m_cache && m_cache->IsFile( aLibraryPath ) )
     {
         delete m_cache;
         m_cache = 0;
     }
 
     return true;
 }

References _, Format(), SCH_LEGACY_PLUGIN_CACHE::IsFile(), m_cache, and THROW_IO_ERROR.

◆ EnumerateSymbolLib() [1/2]

void SCH_LEGACY_PLUGIN::EnumerateSymbolLib	(	wxArrayString &	aSymbolNameList,
		const wxString &	aLibraryPath,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Populate a list of LIB_PART alias names contained within the library aLibraryPath.

Parameters

aSymbolNameList	is an array to populate with the LIB_PART names associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_PART objects.
aProperties	is an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR if the library cannot be found, the part library cannot be loaded.

Reimplemented from SCH_PLUGIN.

Definition at line 4266 of file sch_legacy_plugin.cpp.

 {
     LOCALE_IO   toggle;     // toggles on, then off, the C locale.
 
     bool powerSymbolsOnly = ( aProperties &&
                               aProperties->find( SYMBOL_LIB_TABLE::PropPowerSymsOnly ) != aProperties->end() );
 
     cacheLib( aLibraryPath, aProperties  );
 
     const LIB_PART_MAP& symbols = m_cache->m_symbols;
 
     for( LIB_PART_MAP::const_iterator it = symbols.begin();  it != symbols.end();  ++it )
     {
         if( !powerSymbolsOnly || it->second->IsPower() )
             aSymbolNameList.Add( it->first );
     }
 }

References cacheLib(), m_cache, SCH_LEGACY_PLUGIN_CACHE::m_symbols, and SYMBOL_LIB_TABLE::PropPowerSymsOnly.

◆ EnumerateSymbolLib() [2/2]

void SCH_LEGACY_PLUGIN::EnumerateSymbolLib	(	std::vector< LIB_PART * > &	aSymbolList,
		const wxString &	aLibraryPath,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Populate a list of LIB_PART aliases contained within the library aLibraryPath.

Note: It is the responsibility of the caller to delete the returned object from the heap. Failure to do this will result in memory leaks.

Parameters

aSymbolList	is an array to populate with the LIB_PART pointers associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_PART objects.
aProperties	is an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR if the library cannot be found, the part library cannot be loaded.

Reimplemented from SCH_PLUGIN.

Definition at line 4287 of file sch_legacy_plugin.cpp.

 {
     LOCALE_IO   toggle;     // toggles on, then off, the C locale.
 
     bool powerSymbolsOnly = ( aProperties &&
                               aProperties->find( SYMBOL_LIB_TABLE::PropPowerSymsOnly ) != aProperties->end() );
 
     cacheLib( aLibraryPath, aProperties );
 
     const LIB_PART_MAP& symbols = m_cache->m_symbols;
 
     for( LIB_PART_MAP::const_iterator it = symbols.begin();  it != symbols.end();  ++it )
     {
         if( !powerSymbolsOnly || it->second->IsPower() )
             aSymbolList.push_back( it->second );
     }
 }

References cacheLib(), m_cache, SCH_LEGACY_PLUGIN_CACHE::m_symbols, and SYMBOL_LIB_TABLE::PropPowerSymsOnly.

◆ Format() [1/2]

void SCH_LEGACY_PLUGIN::Format ( SCH_SHEET * aSheet )

Definition at line 1859 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aSheet != NULL, "NULL SCH_SHEET* object." );
     wxCHECK_RET( m_schematic != NULL, "NULL SCHEMATIC* object." );
 
     SCH_SCREEN* screen = aSheet->GetScreen();
 
     wxCHECK( screen, /* void */ );
 
     // Write the header
     m_out->Print( 0, "%s %s %d\n", "EESchema", SCHEMATIC_HEAD_STRING, EESCHEMA_VERSION );
 
     // This section is not used, but written for file compatibility
     m_out->Print( 0, "EELAYER %d %d\n", SCH_LAYER_ID_COUNT, 0 );
     m_out->Print( 0, "EELAYER END\n" );
 
     /* Write page info, ScreenNumber and NumberOfScreen; not very meaningful for
      * SheetNumber and Sheet Count in a complex hierarchy, but useful in
      * simple hierarchy and flat hierarchy.  Used also to search the root
      * sheet ( ScreenNumber = 1 ) within the files
      */
     const TITLE_BLOCK& tb = screen->GetTitleBlock();
     const PAGE_INFO& page = screen->GetPageSettings();
 
     m_out->Print( 0, "$Descr %s %d %d%s\n", TO_UTF8( page.GetType() ),
                   page.GetWidthMils(),
                   page.GetHeightMils(),
                   !page.IsCustom() && page.IsPortrait() ? " portrait" : "" );
     m_out->Print( 0, "encoding utf-8\n" );
     m_out->Print( 0, "Sheet %d %d\n", screen->GetVirtualPageNumber(), screen->GetPageCount() );
     m_out->Print( 0, "Title %s\n",    EscapedUTF8( tb.GetTitle() ).c_str() );
     m_out->Print( 0, "Date %s\n",     EscapedUTF8( tb.GetDate() ).c_str() );
     m_out->Print( 0, "Rev %s\n",      EscapedUTF8( tb.GetRevision() ).c_str() );
     m_out->Print( 0, "Comp %s\n",     EscapedUTF8( tb.GetCompany() ).c_str() );
     m_out->Print( 0, "Comment1 %s\n", EscapedUTF8( tb.GetComment( 0 ) ).c_str() );
     m_out->Print( 0, "Comment2 %s\n", EscapedUTF8( tb.GetComment( 1 ) ).c_str() );
     m_out->Print( 0, "Comment3 %s\n", EscapedUTF8( tb.GetComment( 2 ) ).c_str() );
     m_out->Print( 0, "Comment4 %s\n", EscapedUTF8( tb.GetComment( 3 ) ).c_str() );
     m_out->Print( 0, "Comment5 %s\n", EscapedUTF8( tb.GetComment( 4 ) ).c_str() );
     m_out->Print( 0, "Comment6 %s\n", EscapedUTF8( tb.GetComment( 5 ) ).c_str() );
     m_out->Print( 0, "Comment7 %s\n", EscapedUTF8( tb.GetComment( 6 ) ).c_str() );
     m_out->Print( 0, "Comment8 %s\n", EscapedUTF8( tb.GetComment( 7 ) ).c_str() );
     m_out->Print( 0, "Comment9 %s\n", EscapedUTF8( tb.GetComment( 8 ) ).c_str() );
     m_out->Print( 0, "$EndDescr\n" );
 
     for( const auto& alias : screen->GetBusAliases() )
     {
         saveBusAlias( alias );
     }
 
     // Enforce item ordering
     auto cmp = []( const SCH_ITEM* a, const SCH_ITEM* b ) { return *a < *b; };
     std::multiset<SCH_ITEM*, decltype( cmp )> save_map( cmp );
 
     for( auto item : screen->Items() )
         save_map.insert( item );
 
 
     for( auto& item : save_map )
     {
         switch( item->Type() )
         {
         case SCH_COMPONENT_T:
             saveComponent( static_cast<SCH_COMPONENT*>( item ) );
             break;
         case SCH_BITMAP_T:
             saveBitmap( static_cast<SCH_BITMAP*>( item ) );
             break;
         case SCH_SHEET_T:
             saveSheet( static_cast<SCH_SHEET*>( item ) );
             break;
         case SCH_JUNCTION_T:
             saveJunction( static_cast<SCH_JUNCTION*>( item ) );
             break;
         case SCH_NO_CONNECT_T:
             saveNoConnect( static_cast<SCH_NO_CONNECT*>( item ) );
             break;
         case SCH_BUS_WIRE_ENTRY_T:
         case SCH_BUS_BUS_ENTRY_T:
             saveBusEntry( static_cast<SCH_BUS_ENTRY_BASE*>( item ) );
             break;
         case SCH_LINE_T:
             saveLine( static_cast<SCH_LINE*>( item ) );
             break;
         case SCH_TEXT_T:
         case SCH_LABEL_T:
         case SCH_GLOBAL_LABEL_T:
         case SCH_HIER_LABEL_T:
             saveText( static_cast<SCH_TEXT*>( item ) );
             break;
         default:
             wxASSERT( "Unexpected schematic object type in SCH_LEGACY_PLUGIN::Format()" );
         }
     }
 
     m_out->Print( 0, "$EndSCHEMATC\n" );
 }

References EESCHEMA_VERSION, EscapedUTF8(), SCH_SCREEN::GetBusAliases(), TITLE_BLOCK::GetComment(), TITLE_BLOCK::GetCompany(), TITLE_BLOCK::GetDate(), PAGE_INFO::GetHeightMils(), BASE_SCREEN::GetPageCount(), SCH_SCREEN::GetPageSettings(), TITLE_BLOCK::GetRevision(), SCH_SHEET::GetScreen(), TITLE_BLOCK::GetTitle(), SCH_SCREEN::GetTitleBlock(), PAGE_INFO::GetType(), BASE_SCREEN::GetVirtualPageNumber(), PAGE_INFO::GetWidthMils(), PAGE_INFO::IsCustom(), PAGE_INFO::IsPortrait(), SCH_SCREEN::Items(), m_out, m_schematic, NULL, OUTPUTFORMATTER::Print(), saveBitmap(), saveBusAlias(), saveBusEntry(), saveComponent(), saveJunction(), saveLine(), saveNoConnect(), saveSheet(), saveText(), SCH_BITMAP_T, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, SCH_COMPONENT_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_JUNCTION_T, SCH_LABEL_T, SCH_LAYER_ID_COUNT, SCH_LINE_T, SCH_NO_CONNECT_T, SCH_SHEET_T, SCH_TEXT_T, SCHEMATIC_HEAD_STRING, and TO_UTF8.

Referenced by Save().

◆ Format() [2/2]

void SCH_LEGACY_PLUGIN::Format	(	SELECTION *	aSelection,
		OUTPUTFORMATTER *	aFormatter
	)

Definition at line 1958 of file sch_legacy_plugin.cpp.

 {
     m_out = aFormatter;
 
     for( unsigned i = 0; i < aSelection->GetSize(); ++i )
     {
         SCH_ITEM* item = (SCH_ITEM*) aSelection->GetItem( i );
 
         switch( item->Type() )
         {
         case SCH_COMPONENT_T:
             saveComponent( static_cast< SCH_COMPONENT* >( item ) );
             break;
         case SCH_BITMAP_T:
             saveBitmap( static_cast< SCH_BITMAP* >( item ) );
             break;
         case SCH_SHEET_T:
             saveSheet( static_cast< SCH_SHEET* >( item ) );
             break;
         case SCH_JUNCTION_T:
             saveJunction( static_cast< SCH_JUNCTION* >( item ) );
             break;
         case SCH_NO_CONNECT_T:
             saveNoConnect( static_cast< SCH_NO_CONNECT* >( item ) );
             break;
         case SCH_BUS_WIRE_ENTRY_T:
         case SCH_BUS_BUS_ENTRY_T:
             saveBusEntry( static_cast< SCH_BUS_ENTRY_BASE* >( item ) );
             break;
         case SCH_LINE_T:
             saveLine( static_cast< SCH_LINE* >( item ) );
             break;
         case SCH_TEXT_T:
         case SCH_LABEL_T:
         case SCH_GLOBAL_LABEL_T:
         case SCH_HIER_LABEL_T:
             saveText( static_cast< SCH_TEXT* >( item ) );
             break;
         default:
             wxASSERT( "Unexpected schematic object type in SCH_LEGACY_PLUGIN::Format()" );
         }
     }
 }

References SELECTION::GetItem(), SELECTION::GetSize(), m_out, saveBitmap(), saveBusEntry(), saveComponent(), saveJunction(), saveLine(), saveNoConnect(), saveSheet(), saveText(), SCH_BITMAP_T, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_T, SCH_COMPONENT_T, SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_JUNCTION_T, SCH_LABEL_T, SCH_LINE_T, SCH_NO_CONNECT_T, SCH_SHEET_T, SCH_TEXT_T, and EDA_ITEM::Type().

◆ FormatPart()

void SCH_LEGACY_PLUGIN::FormatPart	(	LIB_PART *	aPart,
		OUTPUTFORMATTER &	aFormatter
	)

static

Definition at line 4446 of file sch_legacy_plugin.cpp.

 {
     SCH_LEGACY_PLUGIN_CACHE::SaveSymbol( part, formatter );
 }

References SCH_LEGACY_PLUGIN_CACHE::SaveSymbol().

◆ GetError()

const wxString& SCH_LEGACY_PLUGIN::GetError ( ) const

inlineoverridevirtual

Return an error string to the caller.

This is useful for schematic loaders that can load partial schematics where throwing an exception would be problematic such as the KiCad legacy plugin.

Returns: an unformatted string containing errors if any.

Reimplemented from SCH_PLUGIN.

Definition at line 136 of file sch_legacy_plugin.h.

136 { return m_error; }

SCH_LEGACY_PLUGIN::m_error

wxString m_error

For throwing exceptions or errors on partial schematic loads.

Definition: sch_legacy_plugin.h:175

References m_error.

◆ GetFileExtension()

const wxString SCH_LEGACY_PLUGIN::GetFileExtension ( ) const

inlineoverridevirtual

Return the file extension for the SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 75 of file sch_legacy_plugin.h.

     {
         return wxT( "sch" );
     }

◆ GetLibraryFileExtension()

const wxString SCH_LEGACY_PLUGIN::GetLibraryFileExtension ( ) const

inlineoverridevirtual

Return the library file extension for the SCH_PLUGIN object.

Implements SCH_PLUGIN.

Definition at line 80 of file sch_legacy_plugin.h.

     {
         return wxT( "lib" );
     }

◆ GetModifyHash()

int SCH_LEGACY_PLUGIN::GetModifyHash ( ) const

overridevirtual

Return the modification hash from the library cache.

Note: This is temporary until the new s-expr file format is implement. The new file format will embed symbols instead of referencing them from the library. This function can be removed when the new file format is implemented.

Returns: the modification hash of the library cache.

Implements SCH_PLUGIN.

Definition at line 4256 of file sch_legacy_plugin.cpp.

 {
     if( m_cache )
         return SCH_LEGACY_PLUGIN_CACHE::GetModifyHash();
 
     // If the cache hasn't been loaded, it hasn't been modified.
     return 0;
 }

References SCH_LEGACY_PLUGIN_CACHE::GetModifyHash(), and m_cache.

◆ GetName()

const wxString SCH_LEGACY_PLUGIN::GetName ( ) const

inlineoverridevirtual

Return a brief hard coded name for this SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 70 of file sch_legacy_plugin.h.

     {
         return wxT( "Eeschema-Legacy" );
     }

◆ init()

void SCH_LEGACY_PLUGIN::init	(	SCHEMATIC *	aSchematic,
		const PROPERTIES *	aProperties = `nullptr`
	)

protected

initialize PLUGIN like a constructor would.

Definition at line 593 of file sch_legacy_plugin.cpp.

 {
     m_version   = 0;
     m_rootSheet = nullptr;
     m_schematic = aSchematic;
     m_cache     = nullptr;
     m_out       = nullptr;
 }

References m_cache, m_out, m_rootSheet, m_schematic, and m_version.

Referenced by Load(), Save(), and SCH_LEGACY_PLUGIN().

◆ isBuffering()

bool SCH_LEGACY_PLUGIN::isBuffering ( const PROPERTIES * aProperties )

private

Definition at line 4250 of file sch_legacy_plugin.cpp.

 {
     return ( aProperties && aProperties->Exists( SCH_LEGACY_PLUGIN::PropBuffering ) );
 }

References PROPERTIES::Exists(), and PropBuffering.

Referenced by cacheLib(), DeleteSymbol(), and SaveSymbol().

◆ IsSymbolLibWritable()

bool SCH_LEGACY_PLUGIN::IsSymbolLibWritable ( const wxString & aLibraryPath )

overridevirtual

Return true if the library at aLibraryPath is writable.

(Often system libraries are read only because of where they are installed.)

Parameters

aLibraryPath is a locator for the "library", usually a directory, file, or URL containing several symbols.

Exceptions

IO_ERROR if no library at aLibraryPath exists.

Reimplemented from SCH_PLUGIN.

Definition at line 4432 of file sch_legacy_plugin.cpp.

 {
     // Writing legacy symbol libraries is deprecated.
     return false;
 }

◆ Load()

SCH_SHEET * SCH_LEGACY_PLUGIN::Load	(	const wxString &	aFileName,
		SCHEMATIC *	aSchematic,
		SCH_SHEET *	aAppendToMe = `nullptr`,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Load information from some input file format that this SCH_PLUGIN implementation knows about, into either a new SCH_SHEET or an existing one.

This may be used to load an entire new SCH_SHEET, or to augment an existing one if aAppendToMe is not NULL.

Parameters

aFileName	is the name of the file to use as input and may be foreign in nature or native in nature.
aKiway	is the KIWAY object used to access the component libraries loaded by the project.
aAppendToMe	is an existing SCH_SHEET to append to, but if NULL then this means "do not append, rather load anew".
aProperties	is an associative array that can be used to tell the loader how to load the file, because it can take any number of additional named arguments that the plugin is known to support. These are tuning parameters for the import or load. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns: the successfully loaded schematic, or the same one as aAppendToMe if aAppendToMe was not NULL, and the caller owns it.

Exceptions

IO_ERROR if there is a problem loading, and its contents should say what went wrong, using line number and character offsets of the input file if possible.

Reimplemented from SCH_PLUGIN.

Definition at line 603 of file sch_legacy_plugin.cpp.

 {
     wxASSERT( !aFileName || aSchematic != NULL );
 
     LOCALE_IO   toggle;     // toggles on, then off, the C locale.
     SCH_SHEET*  sheet;
 
     wxFileName fn = aFileName;
 
     // Unfortunately child sheet file names the legacy schematic file format are not fully
     // qualified and are always appended to the project path.  The aFileName attribute must
     // always be an absolute path so the project path can be used for load child sheet files.
     wxASSERT( fn.IsAbsolute() );
 
     if( aAppendToMe )
     {
         wxLogTrace( traceSchLegacyPlugin, "Append \"%s\" to sheet \"%s\".",
                     aFileName, aAppendToMe->GetFileName() );
 
         wxFileName normedFn = aAppendToMe->GetFileName();
 
         if( !normedFn.IsAbsolute() )
         {
             if( aFileName.Right( normedFn.GetFullPath().Length() ) == normedFn.GetFullPath() )
                 m_path = aFileName.Left( aFileName.Length() - normedFn.GetFullPath().Length() );
         }
 
         if( m_path.IsEmpty() )
             m_path = aSchematic->Prj().GetProjectPath();
 
         wxLogTrace( traceSchLegacyPlugin, "m_Normalized append path \"%s\".", m_path );
     }
     else
     {
         m_path = aSchematic->Prj().GetProjectPath();
     }
 
     m_currentPath.push( m_path );
     init( aSchematic, aProperties );
 
     if( aAppendToMe == NULL )
     {
         // Clean up any allocated memory if an exception occurs loading the schematic.
         std::unique_ptr<SCH_SHEET> newSheet = std::make_unique<SCH_SHEET>( aSchematic );
         newSheet->SetFileName( aFileName );
         m_rootSheet = newSheet.get();
         loadHierarchy( newSheet.get() );
 
         // If we got here, the schematic loaded successfully.
         sheet = newSheet.release();
         m_rootSheet = nullptr;         // Quiet Coverity warning.
     }
     else
     {
         wxCHECK_MSG( aSchematic->IsValid(), nullptr, "Can't append to a schematic with no root!" );
         m_rootSheet = &aSchematic->Root();
         sheet = aAppendToMe;
         loadHierarchy( sheet );
     }
 
     wxASSERT( m_currentPath.size() == 1 );  // only the project path should remain
 
     return sheet;
 }

References SCH_SHEET::GetFileName(), PROJECT::GetProjectPath(), init(), SCHEMATIC::IsValid(), loadHierarchy(), m_currentPath, m_path, m_rootSheet, NULL, SCHEMATIC::Prj(), SCHEMATIC::Root(), and traceSchLegacyPlugin.

◆ loadBitmap()

SCH_BITMAP * SCH_LEGACY_PLUGIN::loadBitmap ( LINE_READER & aReader )

private

Definition at line 1093 of file sch_legacy_plugin.cpp.

 {
     std::unique_ptr<SCH_BITMAP> bitmap = std::make_unique<SCH_BITMAP>();
 
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "$Bitmap", line, &line ), NULL );
 
     line = aReader.ReadLine();
 
     while( line != NULL )
     {
         if( strCompare( "Pos", line, &line ) )
         {
             wxPoint position;
 
             position.x = Mils2Iu( parseInt( aReader, line, &line ) );
             position.y = Mils2Iu( parseInt( aReader, line, &line ) );
             bitmap->SetPosition( position );
         }
         else if( strCompare( "Scale", line, &line ) )
         {
             auto scalefactor = parseDouble( aReader, line, &line );
 
             // Prevent scalefactor values that cannot be displayed.
             // In the case of a bad value, we accept that the image might be mis-scaled
             // rather than removing the full image.  Users can then edit the scale factor in
             // Eeschema to the appropriate value
             if( !std::isnormal( scalefactor ) )
                 scalefactor = 1.0;
 
             bitmap->GetImage()->SetScale( scalefactor );
         }
         else if( strCompare( "Data", line, &line ) )
         {
             wxMemoryOutputStream stream;
 
             while( line )
             {
                 if( !aReader.ReadLine() )
                     SCH_PARSE_ERROR( _( "Unexpected end of file" ), aReader, line );
 
                 line = aReader.Line();
 
                 if( strCompare( "EndData", line ) )
                 {
                     // all the PNG date is read.
                     // We expect here m_image and m_bitmap are void
                     wxImage* image = new wxImage();
                     wxMemoryInputStream istream( stream );
                     image->LoadFile( istream, wxBITMAP_TYPE_PNG );
                     bitmap->GetImage()->SetImage( image );
                     bitmap->GetImage()->SetBitmap( new wxBitmap( *image ) );
                     break;
                 }
 
                 // Read PNG data, stored in hexadecimal,
                 // each byte = 2 hexadecimal digits and a space between 2 bytes
                 // and put it in memory stream buffer
                 int len = strlen( line );
 
                 for( ; len > 0 && !isspace( *line ); len -= 3, line += 3 )
                 {
                     int value = 0;
 
                     if( sscanf( line, "%X", &value ) == 1 )
                         stream.PutC( (char) value );
                     else
                         THROW_IO_ERROR( "invalid PNG data" );
                 }
             }
 
             if( line == NULL )
                 THROW_IO_ERROR( _( "unexpected end of file" ) );
         }
         else if( strCompare( "$EndBitmap", line ) )
             return bitmap.release();
 
         line = aReader.ReadLine();
     }
 
     THROW_IO_ERROR( _( "unexpected end of file" ) );
 }

References _, image, LINE_READER::Line(), Mils2Iu, NULL, parseDouble(), parseInt(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, strCompare(), and THROW_IO_ERROR.

Referenced by LoadContent().

◆ loadBusAlias()

std::shared_ptr< BUS_ALIAS > SCH_LEGACY_PLUGIN::loadBusAlias	(	LINE_READER &	aReader,
		SCH_SCREEN *	aScreen
	)

private

Definition at line 1809 of file sch_legacy_plugin.cpp.

 {
     auto busAlias = std::make_shared<BUS_ALIAS>( aScreen );
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "BusAlias", line, &line ), NULL );
 
     wxString buf;
     parseUnquotedString( buf, aReader, line, &line );
     busAlias->SetName( buf );
 
     while( *line != '\0' )
     {
         buf.clear();
         parseUnquotedString( buf, aReader, line, &line, true );
         if( buf.Len() > 0 )
         {
             busAlias->AddMember( buf );
         }
     }
 
     return busAlias;
 }

References LINE_READER::Line(), NULL, parseUnquotedString(), and strCompare().

Referenced by LoadContent().

◆ loadBusEntry()

SCH_BUS_ENTRY_BASE * SCH_LEGACY_PLUGIN::loadBusEntry ( LINE_READER & aReader )

private

Definition at line 1320 of file sch_legacy_plugin.cpp.

 {
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "Entry", line, &line ), NULL );
 
     std::unique_ptr<SCH_BUS_ENTRY_BASE> busEntry;
 
     if( strCompare( "Wire", line, &line ) )
     {
         busEntry = std::make_unique<SCH_BUS_WIRE_ENTRY>();
 
         if( !strCompare( "Line", line, &line ) )
             SCH_PARSE_ERROR( "invalid bus entry definition expected 'Line'", aReader, line );
     }
     else if( strCompare( "Bus", line, &line ) )
     {
         busEntry = std::make_unique<SCH_BUS_BUS_ENTRY>();
 
         if( !strCompare( "Bus", line, &line ) )
             SCH_PARSE_ERROR( "invalid bus entry definition expected 'Bus'", aReader, line );
     }
     else
         SCH_PARSE_ERROR( "invalid bus entry type", aReader, line );
 
     line = aReader.ReadLine();
 
     wxPoint pos;
     wxSize size;
 
     pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
     pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
     size.x = Mils2Iu( parseInt( aReader, line, &line ) );
     size.y = Mils2Iu( parseInt( aReader, line, &line ) );
 
     size.x -= pos.x;
     size.y -= pos.y;
 
     busEntry->SetPosition( pos );
     busEntry->SetSize( size );
 
     return busEntry.release();
 }

References LINE_READER::Line(), Mils2Iu, NULL, parseInt(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, and strCompare().

Referenced by LoadContent().

◆ loadComponent()

SCH_COMPONENT * SCH_LEGACY_PLUGIN::loadComponent ( LINE_READER & aReader )

private

Definition at line 1493 of file sch_legacy_plugin.cpp.

 {
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "$Comp", line, &line ), NULL );
 
     std::unique_ptr<SCH_COMPONENT> component = std::make_unique<SCH_COMPONENT>();
 
     line = aReader.ReadLine();
 
     while( line != NULL )
     {
         if( strCompare( "L", line, &line ) )
         {
             wxString libName;
             size_t pos = 2;                               // "X" plus ' ' space character.
             wxString utf8Line = wxString::FromUTF8( line );
             wxStringTokenizer tokens( utf8Line, " \r\n\t" );
 
             if( tokens.CountTokens() < 2 )
                 THROW_PARSE_ERROR( "invalid symbol library definition", aReader.GetSource(),
                                    aReader.Line(), aReader.LineNumber(), pos );
 
             libName = tokens.GetNextToken();
             libName.Replace( "~", " " );
 
             LIB_ID libId;
 
             // Prior to schematic version 4, library IDs did not have a library nickname so
             // parsing the symbol name with LIB_ID::Parse() would break symbol library links
             // that contained '/' and ':' characters.
             if( m_version > 3 )
                 libId.Parse( libName, true );
             else
                 libId.SetLibItemName( libName, false );
 
             component->SetLibId( libId );
 
             wxString refDesignator = tokens.GetNextToken();
 
             refDesignator.Replace( "~", " " );
 
             wxString prefix = refDesignator;
 
             while( prefix.Length() )
             {
                 if( ( prefix.Last() < '0' || prefix.Last() > '9') && prefix.Last() != '?' )
                     break;
 
                 prefix.RemoveLast();
             }
 
             // Avoid a prefix containing trailing/leading spaces
             prefix.Trim( true );
             prefix.Trim( false );
 
             if( prefix.IsEmpty() )
                 component->SetPrefix( wxString( "U" ) );
             else
                 component->SetPrefix( prefix );
         }
         else if( strCompare( "U", line, &line ) )
         {
             // This fixes a potentially buggy files caused by unit being set to zero which
             // causes netlist issues.  See https://bugs.launchpad.net/kicad/+bug/1677282.
             int unit = parseInt( aReader, line, &line );
 
             if( unit == 0 )
             {
                 unit = 1;
 
                 // Set the file as modified so the user can be warned.
                 if( m_rootSheet->GetScreen() )
                     m_rootSheet->GetScreen()->SetModify();
             }
 
             component->SetUnit( unit );
 
             // Same can also happen with the convert parameter
             int convert = parseInt( aReader, line, &line );
 
             if( convert == 0 )
             {
                 convert = 1;
 
                 // Set the file as modified so the user can be warned.
                 if( m_rootSheet->GetScreen() )
                     m_rootSheet->GetScreen()->SetModify();
             }
 
             component->SetConvert( convert );
 
             wxString text;
             parseUnquotedString( text, aReader, line, &line );
 
             if( text != "00000000" )
                 const_cast<KIID&>( component->m_Uuid ) = KIID( text );
         }
         else if( strCompare( "P", line, &line ) )
         {
             wxPoint pos;
 
             pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
             pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
             component->SetPosition( pos );
         }
         else if( strCompare( "AR", line, &line ) )
         {
             const char* strCompare = "Path=";
             int         len = strlen( strCompare );
 
             if( strncasecmp( strCompare, line, len ) != 0 )
                 SCH_PARSE_ERROR( "missing 'Path=' token", aReader, line );
 
             line += len;
             wxString pathStr, reference, unit;
 
             parseQuotedString( pathStr, aReader, line, &line );
 
             // Note: AR path excludes root sheet, but includes component.  Normalize to
             // internal format by shifting everything down one and adding the root sheet.
             KIID_PATH path( pathStr );
 
             if( path.size() > 0 )
             {
                 for( size_t i = path.size() - 1; i > 0; --i )
                     path[i] = path[i-1];
 
                 path[0] = m_rootSheet->m_Uuid;
             }
             else
                 path.push_back( m_rootSheet->m_Uuid );
 
             strCompare = "Ref=";
             len = strlen( strCompare );
 
             if( strncasecmp( strCompare, line, len ) != 0 )
                 SCH_PARSE_ERROR( "missing 'Ref=' token", aReader, line );
 
             line+= len;
             parseQuotedString( reference, aReader, line, &line );
 
             strCompare = "Part=";
             len = strlen( strCompare );
 
             if( strncasecmp( strCompare, line, len ) != 0 )
                 SCH_PARSE_ERROR( "missing 'Part=' token", aReader, line );
 
             line+= len;
             parseQuotedString( unit, aReader, line, &line );
 
             long tmp;
 
             if( !unit.ToLong( &tmp, 10 ) )
                 SCH_PARSE_ERROR( "expected integer value", aReader, line );
 
             if( tmp < 0 || tmp > MAX_UNIT_COUNT_PER_PACKAGE )
                 SCH_PARSE_ERROR( "unit value out of range", aReader, line );
 
             component->AddHierarchicalReference( path, reference, (int)tmp );
             component->GetField( REFERENCE_FIELD )->SetText( reference );
 
         }
         else if( strCompare( "F", line, &line ) )
         {
             int index = parseInt( aReader, line, &line );
 
             wxString text, name;
 
             parseQuotedString( text, aReader, line, &line, true );
 
             char orientation = parseChar( aReader, line, &line );
             wxPoint pos;
             pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
             pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
             int size = Mils2Iu( parseInt( aReader, line, &line ) );
             int attributes = parseHex( aReader, line, &line );
 
             if( index >= component->GetFieldCount() )
             {
                 // The first MANDATOR_FIELDS _must_ be constructed within
                 // the SCH_COMPONENT constructor.  This assert is simply here
                 // to guard against a change in that constructor.
                 wxASSERT( component->GetFieldCount() >= MANDATORY_FIELDS );
 
                 // Ignore the _supplied_ fieldNdx.  It is not important anymore
                 // if within the user defined fields region (i.e. >= MANDATORY_FIELDS).
                 // We freely renumber the index to fit the next available field slot.
                 index = component->GetFieldCount();  // new has this index after insertion
 
                 SCH_FIELD field( wxPoint( 0, 0 ), index, component.get(), name );
                 component->AddField( field );
             }
 
             SCH_FIELD& field = component->GetFields()[index];
 
             // Prior to version 2 of the schematic file format, none of the following existed.
             if( m_version > 1 )
             {
                 wxString textAttrs;
                 char hjustify = parseChar( aReader, line, &line );
 
                 parseUnquotedString( textAttrs, aReader, line, &line );
 
                 // The name of the field is optional.
                 parseQuotedString( name, aReader, line, &line, true );
 
                 if( hjustify == 'L' )
                     field.SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
                 else if( hjustify == 'R' )
                     field.SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
                 else if( hjustify != 'C' )
                     SCH_PARSE_ERROR( "component field text horizontal justification must be "
                                      "L, R, or C", aReader, line );
 
                 // We are guaranteed to have a least one character here for older file formats
                 // otherwise an exception would have been raised..
                 if( textAttrs[0] == 'T' )
                     field.SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
                 else if( textAttrs[0] == 'B' )
                     field.SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
                 else if( textAttrs[0] != 'C' )
                     SCH_PARSE_ERROR( "component field text vertical justification must be "
                                      "B, T, or C", aReader, line );
 
                 // Newer file formats include the bold and italics text attribute.
                 if( textAttrs.Length() > 1 )
                 {
                     if( textAttrs.Length() != 3 )
                         SCH_PARSE_ERROR( _( "component field text attributes must be 3 characters wide" ),
                                          aReader, line );
 
                     if( textAttrs[1] == 'I' )
                         field.SetItalic( true );
                     else if( textAttrs[1] != 'N' )
                         SCH_PARSE_ERROR( "component field text italics indicator must be I or N",
                                          aReader, line );
 
                     if( textAttrs[2] == 'B' )
                         field.SetBold( true );
                     else if( textAttrs[2] != 'N' )
                         SCH_PARSE_ERROR( "component field text bold indicator must be B or N",
                                          aReader, line );
                 }
             }
 
             field.SetText( text );
             field.SetTextPos( pos );
             field.SetVisible( !attributes );
             field.SetTextSize( wxSize( size, size ) );
 
             if( orientation == 'H' )
                 field.SetTextAngle( TEXT_ANGLE_HORIZ );
             else if( orientation == 'V' )
                 field.SetTextAngle( TEXT_ANGLE_VERT );
             else
                 SCH_PARSE_ERROR( "component field orientation must be H or V", aReader, line );
 
             if( name.IsEmpty() )
                 name = TEMPLATE_FIELDNAME::GetDefaultFieldName( index );
 
             field.SetName( name );
         }
         else if( strCompare( "$EndComp", line ) )
         {
             // Ensure all flags (some are set by previous initializations) are reset:
             component->ClearFlags();
             return component.release();
         }
         else
         {
             // There are two lines that begin with a tab or spaces that includes a line with the
             // redundant position information and the transform matrix settings.
 
             // Parse the redundant position information just the same to check for formatting
             // errors.
             parseInt( aReader, line, &line );    // Always 1.
             parseInt( aReader, line, &line );    // The X coordinate.
             parseInt( aReader, line, &line );    // The Y coordinate.
 
             line = aReader.ReadLine();
 
             TRANSFORM transform;
 
             transform.x1 = parseInt( aReader, line, &line );
 
             if( transform.x1 < -1 || transform.x1 > 1 )
                 SCH_PARSE_ERROR( "invalid component X1 transform value", aReader, line );
 
             transform.y1 = parseInt( aReader, line, &line );
 
             if( transform.y1 < -1 || transform.y1 > 1 )
                 SCH_PARSE_ERROR( "invalid component Y1 transform value", aReader, line );
 
             transform.x2 = parseInt( aReader, line, &line );
 
             if( transform.x2 < -1 || transform.x2 > 1 )
                 SCH_PARSE_ERROR( "invalid component X2 transform value", aReader, line );
 
             transform.y2 = parseInt( aReader, line, &line );
 
             if( transform.y2 < -1 || transform.y2 > 1 )
                 SCH_PARSE_ERROR( "invalid component Y2 transform value", aReader, line );
 
             component->SetTransform( transform );
         }
 
         line = aReader.ReadLine();
     }
 
     SCH_PARSE_ERROR( "invalid component line", aReader, line );
 
     return NULL;  // Prevents compiler warning.  Should never get here.
 }

References _, convert, TEMPLATE_FIELDNAME::GetDefaultFieldName(), SCH_SHEET::GetScreen(), LINE_READER::GetSource(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, LINE_READER::Line(), LINE_READER::LineNumber(), m_rootSheet, EDA_ITEM::m_Uuid, m_version, MANDATORY_FIELDS, MAX_UNIT_COUNT_PER_PACKAGE, Mils2Iu, name, NULL, LIB_ID::Parse(), parseChar(), parseHex(), parseInt(), parseQuotedString(), parseUnquotedString(), path, LINE_READER::ReadLine(), REFERENCE_FIELD, SCH_PARSE_ERROR, EDA_TEXT::SetBold(), EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetItalic(), LIB_ID::SetLibItemName(), BASE_SCREEN::SetModify(), SCH_FIELD::SetName(), EDA_TEXT::SetText(), EDA_TEXT::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetVertJustify(), EDA_TEXT::SetVisible(), strCompare(), text, TEXT_ANGLE_HORIZ, TEXT_ANGLE_VERT, THROW_PARSE_ERROR, TRANSFORM::x1, TRANSFORM::x2, TRANSFORM::y1, and TRANSFORM::y2.

Referenced by LoadContent().

◆ LoadContent()

void SCH_LEGACY_PLUGIN::LoadContent	(	LINE_READER &	aReader,
		SCH_SCREEN *	aScreen,
		int	version = `EESCHEMA_VERSION`
	)

Definition at line 771 of file sch_legacy_plugin.cpp.

 {
     m_version = version;
 
     // We cannot safely load content without a set root level.
     wxCHECK_RET( m_rootSheet,
             "Cannot call SCH_LEGACY_PLUGIN::LoadContent() without setting root sheet." );
 
     while( aReader.ReadLine() )
     {
         char* line = aReader.Line();
 
         while( *line == ' ' )
             line++;
 
         // Either an object will be loaded properly or the file load will fail and raise
         // an exception.
         if( strCompare( "$Descr", line ) )
             loadPageSettings( aReader, aScreen );
         else if( strCompare( "$Comp", line ) )
             aScreen->Append( loadComponent( aReader ) );
         else if( strCompare( "$Sheet", line ) )
             aScreen->Append( loadSheet( aReader ) );
         else if( strCompare( "$Bitmap", line ) )
             aScreen->Append( loadBitmap( aReader ) );
         else if( strCompare( "Connection", line ) )
             aScreen->Append( loadJunction( aReader ) );
         else if( strCompare( "NoConn", line ) )
             aScreen->Append( loadNoConnect( aReader ) );
         else if( strCompare( "Wire", line ) )
             aScreen->Append( loadWire( aReader ) );
         else if( strCompare( "Entry", line ) )
             aScreen->Append( loadBusEntry( aReader ) );
         else if( strCompare( "Text", line ) )
             aScreen->Append( loadText( aReader ) );
         else if( strCompare( "BusAlias", line ) )
             aScreen->AddBusAlias( loadBusAlias( aReader, aScreen ) );
         else if( strCompare( "$EndSCHEMATC", line ) )
             return;
         else
             SCH_PARSE_ERROR( "unrecognized token", aReader, line );
     }
 }

References SCH_SCREEN::AddBusAlias(), SCH_SCREEN::Append(), LINE_READER::Line(), loadBitmap(), loadBusAlias(), loadBusEntry(), loadComponent(), loadJunction(), loadNoConnect(), loadPageSettings(), loadSheet(), loadText(), loadWire(), m_rootSheet, m_version, LINE_READER::ReadLine(), SCH_PARSE_ERROR, and strCompare().

Referenced by loadFile().

◆ loadFile()

void SCH_LEGACY_PLUGIN::loadFile	(	const wxString &	aFileName,
		SCH_SCREEN *	aScreen
	)

private

Definition at line 748 of file sch_legacy_plugin.cpp.

 {
     FILE_LINE_READER reader( aFileName );
 
     loadHeader( reader, aScreen );
 
     LoadContent( reader, aScreen, m_version );
 
     // Unfortunately schematic files prior to version 2 are not terminated with $EndSCHEMATC
     // so checking for it's existance will fail so just exit here and take our chances. :(
     if( m_version > 1 )
     {
         char* line = reader.Line();
 
         while( *line == ' ' )
             line++;
 
         if( !strCompare( "$EndSCHEMATC", line ) )
             THROW_IO_ERROR( "'$EndSCHEMATC' not found" );
     }
 }

References LINE_READER::Line(), LoadContent(), loadHeader(), m_version, strCompare(), and THROW_IO_ERROR.

Referenced by loadHierarchy().

◆ loadHeader()

void SCH_LEGACY_PLUGIN::loadHeader	(	LINE_READER &	aReader,
		SCH_SCREEN *	aScreen
	)

private

Definition at line 816 of file sch_legacy_plugin.cpp.

 {
     const char* line = aReader.ReadLine();
 
     if( !line || !strCompare( "Eeschema Schematic File Version", line, &line ) )
     {
         m_error.Printf(
                 _( "\"%s\" does not appear to be an Eeschema file" ), aScreen->GetFileName() );
         THROW_IO_ERROR( m_error );
     }
 
     // get the file version here.
     m_version = parseInt( aReader, line, &line );
 
     // The next lines are the lib list section, and are mainly comments, like:
     // LIBS:power
     // the lib list is not used, but is in schematic file just in case.
     // It is usually not empty, but we accept empty list.
     // If empty, there is a legacy section, not used
     // EELAYER i j
     // and the last line is
     // EELAYER END
     // Skip all lines until the end of header "EELAYER END" is found
     while( aReader.ReadLine() )
     {
         line = aReader.Line();
 
         while( *line == ' ' )
             line++;
 
         if( strCompare( "EELAYER END", line ) )
             return;
     }
 
     THROW_IO_ERROR( _( "Missing 'EELAYER END'" ) );
 }

References _, SCH_SCREEN::GetFileName(), LINE_READER::Line(), m_error, m_version, parseInt(), LINE_READER::ReadLine(), strCompare(), and THROW_IO_ERROR.

Referenced by loadFile().

◆ loadHierarchy()

void SCH_LEGACY_PLUGIN::loadHierarchy ( SCH_SHEET * aSheet )

private

Definition at line 672 of file sch_legacy_plugin.cpp.

 {
     SCH_SCREEN* screen = NULL;
 
     if( !aSheet->GetScreen() )
     {
         // SCH_SCREEN objects store the full path and file name where the SCH_SHEET object only
         // stores the file name and extension.  Add the project path to the file name and
         // extension to compare when calling SCH_SHEET::SearchHierarchy().
         wxFileName fileName = aSheet->GetFileName();
         fileName.SetExt( "sch" );
 
         if( !fileName.IsAbsolute() )
             fileName.MakeAbsolute( m_currentPath.top() );
 
         // Save the current path so that it gets restored when decending and ascending the
         // sheet hierarchy which allows for sheet schematic files to be nested in folders
         // relative to the last path a schematic was loaded from.
         wxLogTrace( traceSchLegacyPlugin, "Saving path    \"%s\"", m_currentPath.top() );
         m_currentPath.push( fileName.GetPath() );
         wxLogTrace( traceSchLegacyPlugin, "Current path   \"%s\"", m_currentPath.top() );
         wxLogTrace( traceSchLegacyPlugin, "Loading        \"%s\"", fileName.GetFullPath() );
 
         m_rootSheet->SearchHierarchy( fileName.GetFullPath(), &screen );
 
         if( screen )
         {
             aSheet->SetScreen( screen );
             screen->SetParent( m_schematic );
             // Do not need to load the sub-sheets - this has already been done.
         }
         else
         {
             aSheet->SetScreen( new SCH_SCREEN( m_schematic ) );
             aSheet->GetScreen()->SetFileName( fileName.GetFullPath() );
 
             try
             {
                 loadFile( fileName.GetFullPath(), aSheet->GetScreen() );
             }
             catch( const IO_ERROR& ioe )
             {
                 // If there is a problem loading the root sheet, there is no recovery.
                 if( aSheet == m_rootSheet )
                     throw( ioe );
 
                 // For all subsheets, queue up the error message for the caller.
                 if( !m_error.IsEmpty() )
                     m_error += "\n";
 
                 m_error += ioe.What();
             }
 
             for( auto aItem : aSheet->GetScreen()->Items().OfType( SCH_SHEET_T ) )
             {
                 wxCHECK2( aItem->Type() == SCH_SHEET_T, continue );
                 auto sheet = static_cast<SCH_SHEET*>( aItem );
 
                 // Set the parent to aSheet.  This effectively creates a method to find
                 // the root sheet from any sheet so a pointer to the root sheet does not
                 // need to be stored globally.  Note: this is not the same as a hierarchy.
                 // Complex hierarchies can have multiple copies of a sheet.  This only
                 // provides a simple tree to find the root sheet.
                 sheet->SetParent( aSheet );
 
                 // Recursion starts here.
                 loadHierarchy( sheet );
             }
         }
 
         m_currentPath.pop();
         wxLogTrace( traceSchLegacyPlugin, "Restoring path \"%s\"", m_currentPath.top() );
     }
 }

References SCH_SHEET::GetFileName(), SCH_SHEET::GetScreen(), SCH_SCREEN::Items(), loadFile(), m_currentPath, m_error, m_rootSheet, m_schematic, NULL, EE_RTREE::OfType(), SCH_SHEET_T, SCH_SHEET::SearchHierarchy(), SCH_SCREEN::SetFileName(), EDA_ITEM::SetParent(), SCH_SHEET::SetScreen(), traceSchLegacyPlugin, and IO_ERROR::What().

Referenced by Load().

◆ loadJunction()

SCH_JUNCTION * SCH_LEGACY_PLUGIN::loadJunction ( LINE_READER & aReader )

private

Definition at line 1178 of file sch_legacy_plugin.cpp.

 {
     std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();
 
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "Connection", line, &line ), NULL );
 
     wxString name;
 
     parseUnquotedString( name, aReader, line, &line );
 
     wxPoint position;
 
     position.x = Mils2Iu( parseInt( aReader, line, &line ) );
     position.y = Mils2Iu( parseInt( aReader, line, &line ) );
     junction->SetPosition( position );
 
     return junction.release();
 }

References LINE_READER::Line(), Mils2Iu, name, NULL, parseInt(), parseUnquotedString(), and strCompare().

Referenced by LoadContent().

◆ loadNoConnect()

SCH_NO_CONNECT * SCH_LEGACY_PLUGIN::loadNoConnect ( LINE_READER & aReader )

private

Definition at line 1200 of file sch_legacy_plugin.cpp.

 {
     std::unique_ptr<SCH_NO_CONNECT> no_connect = std::make_unique<SCH_NO_CONNECT>();
 
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "NoConn", line, &line ), NULL );
 
     wxString name;
 
     parseUnquotedString( name, aReader, line, &line );
 
     wxPoint position;
 
     position.x = Mils2Iu( parseInt( aReader, line, &line ) );
     position.y = Mils2Iu( parseInt( aReader, line, &line ) );
     no_connect->SetPosition( position );
 
     return no_connect.release();
 }

References LINE_READER::Line(), Mils2Iu, name, NULL, parseInt(), parseUnquotedString(), and strCompare().

Referenced by LoadContent().

◆ loadPageSettings()

void SCH_LEGACY_PLUGIN::loadPageSettings	(	LINE_READER &	aReader,
		SCH_SCREEN *	aScreen
	)

private

Definition at line 854 of file sch_legacy_plugin.cpp.

 {
     wxASSERT( aScreen != NULL );
 
     wxString    buf;
     const char* line = aReader.Line();
 
     PAGE_INFO   pageInfo;
     TITLE_BLOCK tb;
 
     wxCHECK_RET( strCompare( "$Descr", line, &line ), "Invalid sheet description" );
 
     parseUnquotedString( buf, aReader, line, &line );
 
     if( !pageInfo.SetType( buf ) )
         SCH_PARSE_ERROR( "invalid page size", aReader, line );
 
     int pagew = parseInt( aReader, line, &line );
     int pageh = parseInt( aReader, line, &line );
 
     if( buf == PAGE_INFO::Custom )
     {
         pageInfo.SetWidthMils( pagew );
         pageInfo.SetHeightMils( pageh );
     }
     else
     {
         wxString orientation;
 
         // Non custom size, set portrait if its present.  Can be empty string which defaults
         // to landscape.
         parseUnquotedString( orientation, aReader, line, &line, true );
 
         if( orientation == "portrait" )
             pageInfo.SetPortrait( true );
     }
 
     aScreen->SetPageSettings( pageInfo );
 
     while( line != NULL )
     {
         buf.clear();
 
         if( !aReader.ReadLine() )
             SCH_PARSE_ERROR( _( "unexpected end of file" ), aReader, line );
 
         line = aReader.Line();
 
         if( strCompare( "Sheet", line, &line ) )
         {
             aScreen->SetVirtualPageNumber( parseInt( aReader, line, &line ) );
             aScreen->SetPageCount( parseInt( aReader, line, &line ) );
         }
         else if( strCompare( "Title", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetTitle( buf );
         }
         else if( strCompare( "Date", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetDate( buf );
         }
         else if( strCompare( "Rev", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetRevision( buf );
         }
         else if( strCompare( "Comp", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetCompany( buf );
         }
         else if( strCompare( "Comment1", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 0, buf );
         }
         else if( strCompare( "Comment2", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 1, buf );
         }
         else if( strCompare( "Comment3", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 2, buf );
         }
         else if( strCompare( "Comment4", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 3, buf );
         }
         else if( strCompare( "Comment5", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 4, buf );
         }
         else if( strCompare( "Comment6", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 5, buf );
         }
         else if( strCompare( "Comment7", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 6, buf );
         }
         else if( strCompare( "Comment8", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 7, buf );
         }
         else if( strCompare( "Comment9", line, &line ) )
         {
             parseQuotedString( buf, aReader, line, &line, true );
             tb.SetComment( 8, buf );
         }
         else if( strCompare( "$EndDescr", line ) )
         {
             aScreen->SetTitleBlock( tb );
             return;
         }
     }
 
     SCH_PARSE_ERROR( "missing 'EndDescr'", aReader, line );
 }

References _, PAGE_INFO::Custom, LINE_READER::Line(), NULL, parseInt(), parseQuotedString(), parseUnquotedString(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, TITLE_BLOCK::SetComment(), TITLE_BLOCK::SetCompany(), TITLE_BLOCK::SetDate(), PAGE_INFO::SetHeightMils(), BASE_SCREEN::SetPageCount(), SCH_SCREEN::SetPageSettings(), PAGE_INFO::SetPortrait(), TITLE_BLOCK::SetRevision(), TITLE_BLOCK::SetTitle(), SCH_SCREEN::SetTitleBlock(), PAGE_INFO::SetType(), BASE_SCREEN::SetVirtualPageNumber(), PAGE_INFO::SetWidthMils(), and strCompare().

Referenced by LoadContent().

◆ loadSheet()

SCH_SHEET * SCH_LEGACY_PLUGIN::loadSheet ( LINE_READER & aReader )

private

Definition at line 983 of file sch_legacy_plugin.cpp.

 {
     std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>();
 
     const char* line = aReader.ReadLine();
 
     while( line != NULL )
     {
         if( strCompare( "S", line, &line ) )        // Sheet dimensions.
         {
             wxPoint position;
 
             position.x = Mils2Iu( parseInt( aReader, line, &line ) );
             position.y = Mils2Iu( parseInt( aReader, line, &line ) );
             sheet->SetPosition( position );
 
             wxSize  size;
 
             size.SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );
             size.SetHeight( Mils2Iu( parseInt( aReader, line, &line ) ) );
             sheet->SetSize( size );
         }
         else if( strCompare( "U", line, &line ) )   // Sheet UUID.
         {
             wxString text;
             parseUnquotedString( text, aReader, line );
 
             if( text != "00000000" )
                 const_cast<KIID&>( sheet->m_Uuid ) = KIID( text );
         }
         else if( *line == 'F' )                     // Sheet field.
         {
             line++;
 
             wxString text;
             int size;
             int fieldId = parseInt( aReader, line, &line );
 
             if( fieldId == 0 || fieldId == 1 )      // Sheet name and file name.
             {
                 parseQuotedString( text, aReader, line, &line );
                 size = Mils2Iu( parseInt( aReader, line, &line ) );
 
                 SCH_FIELD& field = sheet->GetFields()[ fieldId ];
                 field.SetText( text );
                 field.SetTextSize( wxSize( size, size ) );
             }
             else                                   // Sheet pin.
             {
                 // Use a unique_ptr so that we clean up in the case of a throw
                 std::unique_ptr<SCH_SHEET_PIN> sheetPin = std::make_unique<SCH_SHEET_PIN>( sheet.get() );
 
                 sheetPin->SetNumber( fieldId );
 
                 // Can be empty fields.
                 parseQuotedString( text, aReader, line, &line, true );
 
                 sheetPin->SetText( text );
 
                 if( line == NULL )
                     THROW_IO_ERROR( _( "unexpected end of line" ) );
 
                 switch( parseChar( aReader, line, &line ) )
                 {
                 case 'I': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_INPUT );       break;
                 case 'O': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_OUTPUT );      break;
                 case 'B': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_BIDI );        break;
                 case 'T': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_TRISTATE );    break;
                 case 'U': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_UNSPECIFIED ); break;
                 default:  SCH_PARSE_ERROR( "invalid sheet pin type", aReader, line );
                 }
 
                 switch( parseChar( aReader, line, &line ) )
                 {
                 case 'R':  sheetPin->SetEdge( SHEET_RIGHT_SIDE );  break;
                 case 'T':  sheetPin->SetEdge( SHEET_TOP_SIDE );    break;
                 case 'B':  sheetPin->SetEdge( SHEET_BOTTOM_SIDE ); break;
                 case 'L':  sheetPin->SetEdge( SHEET_LEFT_SIDE );   break;
                 default:
                     SCH_PARSE_ERROR( "invalid sheet pin side", aReader, line );
                 }
 
                 wxPoint position;
 
                 position.x = Mils2Iu( parseInt( aReader, line, &line ) );
                 position.y = Mils2Iu( parseInt( aReader, line, &line ) );
                 sheetPin->SetPosition( position );
 
                 size = Mils2Iu( parseInt( aReader, line, &line ) );
 
                 sheetPin->SetTextSize( wxSize( size, size ) );
 
                 sheet->AddPin( sheetPin.release() );
             }
         }
         else if( strCompare( "$EndSheet", line ) )
         {
             sheet->AutoplaceFields( /* aScreen */ NULL, /* aManual */ false );
             return sheet.release();
         }
 
         line = aReader.ReadLine();
     }
 
     SCH_PARSE_ERROR( "missing '$EndSheet`", aReader, line );
 
     return NULL;  // Prevents compiler warning.  Should never get here.
 }

References _, Mils2Iu, NULL, parseChar(), parseInt(), parseQuotedString(), parseUnquotedString(), PS_BIDI, PS_INPUT, PS_OUTPUT, PS_TRISTATE, PS_UNSPECIFIED, LINE_READER::ReadLine(), SCH_PARSE_ERROR, EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), SHEET_BOTTOM_SIDE, SHEET_LEFT_SIDE, SHEET_RIGHT_SIDE, SHEET_TOP_SIDE, strCompare(), text, and THROW_IO_ERROR.

Referenced by LoadContent().

◆ LoadSymbol()

LIB_PART * SCH_LEGACY_PLUGIN::LoadSymbol	(	const wxString &	aLibraryPath,
		const wxString &	aPartName,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Load a LIB_PART object having aPartName from the aLibraryPath containing a library format that this SCH_PLUGIN knows about.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several symbols.
aPartName	is the name of the LIB_PART to load.
aProperties	is an associative array that can be used to tell the loader implementation to do something special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Returns: the part created on the heap if found caller shares it or NULL if not found.

Exceptions

IO_ERROR if the library cannot be found or read. No exception is thrown in the case where aAliasName cannot be found.

Reimplemented from SCH_PLUGIN.

Definition at line 4308 of file sch_legacy_plugin.cpp.

 {
     LOCALE_IO toggle;     // toggles on, then off, the C locale.
 
     cacheLib( aLibraryPath, aProperties );
 
     LIB_PART_MAP::const_iterator it = m_cache->m_symbols.find( aSymbolName );
 
     if( it == m_cache->m_symbols.end() )
         return nullptr;
 
     return it->second;
 }

References cacheLib(), m_cache, and SCH_LEGACY_PLUGIN_CACHE::m_symbols.

◆ loadText()

SCH_TEXT * SCH_LEGACY_PLUGIN::loadText ( LINE_READER & aReader )

private

Definition at line 1376 of file sch_legacy_plugin.cpp.

 {
     const char*   line = aReader.Line();
 
     wxCHECK( strCompare( "Text", line, &line ), NULL );
 
     std::unique_ptr<SCH_TEXT> text;
 
     if( strCompare( "Notes", line, &line ) )
         text.reset( new SCH_TEXT );
     else if( strCompare( "Label", line, &line ) )
         text.reset( new SCH_LABEL );
     else if( strCompare( "HLabel", line, &line ) )
         text.reset( new SCH_HIERLABEL );
     else if( strCompare( "GLabel", line, &line ) )
     {
         // Prior to version 2, the SCH_GLOBALLABEL object did not exist.
         if( m_version == 1 )
             text = std::make_unique<SCH_HIERLABEL>();
         else
             text = std::make_unique<SCH_GLOBALLABEL>();
     }
     else
         SCH_PARSE_ERROR( "unknown Text type", aReader, line );
 
     // Parse the parameters common to all text objects.
     wxPoint position;
 
     position.x = Mils2Iu( parseInt( aReader, line, &line ) );
     position.y = Mils2Iu( parseInt( aReader, line, &line ) );
     text->SetPosition( position );
 
     int spinStyle = parseInt( aReader, line, &line );
 
     // Sadly we store the orientation of hierarchical and global labels using a different
     // int encoding than that for local labels:
     //                   Global      Local
     // Left justified      0           2
     // Up                  1           3
     // Right justified     2           0
     // Down                3           1
     // So we must flip it as the enum is setup with the "global" numbering
     if( text->Type() != SCH_GLOBAL_LABEL_T && text->Type() != SCH_HIER_LABEL_T )
     {
         if( spinStyle == 0 )
             spinStyle = 2;
         else if( spinStyle == 2 )
             spinStyle = 0;
     }
 
     text->SetLabelSpinStyle( (LABEL_SPIN_STYLE::SPIN) spinStyle );
 
     int size = Mils2Iu( parseInt( aReader, line, &line ) );
 
     text->SetTextSize( wxSize( size, size ) );
 
     // Parse the global and hierarchical label type.
     if( text->Type() == SCH_HIER_LABEL_T || text->Type() == SCH_GLOBAL_LABEL_T )
     {
         auto resultIt = std::find_if( sheetLabelNames.begin(), sheetLabelNames.end(),
                 [ &line ]( const auto& it )
                 {
                     return strCompare( it.second, line, &line );
                 } );
 
         if( resultIt != sheetLabelNames.end() )
             text->SetShape( resultIt->first );
         else
             SCH_PARSE_ERROR( "invalid label type", aReader, line );
     }
 
     int penWidth = 0;
 
     // The following tokens do not exist in version 1 schematic files,
     // and not always in version 2 for HLabels and GLabels
     if( m_version > 1 )
     {
         if( m_version > 2 || *line >= ' ' )
         {
             if( strCompare( "Italic", line, &line ) )
                 text->SetItalic( true );
             else if( !strCompare( "~", line, &line ) )
                 SCH_PARSE_ERROR( _( "expected 'Italics' or '~'" ), aReader, line );
         }
 
         // The penWidth token does not exist in older versions of the schematic file format
         // so calling parseInt will be made only if the EOL is not reached.
         if( *line >= ' ' )
             penWidth = parseInt( aReader, line, &line );
     }
 
     text->SetBold( penWidth != 0 );
     text->SetTextThickness( penWidth != 0 ? GetPenSizeForBold( size ) : 0 );
 
     // Read the text string for the text.
     char* tmp = aReader.ReadLine();
 
     tmp = strtok( tmp, "\r\n" );
     wxString val = FROM_UTF8( tmp );
 
     for( ; ; )
     {
         int i = val.find( wxT( "\\n" ) );
 
         if( i == wxNOT_FOUND )
             break;
 
         val.erase( i, 2 );
         val.insert( i, wxT( "\n" ) );
     }
 
     text->SetText( val );
 
     return text.release();
 }

References _, FROM_UTF8(), GetPenSizeForBold(), LINE_READER::Line(), m_version, Mils2Iu, NULL, parseInt(), LINE_READER::ReadLine(), SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_PARSE_ERROR, sheetLabelNames, strCompare(), and text.

Referenced by LoadContent().

◆ loadWire()

SCH_LINE * SCH_LEGACY_PLUGIN::loadWire ( LINE_READER & aReader )

private

Definition at line 1222 of file sch_legacy_plugin.cpp.

 {
     std::unique_ptr<SCH_LINE> wire = std::make_unique<SCH_LINE>();
 
     const char* line = aReader.Line();
 
     wxCHECK( strCompare( "Wire", line, &line ), NULL );
 
     if( strCompare( "Wire", line, &line ) )
         wire->SetLayer( LAYER_WIRE );
     else if( strCompare( "Bus", line, &line ) )
         wire->SetLayer( LAYER_BUS );
     else if( strCompare( "Notes", line, &line ) )
         wire->SetLayer( LAYER_NOTES );
     else
         SCH_PARSE_ERROR( "invalid line type", aReader, line );
 
     if( !strCompare( "Line", line, &line ) )
         SCH_PARSE_ERROR( "invalid wire definition", aReader, line );
 
     // Since Sept 15, 2017, a line style is alloved (width, style, color)
     // Only non default values are stored
     while( !is_eol( *line ) )
     {
         wxString buf;
 
         parseUnquotedString( buf, aReader, line, &line );
 
         if( buf == ")" )
             continue;
 
         else if( buf == T_WIDTH )
         {
             int size = Mils2Iu( parseInt( aReader, line, &line ) );
             wire->SetLineWidth( size );
         }
         else if( buf == T_STYLE )
         {
             parseUnquotedString( buf, aReader, line, &line );
             PLOT_DASH_TYPE style = SCH_LINE::GetLineStyleByName( buf );
             wire->SetLineStyle( style );
         }
         else    // should be the color parameter.
         {
             // The color param is something like rgb(150, 40, 191)
             // and because there is no space between ( and 150
             // the first param is inside buf.
             // So break keyword and the first param into 2 separate strings.
             wxString prm, keyword;
             keyword = buf.BeforeLast( '(', &prm );
 
             if( ( keyword == T_COLOR ) || ( keyword == T_COLORA ) )
             {
                 long color[4] = { 0 };
 
                 int ii = 0;
 
                 if( !prm.IsEmpty() )
                 {
                     prm.ToLong( &color[ii] );
                     ii++;
                 }
 
                 int prm_count = ( keyword == T_COLORA ) ? 4 : 3;
                 // fix opacity to 1.0 or 255, when not exists in file
                 color[3] = 255;
 
                 for(; ii < prm_count && !is_eol( *line ); ii++ )
                 {
                     color[ii] = parseInt( aReader, line, &line );
 
                     // Skip the separator between values
                     if( *line == ',' || *line == ' ')
                         line++;
                 }
 
                 wire->SetLineColor( color[0]/255.0, color[1]/255.0, color[2]/255.0,color[3]/255.0 );
             }
         }
     }
 
     // Read the segment en points coordinates:
     line = aReader.ReadLine();
 
     wxPoint begin, end;
 
     begin.x = Mils2Iu( parseInt( aReader, line, &line ) );
     begin.y = Mils2Iu( parseInt( aReader, line, &line ) );
     end.x = Mils2Iu( parseInt( aReader, line, &line ) );
     end.y = Mils2Iu( parseInt( aReader, line, &line ) );
 
     wire->SetStartPoint( begin );
     wire->SetEndPoint( end );
 
     return wire.release();
 }

References color, SCH_LINE::GetLineStyleByName(), is_eol(), LAYER_BUS, LAYER_NOTES, LAYER_WIRE, LINE_READER::Line(), Mils2Iu, NULL, parseInt(), parseUnquotedString(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, strCompare(), T_COLOR, T_COLORA, T_STYLE, and T_WIDTH.

Referenced by LoadContent().

◆ ParsePart()

LIB_PART * SCH_LEGACY_PLUGIN::ParsePart	(	LINE_READER &	aReader,
		int	majorVersion = `0`,
		int	minorVersion = `0`
	)

static

Definition at line 4439 of file sch_legacy_plugin.cpp.

 {
     return SCH_LEGACY_PLUGIN_CACHE::LoadPart( reader, aMajorVersion, aMinorVersion );
 }

References SCH_LEGACY_PLUGIN_CACHE::LoadPart().

◆ Save()

void SCH_LEGACY_PLUGIN::Save	(	const wxString &	aFileName,
		SCH_SHEET *	aSheet,
		SCHEMATIC *	aSchematic,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Write aSchematic to a storage file in a format that this SCH_PLUGIN implementation knows about, or it can be used to write a portion of aSchematic to a special kind of export file.

Parameters

aFileName	is the name of a file to save to on disk.
aSheet	is the class SCH_SHEET in memory document tree from which to extract information when writing to aFileName. The caller continues to own the SCHEMATIC, and the plugin should refrain from modifying the SCHEMATIC if possible.
aSchematic	is the SCHEMATIC object used to access any schematic-wide or project information needed to save the document.
aProperties	is an associative array that can be used to tell the saver how to save the file, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL. Set the #PropSaveCurrentSheetOnly property to only save the current sheet. Otherwise, all hierarchical sheets are saved.

Exceptions

IO_ERROR if there is a problem saving or exporting.

Reimplemented from SCH_PLUGIN.

Definition at line 1835 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aSheet != NULL, "NULL SCH_SHEET object." );
     wxCHECK_RET( !aFileName.IsEmpty(), "No schematic file name defined." );
 
     LOCALE_IO   toggle;     // toggles on, then off, the C locale, to write floating point values.
 
     init( aSchematic, aProperties );
 
     wxFileName fn = aFileName;
 
     // File names should be absolute.  Don't assume everything relative to the project path
     // works properly.
     wxASSERT( fn.IsAbsolute() );
 
     FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
 
     m_out = &formatter;     // no ownership
 
     Format( aSheet );
 }

References Format(), init(), m_out, and NULL.

◆ saveBitmap()

void SCH_LEGACY_PLUGIN::saveBitmap ( SCH_BITMAP * aBitmap )

private

Definition at line 2146 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aBitmap != NULL, "SCH_BITMAP* is NULL" );
 
     const wxImage* image = aBitmap->GetImage()->GetImageData();
 
     wxCHECK_RET( image != NULL, "wxImage* is NULL" );
 
     m_out->Print( 0, "$Bitmap\n" );
     m_out->Print( 0, "Pos %-4d %-4d\n",
                   Iu2Mils( aBitmap->GetPosition().x ),
                   Iu2Mils( aBitmap->GetPosition().y ) );
     m_out->Print( 0, "Scale %f\n", aBitmap->GetImage()->GetScale() );
     m_out->Print( 0, "Data\n" );
 
     wxMemoryOutputStream stream;
 
     image->SaveFile( stream, wxBITMAP_TYPE_PNG );
 
     // Write binary data in hexadecimal form (ASCII)
     wxStreamBuffer* buffer = stream.GetOutputStreamBuffer();
     char*           begin  = (char*) buffer->GetBufferStart();
 
     for( int ii = 0; begin < buffer->GetBufferEnd(); begin++, ii++ )
     {
         if( ii >= 32 )
         {
             ii = 0;
 
             m_out->Print( 0, "\n" );
         }
 
         m_out->Print( 0, "%2.2X ", *begin & 0xFF );
     }
 
     m_out->Print( 0, "\nEndData\n" );
     m_out->Print( 0, "$EndBitmap\n" );
 }

References SCH_BITMAP::GetImage(), BITMAP_BASE::GetImageData(), SCH_BITMAP::GetPosition(), BITMAP_BASE::GetScale(), image, m_out, NULL, and OUTPUTFORMATTER::Print().

Referenced by Format().

◆ saveBusAlias()

void SCH_LEGACY_PLUGIN::saveBusAlias ( std::shared_ptr< BUS_ALIAS > aAlias )

private

Definition at line 2399 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aAlias != NULL, "BUS_ALIAS* is NULL" );
 
     wxString members = boost::algorithm::join( aAlias->Members(), " " );
 
     m_out->Print( 0, "BusAlias %s %s\n",
                   TO_UTF8( aAlias->GetName() ), TO_UTF8( members ) );
 }

References m_out, NULL, OUTPUTFORMATTER::Print(), and TO_UTF8.

Referenced by Format().

◆ saveBusEntry()

void SCH_LEGACY_PLUGIN::saveBusEntry ( SCH_BUS_ENTRY_BASE * aBusEntry )

private

Definition at line 2270 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aBusEntry != NULL, "SCH_BUS_ENTRY_BASE* is NULL" );
 
     if( aBusEntry->GetLayer() == LAYER_WIRE )
         m_out->Print( 0, "Entry Wire Line\n\t%-4d %-4d %-4d %-4d\n",
                       Iu2Mils( aBusEntry->GetPosition().x ),
                       Iu2Mils( aBusEntry->GetPosition().y ),
                       Iu2Mils( aBusEntry->GetEnd().x ), Iu2Mils( aBusEntry->GetEnd().y ) );
     else
         m_out->Print( 0, "Entry Bus Bus\n\t%-4d %-4d %-4d %-4d\n",
                       Iu2Mils( aBusEntry->GetPosition().x ),
                       Iu2Mils( aBusEntry->GetPosition().y ),
                       Iu2Mils( aBusEntry->GetEnd().x ), Iu2Mils( aBusEntry->GetEnd().y ) );
 }

References SCH_BUS_ENTRY_BASE::GetEnd(), SCH_ITEM::GetLayer(), SCH_BUS_ENTRY_BASE::GetPosition(), LAYER_WIRE, m_out, NULL, and OUTPUTFORMATTER::Print().

Referenced by Format().

◆ saveComponent()

void SCH_LEGACY_PLUGIN::saveComponent ( SCH_COMPONENT * aComponent )

private

Definition at line 2003 of file sch_legacy_plugin.cpp.

 {
     std::string     name1;
     std::string     name2;
 
     static wxString delimiters( wxT( " " ) );
 
     // This is redundant with the AR entries below, but it makes the files backwards-compatible.
     if( aComponent->GetInstanceReferences().size() > 0 )
     {
         const SYMBOL_INSTANCE_REFERENCE& instance = aComponent->GetInstanceReferences()[0];
         name1 = toUTFTildaText( instance.m_Reference );
     }
     else
     {
         if( aComponent->GetField( REFERENCE_FIELD )->GetText().IsEmpty() )
             name1 = toUTFTildaText( aComponent->GetPrefix() );
         else
             name1 = toUTFTildaText( aComponent->GetField( REFERENCE_FIELD )->GetText() );
     }
 
     wxString part_name = aComponent->GetLibId().Format();
 
     if( part_name.size() )
     {
         name2 = toUTFTildaText( part_name );
     }
     else
     {
         name2 = "_NONAME_";
     }
 
     m_out->Print( 0, "$Comp\n" );
     m_out->Print( 0, "L %s %s\n", name2.c_str(), name1.c_str() );
 
     // Generate unit number, conversion and timestamp
     m_out->Print( 0, "U %d %d %8.8X\n",
                   aComponent->GetUnit(),
                   aComponent->GetConvert(),
                   aComponent->m_Uuid.AsLegacyTimestamp() );
 
     // Save the position
     m_out->Print( 0, "P %d %d\n",
                   Iu2Mils( aComponent->GetPosition().x ),
                   Iu2Mils( aComponent->GetPosition().y ) );
 
     /* If this is a complex hierarchy; save hierarchical references.
      * but for simple hierarchies it is not necessary.
      * the reference inf is already saved
      * this is useful for old Eeschema version compatibility
      */
     if( aComponent->GetInstanceReferences().size() > 1 )
     {
         for( const SYMBOL_INSTANCE_REFERENCE& instance : aComponent->GetInstanceReferences() )
         {
             /*format:
              * AR Path="/140/2" Ref="C99"   Part="1"
              * where 140 is the uid of the containing sheet
              * and 2 is the timestamp of this component.
              * (timestamps are actually 8 hex chars)
              * Ref is the conventional component reference for this 'path'
              * Part is the conventional component part selection for this 'path'
              */
             wxString path = "/";
 
             // Skip root sheet
             for( int i = 1; i < (int) instance.m_Path.size(); ++i )
                 path += instance.m_Path[i].AsLegacyTimestampString() + "/";
 
             m_out->Print( 0, "AR Path=\"%s\" Ref=\"%s\"  Part=\"%d\" \n",
                           TO_UTF8( path + aComponent->m_Uuid.AsLegacyTimestampString() ),
                           TO_UTF8( instance.m_Reference ),
                           instance.m_Unit );
         }
     }
 
     // update the ugly field id, which I would like to see go away someday soon.
     for( int i = 0;  i < aComponent->GetFieldCount();  ++i )
         aComponent->GetFields()[i].SetId( i );
 
     // Fixed fields:
     // Save mandatory fields even if they are blank,
     // because the visibility, size and orientation are set from library editor.
     for( unsigned i = 0; i < MANDATORY_FIELDS; ++i )
         saveField( &aComponent->GetFields()[i] );
 
     // User defined fields:
     // The *policy* about which user defined fields are part of a symbol is now
     // only in the dialog editors.  No policy should be enforced here, simply
     // save all the user defined fields, they are present because a dialog editor
     // thought they should be.  If you disagree, go fix the dialog editors.
     for( int i = MANDATORY_FIELDS;  i < aComponent->GetFieldCount();  ++i )
         saveField( &aComponent->GetFields()[i] );
 
     // Unit number, position, box ( old standard )
     m_out->Print( 0, "\t%-4d %-4d %-4d\n", aComponent->GetUnit(),
                   Iu2Mils( aComponent->GetPosition().x ),
                   Iu2Mils( aComponent->GetPosition().y ) );
 
     TRANSFORM transform = aComponent->GetTransform();
 
     m_out->Print( 0, "\t%-4d %-4d %-4d %-4d\n",
                   transform.x1, transform.y1, transform.x2, transform.y2 );
     m_out->Print( 0, "$EndComp\n" );
 }

Referenced by Format().

◆ saveField()

void SCH_LEGACY_PLUGIN::saveField ( SCH_FIELD * aField )

private

Definition at line 2110 of file sch_legacy_plugin.cpp.

 {
     char hjustify = 'C';
 
     if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_LEFT )
         hjustify = 'L';
     else if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_RIGHT )
         hjustify = 'R';
 
     char vjustify = 'C';
 
     if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_BOTTOM )
         vjustify = 'B';
     else if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_TOP )
         vjustify = 'T';
 
     m_out->Print( 0, "F %d %s %c %-3d %-3d %-3d %4.4X %c %c%c%c",
                   aField->GetId(),
                   EscapedUTF8( aField->GetText() ).c_str(),     // wraps in quotes too
                   aField->GetTextAngle() == TEXT_ANGLE_HORIZ ? 'H' : 'V',
                   Iu2Mils( aField->GetLibPosition().x ),
                   Iu2Mils( aField->GetLibPosition().y ),
                   Iu2Mils( aField->GetTextWidth() ),
                   !aField->IsVisible(),
                   hjustify, vjustify,
                   aField->IsItalic() ? 'I' : 'N',
                   aField->IsBold() ? 'B' : 'N' );
 
     // Save field name, if the name is user definable
     if( aField->GetId() >= MANDATORY_FIELDS )
         m_out->Print( 0, " %s", EscapedUTF8( aField->GetName() ).c_str() );
 
     m_out->Print( 0, "\n" );
 }

References EscapedUTF8(), EDA_TEXT::GetHorizJustify(), SCH_FIELD::GetId(), SCH_FIELD::GetLibPosition(), SCH_FIELD::GetName(), EDA_TEXT::GetText(), EDA_TEXT::GetTextAngle(), EDA_TEXT::GetTextWidth(), EDA_TEXT::GetVertJustify(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, EDA_TEXT::IsBold(), EDA_TEXT::IsItalic(), EDA_TEXT::IsVisible(), m_out, MANDATORY_FIELDS, OUTPUTFORMATTER::Print(), and TEXT_ANGLE_HORIZ.

Referenced by saveComponent().

◆ saveJunction()

void SCH_LEGACY_PLUGIN::saveJunction ( SCH_JUNCTION * aJunction )

private

Definition at line 2250 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aJunction != NULL, "SCH_JUNCTION* is NULL" );
 
     m_out->Print( 0, "Connection ~ %-4d %-4d\n",
                   Iu2Mils( aJunction->GetPosition().x ),
                   Iu2Mils( aJunction->GetPosition().y ) );
 }

References SCH_JUNCTION::GetPosition(), m_out, NULL, and OUTPUTFORMATTER::Print().

Referenced by Format().

◆ SaveLibrary()

void SCH_LEGACY_PLUGIN::SaveLibrary	(	const wxString &	aLibraryPath,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Reimplemented from SCH_PLUGIN.

Definition at line 4398 of file sch_legacy_plugin.cpp.

 {
     if( !m_cache )
         m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryPath );
 
     wxString oldFileName = m_cache->GetFileName();
 
     if( !m_cache->IsFile( aLibraryPath ) )
     {
         m_cache->SetFileName( aLibraryPath );
     }
 
     // This is a forced save.
     m_cache->SetModified();
     m_cache->Save( writeDocFile( aProperties ) );
     m_cache->SetFileName( oldFileName );
 }

References SCH_LEGACY_PLUGIN_CACHE::GetFileName(), SCH_LEGACY_PLUGIN_CACHE::IsFile(), m_cache, SCH_LEGACY_PLUGIN_CACHE::Save(), SCH_LEGACY_PLUGIN_CACHE::SetFileName(), SCH_LEGACY_PLUGIN_CACHE::SetModified(), and writeDocFile().

◆ saveLine()

void SCH_LEGACY_PLUGIN::saveLine ( SCH_LINE * aLine )

private

Definition at line 2287 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aLine != NULL, "SCH_LINE* is NULL" );
 
     const char* layer = "Notes";
     const char* width = "Line";
 
     if( aLine->GetLayer() == LAYER_WIRE )
         layer = "Wire";
     else if( aLine->GetLayer() == LAYER_BUS )
         layer = "Bus";
 
     m_out->Print( 0, "Wire %s %s", layer, width );
 
     // Write line style (width, type, color) only for non default values
     if( aLine->IsGraphicLine() )
     {
         if( aLine->GetLineSize() != 0 )
             m_out->Print( 0, " %s %d", T_WIDTH, Iu2Mils( aLine->GetLineSize() ) );
 
         if( aLine->GetLineStyle() != aLine->GetDefaultStyle() )
             m_out->Print( 0, " %s %s", T_STYLE,
                           SCH_LINE::GetLineStyleName( aLine->GetLineStyle() ) );
 
         if( aLine->GetLineColor() != COLOR4D::UNSPECIFIED )
             m_out->Print( 0, " %s",
                 TO_UTF8( aLine->GetLineColor().ToColour().GetAsString( wxC2S_CSS_SYNTAX ) ) );
     }
 
     m_out->Print( 0, "\n" );
 
     m_out->Print( 0, "\t%-4d %-4d %-4d %-4d",
                   Iu2Mils( aLine->GetStartPoint().x ), Iu2Mils( aLine->GetStartPoint().y ),
                   Iu2Mils( aLine->GetEndPoint().x ), Iu2Mils( aLine->GetEndPoint().y ) );
 
     m_out->Print( 0, "\n");
 }

References SCH_LINE::GetDefaultStyle(), SCH_LINE::GetEndPoint(), SCH_ITEM::GetLayer(), SCH_LINE::GetLineColor(), SCH_LINE::GetLineSize(), SCH_LINE::GetLineStyle(), SCH_LINE::GetLineStyleName(), SCH_LINE::GetStartPoint(), SCH_LINE::IsGraphicLine(), LAYER_BUS, LAYER_WIRE, m_out, NULL, OUTPUTFORMATTER::Print(), T_STYLE, T_WIDTH, and TO_UTF8.

Referenced by Format().

◆ saveNoConnect()

void SCH_LEGACY_PLUGIN::saveNoConnect ( SCH_NO_CONNECT * aNoConnect )

private

Definition at line 2260 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aNoConnect != NULL, "SCH_NOCONNECT* is NULL" );
 
     m_out->Print( 0, "NoConn ~ %-4d %-4d\n",
                   Iu2Mils( aNoConnect->GetPosition().x ),
                   Iu2Mils( aNoConnect->GetPosition().y ) );
 }

References SCH_NO_CONNECT::GetPosition(), m_out, NULL, and OUTPUTFORMATTER::Print().

Referenced by Format().

◆ saveSheet()

void SCH_LEGACY_PLUGIN::saveSheet ( SCH_SHEET * aSheet )

private

Definition at line 2186 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aSheet != NULL, "SCH_SHEET* is NULL" );
 
     m_out->Print( 0, "$Sheet\n" );
     m_out->Print( 0, "S %-4d %-4d %-4d %-4d\n",
                   Iu2Mils( aSheet->GetPosition().x ),
                   Iu2Mils( aSheet->GetPosition().y ),
                   Iu2Mils( aSheet->GetSize().x ),
                   Iu2Mils( aSheet->GetSize().y ) );
 
     m_out->Print( 0, "U %8.8X\n", aSheet->m_Uuid.AsLegacyTimestamp() );
 
     SCH_FIELD& sheetName = aSheet->GetFields()[SHEETNAME];
     SCH_FIELD& fileName = aSheet->GetFields()[SHEETFILENAME];
 
     if( !sheetName.GetText().IsEmpty() )
         m_out->Print( 0, "F0 %s %d\n",
                       EscapedUTF8( sheetName.GetText() ).c_str(),
                       Iu2Mils( sheetName.GetTextSize().x ) );
 
     if( !fileName.GetText().IsEmpty() )
         m_out->Print( 0, "F1 %s %d\n",
                       EscapedUTF8( fileName.GetText() ).c_str(),
                       Iu2Mils( fileName.GetTextSize().x ) );
 
     for( const SCH_SHEET_PIN* pin : aSheet->GetPins() )
     {
         int type, side;
 
         if( pin->GetText().IsEmpty() )
             break;
 
         switch( pin->GetEdge() )
         {
         default:
         case SHEET_LEFT_SIDE:   side = 'L'; break;
         case SHEET_RIGHT_SIDE:  side = 'R'; break;
         case SHEET_TOP_SIDE:    side = 'T'; break;
         case SHEET_BOTTOM_SIDE: side = 'B'; break;
         }
 
         switch( pin->GetShape() )
         {
         default:
         case PINSHEETLABEL_SHAPE::PS_UNSPECIFIED: type = 'U'; break;
         case PINSHEETLABEL_SHAPE::PS_INPUT:       type = 'I'; break;
         case PINSHEETLABEL_SHAPE::PS_OUTPUT:      type = 'O'; break;
         case PINSHEETLABEL_SHAPE::PS_BIDI:        type = 'B'; break;
         case PINSHEETLABEL_SHAPE::PS_TRISTATE:    type = 'T'; break;
         }
 
         m_out->Print( 0, "F%d %s %c %c %-3d %-3d %-3d\n",
                       pin->GetNumber(),
                       EscapedUTF8( pin->GetText() ).c_str(),     // supplies wrapping quotes
                       type, side, Iu2Mils( pin->GetPosition().x ),
                       Iu2Mils( pin->GetPosition().y ),
                       Iu2Mils( pin->GetTextWidth() ) );
     }
 
     m_out->Print( 0, "$EndSheet\n" );
 }

References KIID::AsLegacyTimestamp(), EscapedUTF8(), SCH_SHEET::GetFields(), SCH_SHEET::GetPins(), SCH_SHEET::GetPosition(), SCH_SHEET::GetSize(), EDA_TEXT::GetText(), EDA_TEXT::GetTextSize(), m_out, EDA_ITEM::m_Uuid, NULL, pin, OUTPUTFORMATTER::Print(), PS_BIDI, PS_INPUT, PS_OUTPUT, PS_TRISTATE, PS_UNSPECIFIED, SHEET_BOTTOM_SIDE, SHEET_LEFT_SIDE, SHEET_RIGHT_SIDE, SHEET_TOP_SIDE, SHEETFILENAME, and SHEETNAME.

Referenced by Format().

◆ SaveSymbol()

void SCH_LEGACY_PLUGIN::SaveSymbol	(	const wxString &	aLibraryPath,
		const LIB_PART *	aSymbol,
		const PROPERTIES *	aProperties = `nullptr`
	)

overridevirtual

Write aSymbol to an existing library located at aLibraryPath.

If a LIB_PART by the same name already exists or there are any conflicting alias names, the new LIB_PART will silently overwrite any existing aliases and/or part because libraries cannot have duplicate alias names. It is the responsibility of the caller to check the library for conflicts before saving.

Parameters

aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing several symbols.
aSymbol	is what to store in the library. The library is refreshed and the caller must update any LIB_PART pointers that may have changed.
aProperties	is an associative array that can be used to tell the saver how to save the symbol, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.

Exceptions

IO_ERROR if there is a problem saving.

Reimplemented from SCH_PLUGIN.

Definition at line 4324 of file sch_legacy_plugin.cpp.

 {
     LOCALE_IO toggle;     // toggles on, then off, the C locale.
 
     cacheLib( aLibraryPath, aProperties );
 
     m_cache->AddSymbol( aSymbol );
 
     if( !isBuffering( aProperties ) )
         m_cache->Save( writeDocFile( aProperties ) );
 }

References SCH_LEGACY_PLUGIN_CACHE::AddSymbol(), cacheLib(), isBuffering(), m_cache, SCH_LEGACY_PLUGIN_CACHE::Save(), and writeDocFile().

◆ saveText()

void SCH_LEGACY_PLUGIN::saveText ( SCH_TEXT * aText )

private

Definition at line 2326 of file sch_legacy_plugin.cpp.

 {
     wxCHECK_RET( aText != NULL, "SCH_TEXT* is NULL" );
 
     const char* italics  = "~";
     const char* textType = "Notes";
 
     if( aText->IsItalic() )
         italics = "Italic";
 
     wxString text = aText->GetText();
 
     SCH_LAYER_ID layer = aText->GetLayer();
 
     if( layer == LAYER_NOTES || layer == LAYER_LOCLABEL )
     {
         if( layer == LAYER_NOTES )
         {
             // For compatibility reasons, the text must be saved in only one text line
             // so replace all EOLs with \\n
             text.Replace( wxT( "\n" ), wxT( "\\n" ) );
 
             // Here we should have no CR or LF character in line
             // This is not always the case if a multiline text was copied (using a copy/paste
             // function) from a text that uses E.O.L characters that differs from the current
             // EOL format.  This is mainly the case under Linux using LF symbol when copying
             // a text from Windows (using CRLF symbol) so we must just remove the extra CR left
             // (or LF left under MacOSX)
             for( unsigned ii = 0; ii < text.Len();  )
             {
                 if( text[ii] == 0x0A || text[ii] == 0x0D )
                     text.erase( ii, 1 );
                 else
                     ii++;
             }
         }
         else
         {
             textType = "Label";
         }
 
         // Local labels must have their spin style inverted for left and right
         int spinStyle = static_cast<int>( aText->GetLabelSpinStyle() );
 
         if( spinStyle == 0 )
             spinStyle = 2;
         else if( spinStyle == 2 )
             spinStyle = 0;
 
         m_out->Print( 0, "Text %s %-4d %-4d %-4d %-4d %s %d\n%s\n", textType,
                       Iu2Mils( aText->GetPosition().x ), Iu2Mils( aText->GetPosition().y ),
                       spinStyle,
                       Iu2Mils( aText->GetTextWidth() ),
                       italics, Iu2Mils( aText->GetTextThickness() ), TO_UTF8( text ) );
     }
     else if( layer == LAYER_GLOBLABEL || layer == LAYER_HIERLABEL )
     {
         textType = ( layer == LAYER_GLOBLABEL ) ? "GLabel" : "HLabel";
 
         auto shapeLabelIt = sheetLabelNames.find( aText->GetShape() );
         wxCHECK_RET( shapeLabelIt != sheetLabelNames.end(), "Shape not found in names list" );
 
         m_out->Print( 0, "Text %s %-4d %-4d %-4d %-4d %s %s %d\n%s\n", textType,
                       Iu2Mils( aText->GetPosition().x ), Iu2Mils( aText->GetPosition().y ),
                       static_cast<int>( aText->GetLabelSpinStyle() ),
                       Iu2Mils( aText->GetTextWidth() ),
                       shapeLabelIt->second,
                       italics,
                       Iu2Mils( aText->GetTextThickness() ), TO_UTF8( text ) );
     }
 }

References SCH_TEXT::GetLabelSpinStyle(), SCH_ITEM::GetLayer(), SCH_TEXT::GetPosition(), SCH_TEXT::GetShape(), EDA_TEXT::GetText(), EDA_TEXT::GetTextThickness(), EDA_TEXT::GetTextWidth(), EDA_TEXT::IsItalic(), LAYER_GLOBLABEL, LAYER_HIERLABEL, LAYER_LOCLABEL, LAYER_NOTES, m_out, NULL, OUTPUTFORMATTER::Print(), sheetLabelNames, text, and TO_UTF8.

Referenced by Format().

◆ SetReporter()

virtual void SCH_PLUGIN::SetReporter ( REPORTER * aReporter )

inlinevirtualinherited

Set an optional reporter for warnings/errors.

Reimplemented in SCH_EAGLE_PLUGIN, SCH_ALTIUM_PLUGIN, and CADSTAR_SCH_ARCHIVE_PLUGIN.

Definition at line 165 of file sch_io_mgr.h.

165 {}

◆ SymbolLibOptions()

void SCH_PLUGIN::SymbolLibOptions ( PROPERTIES * aListToAppendTo ) const

virtualinherited

Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions.

Options are typically appended so that a derived SCH_PLUGIN can call its base class function by the same name first, thus inheriting options declared there. (Some base class options could pertain to all Symbol*() functions in all derived SCH_PLUGINs.) Note that since aListToAppendTo is a PROPERTIES object, all options will be unique and last guy wins.

Parameters

aListToAppendTo

holds a tuple of

option: This eventually is what shows up into the fp-lib-table "options" field, possibly combined with others.
internationalized description: The internationalized description is displayed in DIALOG_FP_SCH_PLUGIN_OPTIONS. It may be multi-line and be quite explanatory of the option.

In the future perhaps aListToAppendTo evolves to something capable of also holding a wxValidator for the cells in said dialog: http://forums.wxwidgets.org/viewtopic.php?t=23277&p=104180. This would require a 3 column list, and introducing wx GUI knowledge to SCH_PLUGIN, which has been avoided to date.

Definition at line 133 of file sch_plugin.cpp.

 {
     // disable all these in another couple of months, after everyone has seen them:
 #if 1
     (*aListToAppendTo)["debug_level"] = UTF8( _(
         "Enable <b>debug</b> logging for Symbol*() functions in this SCH_PLUGIN."
         ) );
 
     (*aListToAppendTo)["read_filter_regex"] = UTF8( _(
         "Regular expression <b>symbol name</b> filter."
         ) );
 
     (*aListToAppendTo)["enable_transaction_logging"] = UTF8( _(
         "Enable transaction logging. The mere presence of this option turns on the "
         "logging, no need to set a Value."
         ) );
 
     (*aListToAppendTo)["username"] = UTF8( _(
         "User name for <b>login</b> to some special library server."
         ) );
 
     (*aListToAppendTo)["password"] = UTF8( _(
         "Password for <b>login</b> to some special library server."
         ) );
 #endif
 
 #if 1
     // Suitable for a C++ to python SCH_PLUGIN::Footprint*() adapter, move it to the adapter
     // if and when implemented.
     (*aListToAppendTo)["python_symbol_plugin"] = UTF8( _(
         "Enter the python symbol which implements the SCH_PLUGIN::Symbol*() functions."
         ) );
 #endif
 }

References _.

◆ writeDocFile()

bool SCH_LEGACY_PLUGIN::writeDocFile ( const PROPERTIES * aProperties )

private

Definition at line 4239 of file sch_legacy_plugin.cpp.

 {
     std::string propName( SCH_LEGACY_PLUGIN::PropNoDocFile );
 
     if( aProperties && aProperties->find( propName ) != aProperties->end() )
         return false;
 
     return true;
 }

References PropNoDocFile.

Referenced by CreateSymbolLib(), DeleteSymbol(), SaveLibrary(), and SaveSymbol().

Member Data Documentation

◆ m_cache

SCH_LEGACY_PLUGIN_CACHE* SCH_LEGACY_PLUGIN::m_cache

protected

Definition at line 181 of file sch_legacy_plugin.h.

Referenced by cacheLib(), CreateSymbolLib(), DeleteSymbol(), DeleteSymbolLib(), EnumerateSymbolLib(), GetModifyHash(), init(), LoadSymbol(), SaveLibrary(), SaveSymbol(), and ~SCH_LEGACY_PLUGIN().

◆ m_currentPath

std::stack<wxString> SCH_LEGACY_PLUGIN::m_currentPath

protected

Stack to maintain nested sheet paths.

Definition at line 178 of file sch_legacy_plugin.h.

Referenced by Load(), and loadHierarchy().

◆ m_error

wxString SCH_LEGACY_PLUGIN::m_error

protected

For throwing exceptions or errors on partial schematic loads.

Definition at line 175 of file sch_legacy_plugin.h.

Referenced by GetError(), loadHeader(), and loadHierarchy().

◆ m_out

OUTPUTFORMATTER* SCH_LEGACY_PLUGIN::m_out

protected

The output formatter for saving SCH_SCREEN objects.

Definition at line 180 of file sch_legacy_plugin.h.

Referenced by Format(), init(), Save(), saveBitmap(), saveBusAlias(), saveBusEntry(), saveComponent(), saveField(), saveJunction(), saveLine(), saveNoConnect(), saveSheet(), and saveText().

◆ m_path

wxString SCH_LEGACY_PLUGIN::m_path

protected

Root project path for loading child sheets.

Definition at line 177 of file sch_legacy_plugin.h.

Referenced by Load().

◆ m_rootSheet

SCH_SHEET* SCH_LEGACY_PLUGIN::m_rootSheet

protected

The root sheet of the schematic being loaded..

Definition at line 179 of file sch_legacy_plugin.h.

Referenced by init(), Load(), loadComponent(), LoadContent(), and loadHierarchy().

◆ m_schematic

SCHEMATIC* SCH_LEGACY_PLUGIN::m_schematic

protected

Passed to Load(), the schematic object being loaded.

Definition at line 182 of file sch_legacy_plugin.h.

Referenced by Format(), init(), and loadHierarchy().

◆ m_version

int SCH_LEGACY_PLUGIN::m_version

protected

Version of file being loaded.

Definition at line 172 of file sch_legacy_plugin.h.

Referenced by init(), loadComponent(), LoadContent(), loadFile(), loadHeader(), and loadText().

◆ PropBuffering

const char * SCH_LEGACY_PLUGIN::PropBuffering = "buffering"

static

The property used internally by the plugin to enable cache buffering which prevents the library file from being written every time the cache is changed.

This is useful when writing the schematic cache library file or saving a library to a new file name.

Definition at line 90 of file sch_legacy_plugin.h.

Referenced by PART_LIB::EnableBuffering(), isBuffering(), PART_LIB::IsBuffering(), SCH_EAGLE_PLUGIN::Load(), SYMBOL_LIB_TABLE_RESCUER::OpenRescueLibrary(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer(), and SYMBOL_LIBRARY_MANAGER::SaveLibrary().

◆ PropNoDocFile

const char * SCH_LEGACY_PLUGIN::PropNoDocFile = "no_doc_file"

static

The property used internally by the plugin to disable writing the library documentation (.dcm) file when saving the library cache.

Definition at line 96 of file sch_legacy_plugin.h.

Referenced by PART_LIB::IsCache(), PART_LIB::Save(), PART_LIB::SetCache(), and writeDocFile().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ SCH_LEGACY_PLUGIN()

◆ ~SCH_LEGACY_PLUGIN()

Member Function Documentation

◆ cacheLib()

◆ CheckHeader()

◆ CreateSymbolLib()

◆ DeleteSymbol()

◆ DeleteSymbolLib()

◆ EnumerateSymbolLib() [1/2]

◆ EnumerateSymbolLib() [2/2]

◆ Format() [1/2]

◆ Format() [2/2]

◆ FormatPart()

◆ GetError()

◆ GetFileExtension()

◆ GetLibraryFileExtension()

◆ GetModifyHash()

◆ GetName()

◆ init()

◆ isBuffering()

◆ IsSymbolLibWritable()

◆ Load()

◆ loadBitmap()

◆ loadBusAlias()

◆ loadBusEntry()

◆ loadComponent()

◆ LoadContent()

◆ loadFile()

◆ loadHeader()

◆ loadHierarchy()

◆ loadJunction()

◆ loadNoConnect()

◆ loadPageSettings()

◆ loadSheet()

◆ LoadSymbol()

◆ loadText()

◆ loadWire()

◆ ParsePart()

◆ Save()

◆ saveBitmap()

◆ saveBusAlias()

◆ saveBusEntry()

◆ saveComponent()

◆ saveField()

◆ saveJunction()

◆ SaveLibrary()

◆ saveLine()

◆ saveNoConnect()

◆ saveSheet()

◆ SaveSymbol()

◆ saveText()

◆ SetReporter()

◆ SymbolLibOptions()

◆ writeDocFile()

Member Data Documentation

◆ m_cache

◆ m_currentPath

◆ m_error

◆ m_out

◆ m_path

◆ m_rootSheet

◆ m_schematic

◆ m_version

◆ PropBuffering

◆ PropNoDocFile