SCH_LEGACY_PLUGIN Class Reference

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...
void	SetProgressReporter (PROGRESS_REPORTER *aReporter) override
	Set an optional progress reporter. 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 STRING_UTF8_MAP *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 STRING_UTF8_MAP *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 STRING_UTF8_MAP *aProperties=nullptr) override
	Populate a list of LIB_SYMBOL alias names contained within the library aLibraryPath. More...
void	EnumerateSymbolLib (std::vector< LIB_SYMBOL * > &aSymbolList, const wxString &aLibraryPath, const STRING_UTF8_MAP *aProperties=nullptr) override
	Populate a list of LIB_SYMBOL aliases contained within the library aLibraryPath. More...
LIB_SYMBOL *	LoadSymbol (const wxString &aLibraryPath, const wxString &aAliasName, const STRING_UTF8_MAP *aProperties=nullptr) override
	Load a LIB_SYMBOL object having aPartName from the aLibraryPath containing a library format that this SCH_PLUGIN knows about. More...
void	SaveSymbol (const wxString &aLibraryPath, const LIB_SYMBOL *aSymbol, const STRING_UTF8_MAP *aProperties=nullptr) override
	Write aSymbol to an existing library located at aLibraryPath. More...
void	DeleteSymbol (const wxString &aLibraryPath, const wxString &aSymbolName, const STRING_UTF8_MAP *aProperties=nullptr) override
	Delete the entire LIB_SYMBOL associated with aAliasName from the library aLibraryPath. More...
void	CreateSymbolLib (const wxString &aLibraryPath, const STRING_UTF8_MAP *aProperties=nullptr) override
	Create a new empty symbol library at aLibraryPath. More...
bool	DeleteSymbolLib (const wxString &aLibraryPath, const STRING_UTF8_MAP *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 STRING_UTF8_MAP *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 (STRING_UTF8_MAP *aListToAppendTo) const
	Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions. More...
virtual bool	SupportsSubLibraries () const
virtual void	GetSubLibraryNames (std::vector< wxString > &aNames)
	Retrieves a list of sub-libraries in this library. More...
virtual void	GetAvailableSymbolFields (std::vector< wxString > &aNames)
	Retrieves a list of (custom) field names that are present on symbols in this library. More...
virtual void	GetDefaultSymbolFields (std::vector< wxString > &aNames)
	Retrieves a list of (custom) field names that should be shown by default for this library in the symbol chooser. More...
virtual void	SetLibTable (SYMBOL_LIB_TABLE *aTable)
	Some library plugins need to have access to their parent library table. More...

Static Public Member Functions
static LIB_SYMBOL *	ParsePart (LINE_READER &aReader, int majorVersion=0, int minorVersion=0)
static void	FormatPart (LIB_SYMBOL *aSymbol, 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 STRING_UTF8_MAP *aProperties=nullptr)
	initialize PLUGIN like a constructor would. More...

Protected Attributes
int	m_version
	Version of file being loaded. More...
bool	m_appending
wxString	m_error
	For throwing exceptions or errors on partial schematic loads. More...
PROGRESS_REPORTER *	m_progressReporter
	optional; may be nullptr More...
LINE_READER *	m_lineReader
	for progress reporting More...
unsigned	m_lastProgressLine
unsigned	m_lineCount
	for progress reporting 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...
SCH_SHEET *	m_currentSheet
	The sheet currently being loaded. More...
OUTPUTFORMATTER *	m_out
	The formatter for saving SCH_SCREEN objects. More...
SCH_LEGACY_PLUGIN_CACHE *	m_cache
SCHEMATIC *	m_schematic

Private Member Functions
void	checkpoint ()
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_SYMBOL *	loadSymbol (LINE_READER &aReader)
std::shared_ptr< BUS_ALIAS >	loadBusAlias (LINE_READER &aReader, SCH_SCREEN *aScreen)
void	saveSymbol (SCH_SYMBOL *aSymbol)
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 STRING_UTF8_MAP *aProperties)
bool	writeDocFile (const STRING_UTF8_MAP *aProperties)
bool	isBuffering (const STRING_UTF8_MAP *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 74 of file sch_legacy_plugin.cpp.

 :
 m_appending( false ),
 m_progressReporter( nullptr ),
 m_lineReader( nullptr ),
 m_lastProgressLine( 0 ),
 m_lineCount( 0 )
{
 init( nullptr );
}

References init().

~SCH_LEGACY_PLUGIN()

SCH_LEGACY_PLUGIN::~SCH_LEGACY_PLUGIN ( )

virtual

Definition at line 85 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 STRING_UTF8_MAP *  aProperties  )

private

Definition at line 2038 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 );
 
 if( !isBuffering( aProperties ) )
 m_cache->Load();
 }
}

References isBuffering(), SCH_LIB_PLUGIN_CACHE::IsFile(), SCH_LIB_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 2230 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" );
}

checkpoint()

void SCH_LEGACY_PLUGIN::checkpoint ( )

private

Definition at line 102 of file sch_legacy_plugin.cpp.

{
 const unsigned PROGRESS_DELTA = 250;
 
 if( m_progressReporter )
 {
 unsigned curLine = m_lineReader->LineNumber();
 
 if( curLine > m_lastProgressLine + PROGRESS_DELTA )
 {
 m_progressReporter->SetCurrentProgress( ( (double) curLine )
 / std::max( 1U, m_lineCount ) );
 
 if( !m_progressReporter->KeepRefreshing() )
 THROW_IO_ERROR( ( "Open cancelled by user." ) );
 
 m_lastProgressLine = curLine;
 }
 }
}

References PROGRESS_REPORTER::KeepRefreshing(), LINE_READER::LineNumber(), m_lastProgressLine, m_lineCount, m_lineReader, m_progressReporter, PROGRESS_REPORTER::SetCurrentProgress(), and THROW_IO_ERROR.

Referenced by LoadContent(), and loadHeader().

CreateSymbolLib()

void SCH_LEGACY_PLUGIN::CreateSymbolLib ( const wxString &  aLibraryPath, const STRING_UTF8_MAP *  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 2166 of file sch_legacy_plugin.cpp.

{
 if( wxFileExists( aLibraryPath ) )
 {
 THROW_IO_ERROR( wxString::Format( _( "Symbol library '%s' already exists." ),
 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_LIB_PLUGIN_CACHE::SetModified(), THROW_IO_ERROR, and writeDocFile().

DeleteSymbol()

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

overridevirtual

Delete the entire LIB_SYMBOL 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_SYMBOL associated with it's root LIB_SYMBOL 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 2152 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 STRING_UTF8_MAP *  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 2185 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( _( "Symbol library '%s' cannot be deleted." ),
 aLibraryPath.GetData() ) );
 }
 
 if( m_cache && m_cache->IsFile( aLibraryPath ) )
 {
 delete m_cache;
 m_cache = nullptr;
 }
 
 return true;
}

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

EnumerateSymbolLib() [1/2]

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

overridevirtual

Populate a list of LIB_SYMBOL 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_SYMBOL pointers associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_SYMBOL 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 2100 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_SYMBOL_MAP& symbols = m_cache->m_symbols;
 
 for( LIB_SYMBOL_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_LIB_PLUGIN_CACHE::m_symbols, and SYMBOL_LIB_TABLE::PropPowerSymsOnly.

EnumerateSymbolLib() [2/2]

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

overridevirtual

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

Parameters

aSymbolNameList	is an array to populate with the LIB_SYMBOL names associated with the library.
aLibraryPath	is a locator for the "library", usually a directory, file, or URL containing one or more LIB_SYMBOL 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 2079 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_SYMBOL_MAP& symbols = m_cache->m_symbols;
 
 for( LIB_SYMBOL_MAP::const_iterator it = symbols.begin(); it != symbols.end(); ++it )
 {
 if( !powerSymbolsOnly || it->second->IsPower() )
 aSymbolNameList.Add( it->first );
 }
}

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

Format() [1/2]

void SCH_LEGACY_PLUGIN::Format

(

SCH_SHEET *

aSheet

)

Definition at line 1475 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aSheet != nullptr, "NULL SCH_SHEET* object." );
 wxCHECK_RET( m_schematic != nullptr, "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 std::shared_ptr<BUS_ALIAS>& 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( SCH_ITEM* item : screen->Items() )
 save_map.insert( item );
 
 
 for( auto& item : save_map )
 {
 switch( item->Type() )
 {
 case SCH_SYMBOL_T:
 saveSymbol( static_cast<SCH_SYMBOL*>( 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, OUTPUTFORMATTER::Print(), saveBitmap(), saveBusAlias(), saveBusEntry(), saveJunction(), saveLine(), saveNoConnect(), saveSheet(), saveSymbol(), saveText(), SCH_BITMAP_T, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_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_SYMBOL_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 1572 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_SYMBOL_T:
 saveSymbol( static_cast< SCH_SYMBOL* >( 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(), saveJunction(), saveLine(), saveNoConnect(), saveSheet(), saveSymbol(), saveText(), SCH_BITMAP_T, SCH_BUS_BUS_ENTRY_T, SCH_BUS_WIRE_ENTRY_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_SYMBOL_T, SCH_TEXT_T, and EDA_ITEM::Type().

FormatPart()

void SCH_LEGACY_PLUGIN::FormatPart ( LIB_SYMBOL *  aSymbol, OUTPUTFORMATTER &  aFormatter  )

static

Definition at line 2259 of file sch_legacy_plugin.cpp.

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

References SCH_LEGACY_PLUGIN_CACHE::SaveSymbol().

GetAvailableSymbolFields()

virtual void SCH_PLUGIN::GetAvailableSymbolFields ( std::vector< wxString > &  aNames )

inlinevirtualinherited

Retrieves a list of (custom) field names that are present on symbols in this library.

The plugin is responsible for guaranteeing that this list contains the set of unique custom field names present on any symbols contained in the library.

The required KiCad fields are not included in this list.

Parameters

aNames

will be filled with any custom fields present in this library.

Reimplemented in SCH_DATABASE_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 474 of file sch_io_mgr.h.

{}

Referenced by SYMBOL_LIB_TABLE_ROW::GetAvailableSymbolFields(), and SCH_PLUGIN::GetDefaultSymbolFields().

GetDefaultSymbolFields()

virtual void SCH_PLUGIN::GetDefaultSymbolFields ( std::vector< wxString > &  aNames )

inlinevirtualinherited

Retrieves a list of (custom) field names that should be shown by default for this library in the symbol chooser.

This list should be a subset of the result returned by GetAvailableSymbolFields().

The preference for which fields to hide and show for a given library is stored on a per-library basis in a user's preferences (or in the project local settings for a project- local library). The set of fields returned by GetDefaultSymbolFields() will be used if this preference is missing.

Parameters

aNames

will be filled with the custom field names that should be shown by default

Reimplemented in SCH_DATABASE_PLUGIN, and SCH_SEXPR_PLUGIN.

Definition at line 488 of file sch_io_mgr.h.

 {
 return GetAvailableSymbolFields( aNames );
 }

References SCH_PLUGIN::GetAvailableSymbolFields().

Referenced by SYMBOL_LIB_TABLE_ROW::GetDefaultSymbolFields().

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 141 of file sch_legacy_plugin.h.

{ return m_error; }

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 2069 of file sch_legacy_plugin.cpp.

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

References SCH_LIB_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" );
 }

GetSubLibraryNames()

virtual void SCH_PLUGIN::GetSubLibraryNames ( std::vector< wxString > &  aNames )

inlinevirtualinherited

Retrieves a list of sub-libraries in this library.

Some types of symbol library support sub-libraries, which are a single-level organizational hierarchy that is implementation-defined per plugin. Most of KiCad ignores sub-libraries and treats the hierarchy between library and symbol as flat, but the sub-libraries are used for sorting and grouping symbols in the symbol chooser.

Has no effect if SupportsSubLibraries() returns false.

Parameters

aNames

will be filled with a list of sub-libraries within this symbol library

Reimplemented in SCH_DATABASE_PLUGIN.

Definition at line 463 of file sch_io_mgr.h.

{}

Referenced by SYMBOL_LIB_TABLE_ROW::GetSubLibraryNames().

init()

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

protected

initialize PLUGIN like a constructor would.

Definition at line 91 of file sch_legacy_plugin.cpp.

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

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

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

isBuffering()

bool SCH_LEGACY_PLUGIN::isBuffering ( const STRING_UTF8_MAP *  aProperties )

private

Definition at line 2063 of file sch_legacy_plugin.cpp.

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

References STRING_UTF8_MAP::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 2245 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 STRING_UTF8_MAP *  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 symbol 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 124 of file sch_legacy_plugin.cpp.

{
 wxASSERT( !aFileName || aSchematic != nullptr );
 
 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 == nullptr )
 {
 // 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
 {
 m_appending = true;
 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_appending, m_currentPath, m_path, m_rootSheet, SCHEMATIC::Prj(), SCHEMATIC::Root(), and traceSchLegacyPlugin.

loadBitmap()

SCH_BITMAP * SCH_LEGACY_PLUGIN::loadBitmap ( LINE_READER &  aReader )

private

Definition at line 643 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 ), nullptr );
 
 line = aReader.ReadLine();
 
 while( line != nullptr )
 {
 if( strCompare( "Pos", line, &line ) )
 {
 VECTOR2I position;
 
 position.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 position.y = schIUScale.MilsToIU( 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
 // Note:
 // Some old files created bu the V4 schematic versions have a extra
 // "$EndBitmap" at the end of the hexadecimal data. (Probably due to
 // a bug). So discard it
 int len = strlen( line );
 
 for( ; len > 0 && !isspace( *line ) && '$' != *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 == nullptr )
 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(), EDA_IU_SCALE::MilsToIU(), parseDouble(), parseInt(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, schIUScale, strCompare(), THROW_IO_ERROR, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

loadBusAlias()

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

private

Definition at line 1424 of file sch_legacy_plugin.cpp.

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

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

Referenced by LoadContent().

loadBusEntry()

SCH_BUS_ENTRY_BASE * SCH_LEGACY_PLUGIN::loadBusEntry ( LINE_READER &  aReader )

private

Definition at line 884 of file sch_legacy_plugin.cpp.

{
 const char* line = aReader.Line();
 
 wxCHECK( strCompare( "Entry", line, &line ), nullptr );
 
 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();
 
 VECTOR2I pos;
 wxSize size;
 
 pos.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 pos.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 size.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 size.y = schIUScale.MilsToIU( 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(), EDA_IU_SCALE::MilsToIU(), parseInt(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, schIUScale, strCompare(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

LoadContent()

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

Definition at line 317 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() )
 {
 checkpoint();
 
 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( loadSymbol( 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(), checkpoint(), LINE_READER::Line(), loadBitmap(), loadBusAlias(), loadBusEntry(), loadJunction(), loadNoConnect(), loadPageSettings(), loadSheet(), loadSymbol(), 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 278 of file sch_legacy_plugin.cpp.

{
 FILE_LINE_READER reader( aFileName );
 
 if( m_progressReporter )
 {
 m_progressReporter->Report( wxString::Format( _( "Loading %s..." ), aFileName ) );
 
 if( !m_progressReporter->KeepRefreshing() )
 THROW_IO_ERROR( ( "Open cancelled by user." ) );
 
 m_lineReader = &reader;
 m_lineCount = 0;
 
 while( reader.ReadLine() )
 m_lineCount++;
 
 reader.Rewind();
 }
 
 loadHeader( reader, aScreen );
 
 LoadContent( reader, aScreen, m_version );
 
 // Unfortunately schematic files prior to version 2 are not terminated with $EndSCHEMATC
 // so checking for its 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 _, Format(), PROGRESS_REPORTER::KeepRefreshing(), LINE_READER::Line(), LoadContent(), loadHeader(), m_lineCount, m_lineReader, m_progressReporter, m_version, FILE_LINE_READER::ReadLine(), PROGRESS_REPORTER::Report(), FILE_LINE_READER::Rewind(), strCompare(), and THROW_IO_ERROR.

Referenced by loadHierarchy().

loadHeader()

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

private

Definition at line 364 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() )
 {
 checkpoint();
 
 line = aReader.Line();
 
 while( *line == ' ' )
 line++;
 
 if( strCompare( "EELAYER END", line ) )
 return;
 }
 
 THROW_IO_ERROR( _( "Missing 'EELAYER END'" ) );
}

References _, checkpoint(), 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 194 of file sch_legacy_plugin.cpp.

{
 SCH_SCREEN* screen = nullptr;
 
 m_currentSheet = aSheet;
 
 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 descending 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() );
 
 if( aSheet == m_rootSheet )
 const_cast<KIID&>( aSheet->m_Uuid ) = aSheet->GetScreen()->GetUuid();
 
 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();
 }
 
 aSheet->GetScreen()->SetFileReadOnly( !fileName.IsFileWritable() );
 aSheet->GetScreen()->SetFileExists( true );
 
 for( SCH_ITEM* 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::GetUuid(), SCH_SCREEN::Items(), loadFile(), loadHierarchy(), m_currentPath, m_currentSheet, m_error, m_rootSheet, m_schematic, EDA_ITEM::m_Uuid, EE_RTREE::OfType(), SCH_SHEET_T, SCH_SHEET::SearchHierarchy(), SCH_SCREEN::SetFileExists(), SCH_SCREEN::SetFileName(), SCH_SCREEN::SetFileReadOnly(), EDA_ITEM::SetParent(), SCH_SHEET::SetScreen(), traceSchLegacyPlugin, and IO_ERROR::What().

Referenced by Load(), and loadHierarchy().

loadJunction()

SCH_JUNCTION * SCH_LEGACY_PLUGIN::loadJunction ( LINE_READER &  aReader )

private

Definition at line 734 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 ), nullptr );
 
 wxString name;
 
 parseUnquotedString( name, aReader, line, &line );
 
 VECTOR2I position;
 
 position.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 position.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 junction->SetPosition( position );
 
 return junction.release();
}

References LINE_READER::Line(), EDA_IU_SCALE::MilsToIU(), name, parseInt(), parseUnquotedString(), schIUScale, strCompare(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

loadNoConnect()

SCH_NO_CONNECT * SCH_LEGACY_PLUGIN::loadNoConnect ( LINE_READER &  aReader )

private

Definition at line 756 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 ), nullptr );
 
 wxString name;
 
 parseUnquotedString( name, aReader, line, &line );
 
 VECTOR2I position;
 
 position.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 position.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 no_connect->SetPosition( position );
 
 return no_connect.release();
}

References LINE_READER::Line(), EDA_IU_SCALE::MilsToIU(), name, parseInt(), parseUnquotedString(), schIUScale, strCompare(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

loadPageSettings()

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

private

Definition at line 404 of file sch_legacy_plugin.cpp.

{
 wxASSERT( aScreen != nullptr );
 
 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 != nullptr )
 {
 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(), 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 533 of file sch_legacy_plugin.cpp.

{
 std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>();
 
 const char* line = aReader.ReadLine();
 
 while( line != nullptr )
 {
 if( strCompare( "S", line, &line ) ) // Sheet dimensions.
 {
 VECTOR2I position;
 
 position.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 position.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 sheet->SetPosition( position );
 
 wxSize size;
 
 size.SetWidth( schIUScale.MilsToIU( parseInt( aReader, line, &line ) ) );
 size.SetHeight( schIUScale.MilsToIU( 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 = schIUScale.MilsToIU( 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( ConvertToNewOverbarNotation( text ) );
 
 if( line == nullptr )
 THROW_IO_ERROR( _( "unexpected end of line" ) );
 
 switch( parseChar( aReader, line, &line ) )
 {
 case 'I': sheetPin->SetShape( LABEL_FLAG_SHAPE::L_INPUT ); break;
 case 'O': sheetPin->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT ); break;
 case 'B': sheetPin->SetShape( LABEL_FLAG_SHAPE::L_BIDI ); break;
 case 'T': sheetPin->SetShape( LABEL_FLAG_SHAPE::L_TRISTATE ); break;
 case 'U': sheetPin->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED ); break;
 default: SCH_PARSE_ERROR( "invalid sheet pin type", aReader, line );
 }
 
 switch( parseChar( aReader, line, &line ) )
 {
 case 'R': sheetPin->SetSide( SHEET_SIDE::RIGHT ); break;
 case 'T': sheetPin->SetSide( SHEET_SIDE::TOP ); break;
 case 'B': sheetPin->SetSide( SHEET_SIDE::BOTTOM ); break;
 case 'L': sheetPin->SetSide( SHEET_SIDE::LEFT ); break;
 default:
 SCH_PARSE_ERROR( "invalid sheet pin side", aReader, line );
 }
 
 VECTOR2I position;
 
 position.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 position.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 sheetPin->SetPosition( position );
 
 size = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 
 sheetPin->SetTextSize( wxSize( size, size ) );
 
 sheet->AddPin( sheetPin.release() );
 }
 }
 else if( strCompare( "$EndSheet", line ) )
 {
 sheet->AutoplaceFields( /* aScreen */ nullptr, /* aManual */ false );
 return sheet.release();
 }
 
 line = aReader.ReadLine();
 }
 
 SCH_PARSE_ERROR( "missing '$EndSheet`", aReader, line );
 
 return nullptr; // Prevents compiler warning. Should never get here.
}

References _, BOTTOM, ConvertToNewOverbarNotation(), L_BIDI, L_INPUT, L_OUTPUT, L_TRISTATE, L_UNSPECIFIED, LEFT, EDA_IU_SCALE::MilsToIU(), parseChar(), parseInt(), parseQuotedString(), parseUnquotedString(), LINE_READER::ReadLine(), RIGHT, SCH_PARSE_ERROR, schIUScale, EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), strCompare(), text, THROW_IO_ERROR, TOP, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

LoadSymbol()

LIB_SYMBOL * SCH_LEGACY_PLUGIN::LoadSymbol ( const wxString &  aLibraryPath, const wxString &  aPartName, const STRING_UTF8_MAP *  aProperties = nullptr  )

overridevirtual

Load a LIB_SYMBOL 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_SYMBOL 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 2121 of file sch_legacy_plugin.cpp.

{
 LOCALE_IO toggle; // toggles on, then off, the C locale.
 
 cacheLib( aLibraryPath, aProperties );
 
 LIB_SYMBOL_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_LIB_PLUGIN_CACHE::m_symbols.

loadSymbol()

SCH_SYMBOL * SCH_LEGACY_PLUGIN::loadSymbol ( LINE_READER &  aReader )

private

Definition at line 1076 of file sch_legacy_plugin.cpp.

{
 const char* line = aReader.Line();
 
 wxCHECK( strCompare( "$Comp", line, &line ), nullptr );
 
 std::unique_ptr<SCH_SYMBOL> symbol = std::make_unique<SCH_SYMBOL>();
 
 line = aReader.ReadLine();
 
 while( line != nullptr )
 {
 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 );
 
 symbol->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() )
 symbol->SetPrefix( wxString( "U" ) );
 else
 symbol->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()->SetContentModified();
 }
 
 symbol->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()->SetContentModified();
 }
 
 symbol->SetConvert( convert );
 
 wxString text;
 parseUnquotedString( text, aReader, line, &line );
 
 if( text != "00000000" )
 const_cast<KIID&>( symbol->m_Uuid ) = KIID( text );
 }
 else if( strCompare( "P", line, &line ) )
 {
 VECTOR2I pos;
 
 pos.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 pos.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 symbol->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 symbol. Drop the symbol ID
 // since it's already defined in the symbol itself.
 KIID_PATH path( pathStr );
 
 if( path.size() > 0 )
 path.pop_back();
 
 // In the new file format, the root schematic UUID is used as the virtual SCH_SHEET
 // UUID so we need to prefix it to the symbol path so the symbol instance paths
 // get saved with the root schematic UUID.
 if( !m_appending )
 path.insert( path.begin(), m_rootSheet->GetScreen()->GetUuid() );
 
 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 );
 
 symbol->AddHierarchicalReference( path, reference, (int)tmp );
 symbol->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 );
 VECTOR2I pos;
 pos.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 pos.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 int size = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 int attributes = parseHex( aReader, line, &line );
 
 if( index >= symbol->GetFieldCount() )
 {
 // The first MANDATOR_FIELDS _must_ be constructed within the SCH_SYMBOL
 // constructor. This assert is simply here to guard against a change in that
 // constructor.
 wxASSERT( symbol->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 = symbol->GetFieldCount(); // new has this index after insertion
 
 SCH_FIELD field( VECTOR2I( 0, 0 ), index, symbol.get(), name );
 symbol->AddField( field );
 }
 
 SCH_FIELD& field = symbol->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_H_ALIGN_LEFT );
 else if( hjustify == 'R' )
 field.SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 else if( hjustify != 'C' )
 SCH_PARSE_ERROR( "symbol 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_V_ALIGN_TOP );
 else if( textAttrs[0] == 'B' )
 field.SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 else if( textAttrs[0] != 'C' )
 SCH_PARSE_ERROR( "symbol 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( _( "symbol 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( "symbol 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( "symbol 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( ANGLE_HORIZONTAL );
 else if( orientation == 'V' )
 field.SetTextAngle( ANGLE_VERTICAL );
 else
 SCH_PARSE_ERROR( "symbol 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 ) )
 {
 if( !m_appending )
 {
 if( m_currentSheet == m_rootSheet )
 {
 KIID_PATH path;
 path.push_back( m_rootSheet->GetScreen()->GetUuid() );
 symbol->AddHierarchicalReference( path,
 symbol->GetField( REFERENCE_FIELD )->GetText(),
 symbol->GetUnit(),
 symbol->GetField( VALUE_FIELD )->GetText(),
 symbol->GetField( FOOTPRINT_FIELD )->GetText() );
 }
 else
 {
 for( const SYMBOL_INSTANCE_REFERENCE& instance : symbol->GetInstanceReferences() )
 {
 symbol->AddHierarchicalReference( instance.m_Path, instance.m_Reference,
 instance.m_Unit,
 symbol->GetField( VALUE_FIELD )->GetText(),
 symbol->GetField( FOOTPRINT_FIELD )->GetText() );
 }
 }
 }
 
 // Ensure all flags (some are set by previous initializations) are reset:
 symbol->ClearFlags();
 return symbol.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 symbol X1 transform value", aReader, line );
 
 transform.y1 = parseInt( aReader, line, &line );
 
 if( transform.y1 < -1 || transform.y1 > 1 )
 SCH_PARSE_ERROR( "invalid symbol Y1 transform value", aReader, line );
 
 transform.x2 = parseInt( aReader, line, &line );
 
 if( transform.x2 < -1 || transform.x2 > 1 )
 SCH_PARSE_ERROR( "invalid symbol X2 transform value", aReader, line );
 
 transform.y2 = parseInt( aReader, line, &line );
 
 if( transform.y2 < -1 || transform.y2 > 1 )
 SCH_PARSE_ERROR( "invalid symbol Y2 transform value", aReader, line );
 
 symbol->SetTransform( transform );
 }
 
 line = aReader.ReadLine();
 }
 
 SCH_PARSE_ERROR( "invalid symbol line", aReader, line );
 
 return nullptr; // Prevents compiler warning. Should never get here.
}

References _, ANGLE_HORIZONTAL, ANGLE_VERTICAL, convert, FOOTPRINT_FIELD, TEMPLATE_FIELDNAME::GetDefaultFieldName(), SCH_SHEET::GetScreen(), LINE_READER::GetSource(), SCH_SCREEN::GetUuid(), GR_TEXT_H_ALIGN_LEFT, GR_TEXT_H_ALIGN_RIGHT, GR_TEXT_V_ALIGN_BOTTOM, GR_TEXT_V_ALIGN_TOP, LINE_READER::Line(), LINE_READER::LineNumber(), m_appending, m_currentSheet, m_rootSheet, m_version, MANDATORY_FIELDS, MAX_UNIT_COUNT_PER_PACKAGE, EDA_IU_SCALE::MilsToIU(), name, LIB_ID::Parse(), parseChar(), parseHex(), parseInt(), parseQuotedString(), parseUnquotedString(), path, LINE_READER::ReadLine(), REFERENCE_FIELD, SCH_PARSE_ERROR, schIUScale, EDA_TEXT::SetBold(), BASE_SCREEN::SetContentModified(), EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetItalic(), LIB_ID::SetLibItemName(), SCH_FIELD::SetName(), EDA_TEXT::SetText(), EDA_TEXT::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetVertJustify(), EDA_TEXT::SetVisible(), strCompare(), text, THROW_PARSE_ERROR, VALUE_FIELD, VECTOR2< T >::x, TRANSFORM::x1, TRANSFORM::x2, VECTOR2< T >::y, TRANSFORM::y1, and TRANSFORM::y2.

Referenced by LoadContent().

loadText()

SCH_TEXT * SCH_LEGACY_PLUGIN::loadText ( LINE_READER &  aReader )

private

Definition at line 943 of file sch_legacy_plugin.cpp.

{
 const char* line = aReader.Line();
 KICAD_T textType = TYPE_NOT_INIT;
 
 wxCHECK( strCompare( "Text", line, &line ), nullptr );
 
 if( strCompare( "Notes", line, &line ) )
 {
 textType = SCH_TEXT_T;
 }
 else if( strCompare( "Label", line, &line ) )
 {
 textType = SCH_LABEL_T;
 }
 else if( strCompare( "HLabel", line, &line ) )
 {
 textType = SCH_HIER_LABEL_T;
 }
 else if( strCompare( "GLabel", line, &line ) )
 {
 // Prior to version 2, the SCH_GLOBALLABEL object did not exist.
 if( m_version == 1 )
 textType = SCH_HIER_LABEL_T;
 else
 textType = SCH_GLOBAL_LABEL_T;
 }
 else
 {
 SCH_PARSE_ERROR( "unknown Text type", aReader, line );
 }
 
 VECTOR2I position;
 
 position.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 position.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 
 std::unique_ptr<SCH_TEXT> text;
 
 switch( textType )
 {
 case SCH_TEXT_T: text.reset( new SCH_TEXT( position ) ); break;
 case SCH_LABEL_T: text.reset( new SCH_LABEL( position ) ); break;
 case SCH_HIER_LABEL_T: text.reset( new SCH_HIERLABEL( position ) ); break;
 case SCH_GLOBAL_LABEL_T: text.reset( new SCH_GLOBALLABEL( position ) ); break;
 default: break;
 }
 
 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->SetTextSpinStyle( static_cast<TEXT_SPIN_STYLE::SPIN>( spinStyle ) );
 
 int size = schIUScale.MilsToIU( 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( ConvertToNewOverbarNotation( val ) );
 
 return text.release();
}

References _, ConvertToNewOverbarNotation(), FROM_UTF8(), GetPenSizeForBold(), LINE_READER::Line(), m_version, EDA_IU_SCALE::MilsToIU(), parseInt(), LINE_READER::ReadLine(), SCH_GLOBAL_LABEL_T, SCH_HIER_LABEL_T, SCH_LABEL_T, SCH_PARSE_ERROR, SCH_TEXT_T, schIUScale, sheetLabelNames, strCompare(), text, TYPE_NOT_INIT, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

loadWire()

SCH_LINE * SCH_LEGACY_PLUGIN::loadWire ( LINE_READER &  aReader )

private

Definition at line 778 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 ), nullptr );
 
 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 = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 wire->SetLineWidth( size );
 }
 else if( buf == T_STYLE )
 {
 parseUnquotedString( buf, aReader, line, &line );
 
 if( buf == wxT( "solid" ) )
 wire->SetLineStyle( PLOT_DASH_TYPE::SOLID );
 else if( buf == wxT( "dashed" ) )
 wire->SetLineStyle( PLOT_DASH_TYPE::DASH );
 else if( buf == wxT( "dash_dot" ) )
 wire->SetLineStyle( PLOT_DASH_TYPE::DASHDOT );
 else if( buf == wxT( "dotted" ) )
 wire->SetLineStyle( PLOT_DASH_TYPE::DOT );
 }
 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();
 
 VECTOR2I begin, end;
 
 begin.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 begin.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 end.x = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 end.y = schIUScale.MilsToIU( parseInt( aReader, line, &line ) );
 
 wire->SetStartPoint( begin );
 wire->SetEndPoint( end );
 
 return wire.release();
}

References color, DASH, DASHDOT, DOT, is_eol(), LAYER_BUS, LAYER_NOTES, LAYER_WIRE, LINE_READER::Line(), EDA_IU_SCALE::MilsToIU(), parseInt(), parseUnquotedString(), LINE_READER::ReadLine(), SCH_PARSE_ERROR, schIUScale, SOLID, strCompare(), T_COLOR, T_COLORA, T_STYLE, T_WIDTH, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by LoadContent().

ParsePart()

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

static

Definition at line 2252 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 STRING_UTF8_MAP *  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 1449 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aSheet != nullptr, "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 );
 
 aSheet->GetScreen()->SetFileExists( true );
}

References Format(), SCH_SHEET::GetScreen(), init(), m_out, and SCH_SCREEN::SetFileExists().

saveBitmap()

void SCH_LEGACY_PLUGIN::saveBitmap ( SCH_BITMAP *  aBitmap )

private

Definition at line 1759 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aBitmap != nullptr, "SCH_BITMAP* is NULL" );
 
 const wxImage* image = aBitmap->GetImage()->GetImageData();
 
 wxCHECK_RET( image != nullptr, "wxImage* is NULL" );
 
 m_out->Print( 0, "$Bitmap\n" );
 m_out->Print( 0, "Pos %-4d %-4d\n",
 schIUScale.IUToMils( aBitmap->GetPosition().x ),
 schIUScale.IUToMils( 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, EDA_IU_SCALE::IUToMils(), m_out, OUTPUTFORMATTER::Print(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

saveBusAlias()

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

private

Definition at line 2027 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aAlias != nullptr, "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, OUTPUTFORMATTER::Print(), and TO_UTF8.

Referenced by Format().

saveBusEntry()

void SCH_LEGACY_PLUGIN::saveBusEntry ( SCH_BUS_ENTRY_BASE *  aBusEntry )

private

Definition at line 1887 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aBusEntry != nullptr, "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",
 schIUScale.IUToMils( aBusEntry->GetPosition().x ),
 schIUScale.IUToMils( aBusEntry->GetPosition().y ),
 schIUScale.IUToMils( aBusEntry->GetEnd().x ),
 schIUScale.IUToMils( aBusEntry->GetEnd().y ) );
 }
 else
 {
 m_out->Print( 0, "Entry Bus Bus\n\t%-4d %-4d %-4d %-4d\n",
 schIUScale.IUToMils( aBusEntry->GetPosition().x ),
 schIUScale.IUToMils( aBusEntry->GetPosition().y ),
 schIUScale.IUToMils( aBusEntry->GetEnd().x ),
 schIUScale.IUToMils( aBusEntry->GetEnd().y ) );
 }
}

References SCH_BUS_ENTRY_BASE::GetEnd(), SCH_ITEM::GetLayer(), SCH_BUS_ENTRY_BASE::GetPosition(), EDA_IU_SCALE::IUToMils(), LAYER_WIRE, m_out, OUTPUTFORMATTER::Print(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

saveField()

void SCH_LEGACY_PLUGIN::saveField ( SCH_FIELD *  aField )

private

Definition at line 1723 of file sch_legacy_plugin.cpp.

{
 char hjustify = 'C';
 
 if( aField->GetHorizJustify() == GR_TEXT_H_ALIGN_LEFT )
 hjustify = 'L';
 else if( aField->GetHorizJustify() == GR_TEXT_H_ALIGN_RIGHT )
 hjustify = 'R';
 
 char vjustify = 'C';
 
 if( aField->GetVertJustify() == GR_TEXT_V_ALIGN_BOTTOM )
 vjustify = 'B';
 else if( aField->GetVertJustify() == GR_TEXT_V_ALIGN_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().IsHorizontal() ? 'H' : 'V',
 schIUScale.IUToMils( aField->GetLibPosition().x ),
 schIUScale.IUToMils( aField->GetLibPosition().y ),
 schIUScale.IUToMils( 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_H_ALIGN_LEFT, GR_TEXT_H_ALIGN_RIGHT, GR_TEXT_V_ALIGN_BOTTOM, GR_TEXT_V_ALIGN_TOP, EDA_TEXT::IsBold(), EDA_ANGLE::IsHorizontal(), EDA_TEXT::IsItalic(), EDA_TEXT::IsVisible(), EDA_IU_SCALE::IUToMils(), m_out, MANDATORY_FIELDS, OUTPUTFORMATTER::Print(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by saveSymbol().

saveJunction()

void SCH_LEGACY_PLUGIN::saveJunction ( SCH_JUNCTION *  aJunction )

private

Definition at line 1867 of file sch_legacy_plugin.cpp.

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

References SCH_JUNCTION::GetPosition(), EDA_IU_SCALE::IUToMils(), m_out, OUTPUTFORMATTER::Print(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

SaveLibrary()

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

overridevirtual

Reimplemented from SCH_PLUGIN.

Definition at line 2211 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_LIB_PLUGIN_CACHE::GetFileName(), SCH_LIB_PLUGIN_CACHE::IsFile(), m_cache, SCH_LEGACY_PLUGIN_CACHE::Save(), SCH_LIB_PLUGIN_CACHE::SetFileName(), SCH_LIB_PLUGIN_CACHE::SetModified(), and writeDocFile().

saveLine()

void SCH_LEGACY_PLUGIN::saveLine ( SCH_LINE *  aLine )

private

Definition at line 1910 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aLine != nullptr, "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, schIUScale.IUToMils( aLine->GetLineSize() ) );
 
 m_out->Print( 0, " %s %s", T_STYLE,
 TO_UTF8( STROKE_PARAMS::GetLineStyleToken( aLine->GetLineStyle() ) ) );
 
 if( aLine->GetLineColor() != COLOR4D::UNSPECIFIED )
 {
 m_out->Print( 0, " %s",
 TO_UTF8( aLine->GetLineColor().ToCSSString() ) );
 }
 }
 
 m_out->Print( 0, "\n" );
 
 m_out->Print( 0, "\t%-4d %-4d %-4d %-4d",
 schIUScale.IUToMils( aLine->GetStartPoint().x ),
 schIUScale.IUToMils( aLine->GetStartPoint().y ),
 schIUScale.IUToMils( aLine->GetEndPoint().x ),
 schIUScale.IUToMils( aLine->GetEndPoint().y ) );
 
 m_out->Print( 0, "\n");
}

References SCH_LINE::GetEndPoint(), SCH_ITEM::GetLayer(), SCH_LINE::GetLineColor(), SCH_LINE::GetLineSize(), SCH_LINE::GetLineStyle(), STROKE_PARAMS::GetLineStyleToken(), SCH_LINE::GetStartPoint(), SCH_LINE::IsGraphicLine(), EDA_IU_SCALE::IUToMils(), LAYER_BUS, LAYER_WIRE, m_out, OUTPUTFORMATTER::Print(), schIUScale, T_STYLE, T_WIDTH, TO_UTF8, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

saveNoConnect()

void SCH_LEGACY_PLUGIN::saveNoConnect ( SCH_NO_CONNECT *  aNoConnect )

private

Definition at line 1877 of file sch_legacy_plugin.cpp.

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

References SCH_NO_CONNECT::GetPosition(), EDA_IU_SCALE::IUToMils(), m_out, OUTPUTFORMATTER::Print(), schIUScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

saveSheet()

void SCH_LEGACY_PLUGIN::saveSheet ( SCH_SHEET *  aSheet )

private

Definition at line 1799 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aSheet != nullptr, "SCH_SHEET* is NULL" );
 
 m_out->Print( 0, "$Sheet\n" );
 m_out->Print( 0, "S %-4d %-4d %-4d %-4d\n",
 schIUScale.IUToMils( aSheet->GetPosition().x ),
 schIUScale.IUToMils( aSheet->GetPosition().y ),
 schIUScale.IUToMils( aSheet->GetSize().x ),
 schIUScale.IUToMils( 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(),
 schIUScale.IUToMils( sheetName.GetTextSize().x ) );
 }
 
 if( !fileName.GetText().IsEmpty() )
 {
 m_out->Print( 0, "F1 %s %d\n",
 EscapedUTF8( fileName.GetText() ).c_str(),
 schIUScale.IUToMils( fileName.GetTextSize().x ) );
 }
 
 for( const SCH_SHEET_PIN* pin : aSheet->GetPins() )
 {
 int type, side;
 
 if( pin->GetText().IsEmpty() )
 break;
 
 switch( pin->GetSide() )
 {
 default:
 case SHEET_SIDE::LEFT: side = 'L'; break;
 case SHEET_SIDE::RIGHT: side = 'R'; break;
 case SHEET_SIDE::TOP: side = 'T'; break;
 case SHEET_SIDE::BOTTOM: side = 'B'; break;
 }
 
 switch( pin->GetShape() )
 {
 default:
 case LABEL_FLAG_SHAPE::L_UNSPECIFIED: type = 'U'; break;
 case LABEL_FLAG_SHAPE::L_INPUT: type = 'I'; break;
 case LABEL_FLAG_SHAPE::L_OUTPUT: type = 'O'; break;
 case LABEL_FLAG_SHAPE::L_BIDI: type = 'B'; break;
 case LABEL_FLAG_SHAPE::L_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, schIUScale.IUToMils( pin->GetPosition().x ),
 schIUScale.IUToMils( pin->GetPosition().y ),
 schIUScale.IUToMils( pin->GetTextWidth() ) );
 }
 
 m_out->Print( 0, "$EndSheet\n" );
}

References KIID::AsLegacyTimestamp(), BOTTOM, EscapedUTF8(), SCH_SHEET::GetFields(), SCH_SHEET::GetPins(), SCH_SHEET::GetPosition(), SCH_SHEET::GetSize(), EDA_TEXT::GetText(), EDA_TEXT::GetTextSize(), EDA_IU_SCALE::IUToMils(), L_BIDI, L_INPUT, L_OUTPUT, L_TRISTATE, L_UNSPECIFIED, LEFT, m_out, EDA_ITEM::m_Uuid, pin, OUTPUTFORMATTER::Print(), RIGHT, schIUScale, SHEETFILENAME, SHEETNAME, TOP, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

SaveSymbol()

void SCH_LEGACY_PLUGIN::SaveSymbol ( const wxString &  aLibraryPath, const LIB_SYMBOL *  aSymbol, const STRING_UTF8_MAP *  aProperties = nullptr  )

overridevirtual

Write aSymbol to an existing library located at aLibraryPath.

If a LIB_SYMBOL by the same name already exists or there are any conflicting alias names, the new LIB_SYMBOL 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_SYMBOL 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 2138 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_LIB_PLUGIN_CACHE::AddSymbol(), cacheLib(), isBuffering(), m_cache, SCH_LEGACY_PLUGIN_CACHE::Save(), and writeDocFile().

saveSymbol()

void SCH_LEGACY_PLUGIN::saveSymbol ( SCH_SYMBOL *  aSymbol )

private

Definition at line 1617 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( aSymbol->GetInstanceReferences().size() > 0 )
 {
 const SYMBOL_INSTANCE_REFERENCE& instance = aSymbol->GetInstanceReferences()[0];
 name1 = toUTFTildaText( instance.m_Reference );
 }
 else
 {
 if( aSymbol->GetField( REFERENCE_FIELD )->GetText().IsEmpty() )
 name1 = toUTFTildaText( aSymbol->GetPrefix() );
 else
 name1 = toUTFTildaText( aSymbol->GetField( REFERENCE_FIELD )->GetText() );
 }
 
 wxString symbol_name = aSymbol->GetLibId().Format();
 
 if( symbol_name.size() )
 {
 name2 = toUTFTildaText( symbol_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",
 aSymbol->GetUnit(),
 aSymbol->GetConvert(),
 aSymbol->m_Uuid.AsLegacyTimestamp() );
 
 // Save the position
 m_out->Print( 0, "P %d %d\n",
 schIUScale.IUToMils( aSymbol->GetPosition().x ),
 schIUScale.IUToMils( aSymbol->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( aSymbol->GetInstanceReferences().size() > 1 )
 {
 for( const SYMBOL_INSTANCE_REFERENCE& instance : aSymbol->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 symbol.
 * (timestamps are actually 8 hex chars)
 * Ref is the conventional symbol reference designator for this 'path'
 * Part is the conventional symbol unit 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 + aSymbol->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 < aSymbol->GetFieldCount(); ++i )
 aSymbol->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( &aSymbol->GetFields()[i] );
 
 // User defined fields:
 // The *policy* about which user defined fields are symbol 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 < aSymbol->GetFieldCount(); ++i )
 saveField( &aSymbol->GetFields()[i] );
 
 // Unit number, position, box ( old standard )
 m_out->Print( 0, "\t%-4d %-4d %-4d\n", aSymbol->GetUnit(),
 schIUScale.IUToMils( aSymbol->GetPosition().x ),
 schIUScale.IUToMils( aSymbol->GetPosition().y ) );
 
 TRANSFORM transform = aSymbol->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" );
}

References KIID::AsLegacyTimestamp(), KIID::AsLegacyTimestampString(), LIB_ID::Format(), SCH_SYMBOL::GetConvert(), SCH_SYMBOL::GetField(), SCH_SYMBOL::GetFieldCount(), SCH_SYMBOL::GetFields(), SCH_SYMBOL::GetInstanceReferences(), SCH_SYMBOL::GetLibId(), SCH_SYMBOL::GetPosition(), SCH_SYMBOL::GetPrefix(), EDA_TEXT::GetText(), SCH_SYMBOL::GetTransform(), SCH_SYMBOL::GetUnit(), EDA_IU_SCALE::IUToMils(), m_out, SYMBOL_INSTANCE_REFERENCE::m_Reference, EDA_ITEM::m_Uuid, MANDATORY_FIELDS, path, OUTPUTFORMATTER::Print(), REFERENCE_FIELD, saveField(), schIUScale, TO_UTF8, toUTFTildaText(), VECTOR2< T >::x, TRANSFORM::x1, TRANSFORM::x2, VECTOR2< T >::y, TRANSFORM::y1, and TRANSFORM::y2.

Referenced by Format().

saveText()

void SCH_LEGACY_PLUGIN::saveText ( SCH_TEXT *  aText )

private

Definition at line 1952 of file sch_legacy_plugin.cpp.

{
 wxCHECK_RET( aText != nullptr, "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->GetTextSpinStyle() );
 
 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,
 schIUScale.IUToMils( aText->GetPosition().x ),
 schIUScale.IUToMils( aText->GetPosition().y ),
 spinStyle,
 schIUScale.IUToMils( aText->GetTextWidth() ),
 italics, schIUScale.IUToMils( 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,
 schIUScale.IUToMils( aText->GetPosition().x ),
 schIUScale.IUToMils( aText->GetPosition().y ),
 static_cast<int>( aText->GetTextSpinStyle() ),
 schIUScale.IUToMils( aText->GetTextWidth() ),
 shapeLabelIt->second,
 italics,
 schIUScale.IUToMils( aText->GetTextThickness() ), TO_UTF8( text ) );
 }
}

References SCH_ITEM::GetLayer(), SCH_TEXT::GetPosition(), SCH_TEXT::GetShape(), EDA_TEXT::GetText(), SCH_TEXT::GetTextSpinStyle(), EDA_TEXT::GetTextThickness(), EDA_TEXT::GetTextWidth(), EDA_TEXT::IsItalic(), EDA_IU_SCALE::IUToMils(), LAYER_GLOBLABEL, LAYER_HIERLABEL, LAYER_LOCLABEL, LAYER_NOTES, m_out, OUTPUTFORMATTER::Print(), schIUScale, sheetLabelNames, text, TO_UTF8, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by Format().

SetLibTable()

virtual void SCH_PLUGIN::SetLibTable ( SYMBOL_LIB_TABLE *  aTable )

inlinevirtualinherited

Some library plugins need to have access to their parent library table.

Parameters

aTable

is the table this plugin is registered within.

Reimplemented in SCH_DATABASE_PLUGIN.

Definition at line 515 of file sch_io_mgr.h.

{}

Referenced by SYMBOL_LIB_TABLE::FindRow(), and SYMBOL_LIB_TABLE_ROW::Refresh().

SetProgressReporter()

void SCH_LEGACY_PLUGIN::SetProgressReporter ( PROGRESS_REPORTER *  aReporter )

inlineoverridevirtual

Set an optional progress reporter.

Reimplemented from SCH_PLUGIN.

Definition at line 85 of file sch_legacy_plugin.h.

 {
 m_progressReporter = aReporter;
 }

References m_progressReporter.

SetReporter()

virtual void SCH_PLUGIN::SetReporter ( REPORTER *  aReporter )

inlinevirtualinherited

Set an optional reporter for warnings/errors.

Reimplemented in SCH_ALTIUM_PLUGIN, CADSTAR_SCH_ARCHIVE_PLUGIN, and SCH_EAGLE_PLUGIN.

Definition at line 168 of file sch_io_mgr.h.

{}

Referenced by SCH_EDIT_FRAME::importFile().

SupportsSubLibraries()

virtual bool SCH_PLUGIN::SupportsSubLibraries ( ) const

inlinevirtualinherited

Returns

true if this plugin supports libraries that contain sub-libraries.

Reimplemented in SCH_DATABASE_PLUGIN.

Definition at line 449 of file sch_io_mgr.h.

{ return false; }

Referenced by SYMBOL_LIB_TABLE_ROW::SupportsSubLibraries().

SymbolLibOptions()

void SCH_PLUGIN::SymbolLibOptions ( STRING_UTF8_MAP *  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 STRING_UTF8_MAP *  aProperties )

private

Definition at line 2052 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_appending

bool SCH_LEGACY_PLUGIN::m_appending

protected

Definition at line 182 of file sch_legacy_plugin.h.

Referenced by Load(), and loadSymbol().

m_cache

SCH_LEGACY_PLUGIN_CACHE* SCH_LEGACY_PLUGIN::m_cache

protected

Definition at line 196 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 192 of file sch_legacy_plugin.h.

Referenced by Load(), and loadHierarchy().

m_currentSheet

SCH_SHEET* SCH_LEGACY_PLUGIN::m_currentSheet

protected

The sheet currently being loaded.

Definition at line 194 of file sch_legacy_plugin.h.

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

m_error

wxString SCH_LEGACY_PLUGIN::m_error

protected

For throwing exceptions or errors on partial schematic loads.

Definition at line 184 of file sch_legacy_plugin.h.

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

m_lastProgressLine

unsigned SCH_LEGACY_PLUGIN::m_lastProgressLine

protected

Definition at line 188 of file sch_legacy_plugin.h.

Referenced by checkpoint().

m_lineCount

unsigned SCH_LEGACY_PLUGIN::m_lineCount

protected

for progress reporting

Definition at line 189 of file sch_legacy_plugin.h.

Referenced by checkpoint(), and loadFile().

m_lineReader

LINE_READER* SCH_LEGACY_PLUGIN::m_lineReader

protected

for progress reporting

Definition at line 187 of file sch_legacy_plugin.h.

Referenced by checkpoint(), and loadFile().

m_out

OUTPUTFORMATTER* SCH_LEGACY_PLUGIN::m_out

protected

The formatter for saving SCH_SCREEN objects.

Definition at line 195 of file sch_legacy_plugin.h.

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

m_path

wxString SCH_LEGACY_PLUGIN::m_path

protected

Root project path for loading child sheets.

Definition at line 191 of file sch_legacy_plugin.h.

Referenced by Load().

m_progressReporter

PROGRESS_REPORTER* SCH_LEGACY_PLUGIN::m_progressReporter

protected

optional; may be nullptr

Definition at line 186 of file sch_legacy_plugin.h.

Referenced by checkpoint(), loadFile(), and SetProgressReporter().

m_rootSheet

SCH_SHEET* SCH_LEGACY_PLUGIN::m_rootSheet

protected

The root sheet of the schematic being loaded.

Definition at line 193 of file sch_legacy_plugin.h.

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

m_schematic

SCHEMATIC* SCH_LEGACY_PLUGIN::m_schematic

protected

Definition at line 197 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.

Indicate if we are appending the loaded schemitic or loading a full project.

Definition at line 179 of file sch_legacy_plugin.h.

Referenced by init(), LoadContent(), loadFile(), loadHeader(), loadSymbol(), 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 95 of file sch_legacy_plugin.h.

Referenced by SYMBOL_LIB::EnableBuffering(), SYMBOL_LIB::IsBuffering(), 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 101 of file sch_legacy_plugin.h.

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

---

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

• sch_legacy_plugin.h
• sch_legacy_plugin.cpp