KiCad PCB EDA Suite
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:
SCH_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_SHEETLoad (const wxString &aFileName, SCHEMATIC *aSchematic, SCH_SHEET *aAppendToMe=nullptr, const PROPERTIES *aProperties=nullptr) override
 Load information from some input file format that this SCH_PLUGIN implementation knows about, into either a new SCH_SHEET or an existing one. More...
 
void LoadContent (LINE_READER &aReader, SCH_SCREEN *aScreen, int version=EESCHEMA_VERSION)
 
void Save (const wxString &aFileName, SCH_SHEET *aScreen, SCHEMATIC *aSchematic, const PROPERTIES *aProperties=nullptr) override
 Write aSchematic to a storage file in a format that this SCH_PLUGIN implementation knows about, or it can be used to write a portion of aSchematic to a special kind of export file. More...
 
void Format (SCH_SHEET *aSheet)
 
void Format (SELECTION *aSelection, OUTPUTFORMATTER *aFormatter)
 
void EnumerateSymbolLib (wxArrayString &aSymbolNameList, const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
 Populate a list of LIB_SYMBOL alias names contained within the library aLibraryPath. More...
 
void EnumerateSymbolLib (std::vector< LIB_SYMBOL * > &aSymbolList, const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
 Populate a list of LIB_SYMBOL aliases contained within the library aLibraryPath. More...
 
LIB_SYMBOLLoadSymbol (const wxString &aLibraryPath, const wxString &aAliasName, const PROPERTIES *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 PROPERTIES *aProperties=nullptr) override
 Write aSymbol to an existing library located at aLibraryPath. More...
 
void DeleteSymbol (const wxString &aLibraryPath, const wxString &aSymbolName, const PROPERTIES *aProperties=nullptr) override
 Delete the entire LIB_SYMBOL associated with aAliasName from the library aLibraryPath. More...
 
void CreateSymbolLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
 Create a new empty symbol library at aLibraryPath. More...
 
bool DeleteSymbolLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
 Delete an existing symbol library and returns true if successful, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason. More...
 
void SaveLibrary (const wxString &aLibraryPath, const PROPERTIES *aProperties=nullptr) override
 
bool CheckHeader (const wxString &aFileName) override
 Return true if the first line in aFileName begins with the expected header. More...
 
bool IsSymbolLibWritable (const wxString &aLibraryPath) override
 Return true if the library at aLibraryPath is writable. More...
 
const wxString & GetError () const override
 Return an error string to the caller. More...
 
virtual void SetReporter (REPORTER *aReporter)
 Set an optional reporter for warnings/errors. More...
 
virtual void SymbolLibOptions (PROPERTIES *aListToAppendTo) const
 Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions. More...
 

Static Public Member Functions

static LIB_SYMBOLParsePart (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 PROPERTIES *aProperties=nullptr)
 initialize PLUGIN like a constructor would. More...
 

Protected Attributes

int m_version
 Version of file being loaded. More...
 
wxString m_error
 For throwing exceptions or errors on partial schematic loads. More...
 
PROGRESS_REPORTERm_progressReporter
 optional; may be nullptr More...
 
LINE_READERm_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_SHEETm_rootSheet
 The root sheet of the schematic being loaded. More...
 
OUTPUTFORMATTERm_out
 The formatter for saving SCH_SCREEN objects. More...
 
SCH_LEGACY_PLUGIN_CACHEm_cache
 
SCHEMATICm_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_SHEETloadSheet (LINE_READER &aReader)
 
SCH_BITMAPloadBitmap (LINE_READER &aReader)
 
SCH_JUNCTIONloadJunction (LINE_READER &aReader)
 
SCH_NO_CONNECTloadNoConnect (LINE_READER &aReader)
 
SCH_LINEloadWire (LINE_READER &aReader)
 
SCH_BUS_ENTRY_BASEloadBusEntry (LINE_READER &aReader)
 
SCH_TEXTloadText (LINE_READER &aReader)
 
SCH_SYMBOLloadSymbol (LINE_READER &aReader)
 
std::shared_ptr< BUS_ALIASloadBusAlias (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 PROPERTIES *aProperties)
 
bool writeDocFile (const PROPERTIES *aProperties)
 
bool isBuffering (const PROPERTIES *aProperties)
 

Detailed Description

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

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

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

Definition at line 63 of file sch_legacy_plugin.h.

Constructor & Destructor Documentation

◆ SCH_LEGACY_PLUGIN()

SCH_LEGACY_PLUGIN::SCH_LEGACY_PLUGIN ( )

Definition at line 569 of file sch_legacy_plugin.cpp.

569  :
570  m_progressReporter( nullptr ),
571  m_lineReader( nullptr ),
572  m_lastProgressLine( 0 ),
573  m_lineCount( 0 )
574 {
575  init( nullptr );
576 }
void init(SCHEMATIC *aSchematic, const PROPERTIES *aProperties=nullptr)
initialize PLUGIN like a constructor would.
LINE_READER * m_lineReader
for progress reporting
PROGRESS_REPORTER * m_progressReporter
optional; may be nullptr
unsigned m_lineCount
for progress reporting

References init().

◆ ~SCH_LEGACY_PLUGIN()

SCH_LEGACY_PLUGIN::~SCH_LEGACY_PLUGIN ( )
virtual

Definition at line 579 of file sch_legacy_plugin.cpp.

580 {
581  delete m_cache;
582 }
SCH_LEGACY_PLUGIN_CACHE * m_cache

References m_cache.

Member Function Documentation

◆ cacheLib()

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

Definition at line 4323 of file sch_legacy_plugin.cpp.

4324 {
4325  if( !m_cache || !m_cache->IsFile( aLibraryFileName ) || m_cache->IsFileChanged() )
4326  {
4327  // a spectacular episode in memory management:
4328  delete m_cache;
4329  m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryFileName );
4330 
4331  // Because m_cache is rebuilt, increment SYMBOL_LIBS::s_modify_generation
4332  // to modify the hash value that indicate symbol to symbol links
4333  // must be updated.
4335 
4336  if( !isBuffering( aProperties ) )
4337  m_cache->Load();
4338  }
4339 }
SCH_LEGACY_PLUGIN_CACHE * m_cache
A cache assistant for the symbol library portion of the SCH_PLUGIN API, and only for the SCH_LEGACY_P...
bool isBuffering(const PROPERTIES *aProperties)
static void IncrementModifyGeneration()
bool IsFile(const wxString &aFullPathAndFileName) const

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

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

◆ CheckHeader()

bool SCH_LEGACY_PLUGIN::CheckHeader ( const wxString &  aFileName)
overridevirtual

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

Parameters
aFileNameis the name of the file to use as input

Reimplemented from SCH_PLUGIN.

Definition at line 4520 of file sch_legacy_plugin.cpp.

4521 {
4522  // Open file and check first line
4523  wxTextFile tempFile;
4524 
4525  tempFile.Open( aFileName );
4526  wxString firstline;
4527  // read the first line
4528  firstline = tempFile.GetFirstLine();
4529  tempFile.Close();
4530 
4531  return firstline.StartsWith( "EESchema" );
4532 }

◆ checkpoint()

void SCH_LEGACY_PLUGIN::checkpoint ( )
private

Definition at line 595 of file sch_legacy_plugin.cpp.

596 {
597  const unsigned PROGRESS_DELTA = 250;
598 
599  if( m_progressReporter )
600  {
601  unsigned curLine = m_lineReader->LineNumber();
602 
603  if( curLine > m_lastProgressLine + PROGRESS_DELTA )
604  {
605  m_progressReporter->SetCurrentProgress( ( (double) curLine )
606  / std::max( 1U, m_lineCount ) );
607 
609  THROW_IO_ERROR( ( "Open cancelled by user." ) );
610 
611  m_lastProgressLine = curLine;
612  }
613  }
614 }
virtual unsigned LineNumber() const
Return the line number of the last line read from this LINE_READER.
Definition: richio.h:135
LINE_READER * m_lineReader
for progress reporting
PROGRESS_REPORTER * m_progressReporter
optional; may be nullptr
unsigned m_lineCount
for progress reporting
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
virtual void SetCurrentProgress(double aProgress)=0
Set the progress value to aProgress (0..1).

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 PROPERTIES aProperties = nullptr 
)
overridevirtual

Create a new empty symbol library at aLibraryPath.

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

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aPropertiesis 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_ERRORif there is a problem finding the library, or creating it.

Reimplemented from SCH_PLUGIN.

Definition at line 4456 of file sch_legacy_plugin.cpp.

4458 {
4459  if( wxFileExists( aLibraryPath ) )
4460  {
4461  THROW_IO_ERROR( wxString::Format( _( "Symbol library '%s' already exists." ),
4462  aLibraryPath.GetData() ) );
4463  }
4464 
4465  LOCALE_IO toggle;
4466 
4467  delete m_cache;
4468  m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryPath );
4469  m_cache->SetModified();
4470  m_cache->Save( writeDocFile( aProperties ) );
4471  m_cache->Load(); // update m_writable and m_mod_time
4472 }
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
SCH_LEGACY_PLUGIN_CACHE * m_cache
A cache assistant for the symbol library portion of the SCH_PLUGIN API, and only for the SCH_LEGACY_P...
#define _(s)
void SetModified(bool aModified=true)
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
void Save(bool aSaveDocFile=true)
Save the entire library to file m_libFileName;.
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
bool writeDocFile(const PROPERTIES *aProperties)

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

◆ DeleteSymbol()

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

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

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several symbols.
aSymbolNameis the name of a LIB_SYMBOL associated with it's root LIB_SYMBOL object to delete from the specified library.
aPropertiesis 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_ERRORif there is a problem finding the alias or the library or deleting it.

Reimplemented from SCH_PLUGIN.

Definition at line 4442 of file sch_legacy_plugin.cpp.

4444 {
4445  LOCALE_IO toggle; // toggles on, then off, the C locale.
4446 
4447  cacheLib( aLibraryPath, aProperties );
4448 
4449  m_cache->DeleteSymbol( aSymbolName );
4450 
4451  if( !isBuffering( aProperties ) )
4452  m_cache->Save( writeDocFile( aProperties ) );
4453 }
void DeleteSymbol(const wxString &aName)
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
SCH_LEGACY_PLUGIN_CACHE * m_cache
bool isBuffering(const PROPERTIES *aProperties)
void cacheLib(const wxString &aLibraryFileName, const PROPERTIES *aProperties)
void Save(bool aSaveDocFile=true)
Save the entire library to file m_libFileName;.
bool writeDocFile(const PROPERTIES *aProperties)

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

◆ DeleteSymbolLib()

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

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

Parameters
aLibraryPathis a locator for the "library", usually a directory or file which will contain symbols.
aPropertiesis 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_ERRORif there is a problem deleting an existing library.

Reimplemented from SCH_PLUGIN.

Definition at line 4475 of file sch_legacy_plugin.cpp.

4477 {
4478  wxFileName fn = aLibraryPath;
4479 
4480  if( !fn.FileExists() )
4481  return false;
4482 
4483  // Some of the more elaborate wxRemoveFile() crap puts up its own wxLog dialog
4484  // we don't want that. we want bare metal portability with no UI here.
4485  if( wxRemove( aLibraryPath ) )
4486  {
4487  THROW_IO_ERROR( wxString::Format( _( "Symbol library '%s' cannot be deleted." ),
4488  aLibraryPath.GetData() ) );
4489  }
4490 
4491  if( m_cache && m_cache->IsFile( aLibraryPath ) )
4492  {
4493  delete m_cache;
4494  m_cache = nullptr;
4495  }
4496 
4497  return true;
4498 }
SCH_LEGACY_PLUGIN_CACHE * m_cache
#define _(s)
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
bool IsFile(const wxString &aFullPathAndFileName) const
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38

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

◆ EnumerateSymbolLib() [1/2]

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

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

Parameters
aSymbolNameListis an array to populate with the LIB_SYMBOL names associated with the library.
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing one or more LIB_SYMBOL objects.
aPropertiesis 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_ERRORif the library cannot be found, the part library cannot be loaded.

Reimplemented from SCH_PLUGIN.

Definition at line 4369 of file sch_legacy_plugin.cpp.

4372 {
4373  LOCALE_IO toggle; // toggles on, then off, the C locale.
4374 
4375  bool powerSymbolsOnly = ( aProperties &&
4376  aProperties->find( SYMBOL_LIB_TABLE::PropPowerSymsOnly ) != aProperties->end() );
4377 
4378  cacheLib( aLibraryPath, aProperties );
4379 
4380  const LIB_SYMBOL_MAP& symbols = m_cache->m_symbols;
4381 
4382  for( LIB_SYMBOL_MAP::const_iterator it = symbols.begin(); it != symbols.end(); ++it )
4383  {
4384  if( !powerSymbolsOnly || it->second->IsPower() )
4385  aSymbolNameList.Add( it->first );
4386  }
4387 }
std::map< wxString, LIB_SYMBOL *, LibSymbolMapSort > LIB_SYMBOL_MAP
Symbol map used by symbol library object.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
SCH_LEGACY_PLUGIN_CACHE * m_cache
void cacheLib(const wxString &aLibraryFileName, const PROPERTIES *aProperties)
static const char * PropPowerSymsOnly

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

◆ EnumerateSymbolLib() [2/2]

void SCH_LEGACY_PLUGIN::EnumerateSymbolLib ( std::vector< LIB_SYMBOL * > &  aSymbolList,
const wxString &  aLibraryPath,
const PROPERTIES 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
aSymbolListis an array to populate with the LIB_SYMBOL pointers associated with the library.
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing one or more LIB_SYMBOL objects.
aPropertiesis 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_ERRORif the library cannot be found, the part library cannot be loaded.

Reimplemented from SCH_PLUGIN.

Definition at line 4390 of file sch_legacy_plugin.cpp.

4393 {
4394  LOCALE_IO toggle; // toggles on, then off, the C locale.
4395 
4396  bool powerSymbolsOnly = ( aProperties &&
4397  aProperties->find( SYMBOL_LIB_TABLE::PropPowerSymsOnly ) != aProperties->end() );
4398 
4399  cacheLib( aLibraryPath, aProperties );
4400 
4401  const LIB_SYMBOL_MAP& symbols = m_cache->m_symbols;
4402 
4403  for( LIB_SYMBOL_MAP::const_iterator it = symbols.begin(); it != symbols.end(); ++it )
4404  {
4405  if( !powerSymbolsOnly || it->second->IsPower() )
4406  aSymbolList.push_back( it->second );
4407  }
4408 }
std::map< wxString, LIB_SYMBOL *, LibSymbolMapSort > LIB_SYMBOL_MAP
Symbol map used by symbol library object.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
SCH_LEGACY_PLUGIN_CACHE * m_cache
void cacheLib(const wxString &aLibraryFileName, const PROPERTIES *aProperties)
static const char * PropPowerSymsOnly

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

◆ Format() [1/2]

void SCH_LEGACY_PLUGIN::Format ( SCH_SHEET aSheet)

Definition at line 1903 of file sch_legacy_plugin.cpp.

1904 {
1905  wxCHECK_RET( aSheet != nullptr, "NULL SCH_SHEET* object." );
1906  wxCHECK_RET( m_schematic != nullptr, "NULL SCHEMATIC* object." );
1907 
1908  SCH_SCREEN* screen = aSheet->GetScreen();
1909 
1910  wxCHECK( screen, /* void */ );
1911 
1912  // Write the header
1913  m_out->Print( 0, "%s %s %d\n", "EESchema", SCHEMATIC_HEAD_STRING, EESCHEMA_VERSION );
1914 
1915  // This section is not used, but written for file compatibility
1916  m_out->Print( 0, "EELAYER %d %d\n", SCH_LAYER_ID_COUNT, 0 );
1917  m_out->Print( 0, "EELAYER END\n" );
1918 
1919  /* Write page info, ScreenNumber and NumberOfScreen; not very meaningful for
1920  * SheetNumber and Sheet Count in a complex hierarchy, but useful in
1921  * simple hierarchy and flat hierarchy. Used also to search the root
1922  * sheet ( ScreenNumber = 1 ) within the files
1923  */
1924  const TITLE_BLOCK& tb = screen->GetTitleBlock();
1925  const PAGE_INFO& page = screen->GetPageSettings();
1926 
1927  m_out->Print( 0, "$Descr %s %d %d%s\n", TO_UTF8( page.GetType() ),
1928  page.GetWidthMils(),
1929  page.GetHeightMils(),
1930  !page.IsCustom() && page.IsPortrait() ? " portrait" : "" );
1931  m_out->Print( 0, "encoding utf-8\n" );
1932  m_out->Print( 0, "Sheet %d %d\n", screen->GetVirtualPageNumber(), screen->GetPageCount() );
1933  m_out->Print( 0, "Title %s\n", EscapedUTF8( tb.GetTitle() ).c_str() );
1934  m_out->Print( 0, "Date %s\n", EscapedUTF8( tb.GetDate() ).c_str() );
1935  m_out->Print( 0, "Rev %s\n", EscapedUTF8( tb.GetRevision() ).c_str() );
1936  m_out->Print( 0, "Comp %s\n", EscapedUTF8( tb.GetCompany() ).c_str() );
1937  m_out->Print( 0, "Comment1 %s\n", EscapedUTF8( tb.GetComment( 0 ) ).c_str() );
1938  m_out->Print( 0, "Comment2 %s\n", EscapedUTF8( tb.GetComment( 1 ) ).c_str() );
1939  m_out->Print( 0, "Comment3 %s\n", EscapedUTF8( tb.GetComment( 2 ) ).c_str() );
1940  m_out->Print( 0, "Comment4 %s\n", EscapedUTF8( tb.GetComment( 3 ) ).c_str() );
1941  m_out->Print( 0, "Comment5 %s\n", EscapedUTF8( tb.GetComment( 4 ) ).c_str() );
1942  m_out->Print( 0, "Comment6 %s\n", EscapedUTF8( tb.GetComment( 5 ) ).c_str() );
1943  m_out->Print( 0, "Comment7 %s\n", EscapedUTF8( tb.GetComment( 6 ) ).c_str() );
1944  m_out->Print( 0, "Comment8 %s\n", EscapedUTF8( tb.GetComment( 7 ) ).c_str() );
1945  m_out->Print( 0, "Comment9 %s\n", EscapedUTF8( tb.GetComment( 8 ) ).c_str() );
1946  m_out->Print( 0, "$EndDescr\n" );
1947 
1948  for( const auto& alias : screen->GetBusAliases() )
1949  {
1950  saveBusAlias( alias );
1951  }
1952 
1953  // Enforce item ordering
1954  auto cmp = []( const SCH_ITEM* a, const SCH_ITEM* b ) { return *a < *b; };
1955  std::multiset<SCH_ITEM*, decltype( cmp )> save_map( cmp );
1956 
1957  for( auto item : screen->Items() )
1958  save_map.insert( item );
1959 
1960 
1961  for( auto& item : save_map )
1962  {
1963  switch( item->Type() )
1964  {
1965  case SCH_SYMBOL_T:
1966  saveSymbol( static_cast<SCH_SYMBOL*>( item ) );
1967  break;
1968  case SCH_BITMAP_T:
1969  saveBitmap( static_cast<SCH_BITMAP*>( item ) );
1970  break;
1971  case SCH_SHEET_T:
1972  saveSheet( static_cast<SCH_SHEET*>( item ) );
1973  break;
1974  case SCH_JUNCTION_T:
1975  saveJunction( static_cast<SCH_JUNCTION*>( item ) );
1976  break;
1977  case SCH_NO_CONNECT_T:
1978  saveNoConnect( static_cast<SCH_NO_CONNECT*>( item ) );
1979  break;
1980  case SCH_BUS_WIRE_ENTRY_T:
1981  case SCH_BUS_BUS_ENTRY_T:
1982  saveBusEntry( static_cast<SCH_BUS_ENTRY_BASE*>( item ) );
1983  break;
1984  case SCH_LINE_T:
1985  saveLine( static_cast<SCH_LINE*>( item ) );
1986  break;
1987  case SCH_TEXT_T:
1988  case SCH_LABEL_T:
1989  case SCH_GLOBAL_LABEL_T:
1990  case SCH_HIER_LABEL_T:
1991  saveText( static_cast<SCH_TEXT*>( item ) );
1992  break;
1993  default:
1994  wxASSERT( "Unexpected schematic object type in SCH_LEGACY_PLUGIN::Format()" );
1995  }
1996  }
1997 
1998  m_out->Print( 0, "$EndSCHEMATC\n" );
1999 }
void saveLine(SCH_LINE *aLine)
const wxString & GetComment(int aIdx) const
Definition: title_block.h:107
int GetHeightMils() const
Definition: page_info.h:133
int GetVirtualPageNumber() const
Definition: base_screen.h:75
int GetPageCount() const
Definition: base_screen.h:72
void saveText(SCH_TEXT *aText)
const TITLE_BLOCK & GetTitleBlock() const
Definition: sch_screen.h:156
const wxString & GetType() const
Definition: page_info.h:94
void saveNoConnect(SCH_NO_CONNECT *aNoConnect)
bool IsCustom() const
Definition: page_info.cpp:180
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:102
Hold the information shown in the lower right corner of a plot, printout, or editing view.
Definition: title_block.h:40
const PAGE_INFO & GetPageSettings() const
Definition: sch_screen.h:132
#define SCH_LAYER_ID_COUNT
Definition: layer_ids.h:379
void saveSheet(SCH_SHEET *aSheet)
void saveJunction(SCH_JUNCTION *aJunction)
#define SCHEMATIC_HEAD_STRING
Definition: general.h:36
void saveSymbol(SCH_SYMBOL *aSymbol)
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
#define EESCHEMA_VERSION
Definition: general.h:35
const wxString & GetRevision() const
Definition: title_block.h:86
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:53
const wxString & GetCompany() const
Definition: title_block.h:96
void saveBitmap(SCH_BITMAP *aBitmap)
const wxString & GetDate() const
Definition: title_block.h:76
std::unordered_set< std::shared_ptr< BUS_ALIAS > > GetBusAliases() const
Return a list of bus aliases defined in this screen.
Definition: sch_screen.h:481
void saveBusAlias(std::shared_ptr< BUS_ALIAS > aAlias)
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
bool IsPortrait() const
Definition: page_info.h:117
EE_RTREE & Items()
Gets the full RTree, usually for iterating.
Definition: sch_screen.h:110
const wxString & GetTitle() const
Definition: title_block.h:63
std::string EscapedUTF8(const wxString &aString)
Return an 8 bit UTF8 string given aString in Unicode form.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:182
void saveBusEntry(SCH_BUS_ENTRY_BASE *aBusEntry)
int GetWidthMils() const
Definition: page_info.h:130

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

2003 {
2004  m_out = aFormatter;
2005 
2006  for( unsigned i = 0; i < aSelection->GetSize(); ++i )
2007  {
2008  SCH_ITEM* item = (SCH_ITEM*) aSelection->GetItem( i );
2009 
2010  switch( item->Type() )
2011  {
2012  case SCH_SYMBOL_T:
2013  saveSymbol( static_cast< SCH_SYMBOL* >( item ) );
2014  break;
2015  case SCH_BITMAP_T:
2016  saveBitmap( static_cast< SCH_BITMAP* >( item ) );
2017  break;
2018  case SCH_SHEET_T:
2019  saveSheet( static_cast< SCH_SHEET* >( item ) );
2020  break;
2021  case SCH_JUNCTION_T:
2022  saveJunction( static_cast< SCH_JUNCTION* >( item ) );
2023  break;
2024  case SCH_NO_CONNECT_T:
2025  saveNoConnect( static_cast< SCH_NO_CONNECT* >( item ) );
2026  break;
2027  case SCH_BUS_WIRE_ENTRY_T:
2028  case SCH_BUS_BUS_ENTRY_T:
2029  saveBusEntry( static_cast< SCH_BUS_ENTRY_BASE* >( item ) );
2030  break;
2031  case SCH_LINE_T:
2032  saveLine( static_cast< SCH_LINE* >( item ) );
2033  break;
2034  case SCH_TEXT_T:
2035  case SCH_LABEL_T:
2036  case SCH_GLOBAL_LABEL_T:
2037  case SCH_HIER_LABEL_T:
2038  saveText( static_cast< SCH_TEXT* >( item ) );
2039  break;
2040  default:
2041  wxASSERT( "Unexpected schematic object type in SCH_LEGACY_PLUGIN::Format()" );
2042  }
2043  }
2044 }
void saveLine(SCH_LINE *aLine)
void saveText(SCH_TEXT *aText)
void saveNoConnect(SCH_NO_CONNECT *aNoConnect)
void saveSheet(SCH_SHEET *aSheet)
void saveJunction(SCH_JUNCTION *aJunction)
void saveSymbol(SCH_SYMBOL *aSymbol)
void saveBitmap(SCH_BITMAP *aBitmap)
virtual unsigned int GetSize() const override
Return the number of stored items.
Definition: selection.h:88
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
virtual KIGFX::VIEW_ITEM * GetItem(unsigned int aIdx) const override
Definition: selection.cpp:53
Base class for any item which can be embedded within the SCHEMATIC container class,...
Definition: sch_item.h:182
void saveBusEntry(SCH_BUS_ENTRY_BASE *aBusEntry)
KICAD_T Type() const
Returns the type of object.
Definition: eda_item.h:112

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

4550 {
4551  SCH_LEGACY_PLUGIN_CACHE::SaveSymbol( symbol, formatter );
4552 }
static void SaveSymbol(LIB_SYMBOL *aSymbol, OUTPUTFORMATTER &aFormatter, LIB_SYMBOL_MAP *aMap=nullptr)

References SCH_LEGACY_PLUGIN_CACHE::SaveSymbol().

◆ GetError()

const wxString& SCH_LEGACY_PLUGIN::GetError ( ) const
inlineoverridevirtual

Return an error string to the caller.

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

Returns
an unformatted string containing errors if any.

Reimplemented from SCH_PLUGIN.

Definition at line 141 of file sch_legacy_plugin.h.

141 { return m_error; }
wxString m_error
For throwing exceptions or errors on partial schematic loads.

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.

76  {
77  return wxT( "sch" );
78  }

◆ 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.

81  {
82  return wxT( "lib" );
83  }

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

4360 {
4361  if( m_cache )
4363 
4364  // If the cache hasn't been loaded, it hasn't been modified.
4365  return 0;
4366 }
SCH_LEGACY_PLUGIN_CACHE * m_cache

References SCH_LEGACY_PLUGIN_CACHE::GetModifyHash(), and m_cache.

◆ GetName()

const wxString SCH_LEGACY_PLUGIN::GetName ( ) const
inlineoverridevirtual

Return a brief hard coded name for this SCH_PLUGIN.

Implements SCH_PLUGIN.

Definition at line 70 of file sch_legacy_plugin.h.

71  {
72  return wxT( "Eeschema-Legacy" );
73  }

◆ init()

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

initialize PLUGIN like a constructor would.

Definition at line 585 of file sch_legacy_plugin.cpp.

586 {
587  m_version = 0;
588  m_rootSheet = nullptr;
589  m_schematic = aSchematic;
590  m_cache = nullptr;
591  m_out = nullptr;
592 }
SCH_LEGACY_PLUGIN_CACHE * m_cache
SCH_SHEET * m_rootSheet
The root sheet of the schematic being loaded.
int m_version
Version of file being loaded.
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.

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

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

◆ isBuffering()

bool SCH_LEGACY_PLUGIN::isBuffering ( const PROPERTIES aProperties)
private

Definition at line 4353 of file sch_legacy_plugin.cpp.

4354 {
4355  return ( aProperties && aProperties->Exists( SCH_LEGACY_PLUGIN::PropBuffering ) );
4356 }
bool Exists(const std::string &aProperty) const
Definition: properties.h:41
static const char * PropBuffering
The property used internally by the plugin to enable cache buffering which prevents the library file ...

References PROPERTIES::Exists(), and PropBuffering.

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

◆ IsSymbolLibWritable()

bool SCH_LEGACY_PLUGIN::IsSymbolLibWritable ( const wxString &  aLibraryPath)
overridevirtual

Return true if the library at aLibraryPath is writable.

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

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several symbols.
Exceptions
IO_ERRORif no library at aLibraryPath exists.

Reimplemented from SCH_PLUGIN.

Definition at line 4535 of file sch_legacy_plugin.cpp.

4536 {
4537  // Writing legacy symbol libraries is deprecated.
4538  return false;
4539 }

◆ Load()

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

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

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

Parameters
aFileNameis the name of the file to use as input and may be foreign in nature or native in nature.
aKiwayis the KIWAY object used to access the symbol libraries loaded by the project.
aAppendToMeis an existing SCH_SHEET to append to, but if NULL then this means "do not append, rather load anew".
aPropertiesis 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_ERRORif 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 617 of file sch_legacy_plugin.cpp.

619 {
620  wxASSERT( !aFileName || aSchematic != nullptr );
621 
622  LOCALE_IO toggle; // toggles on, then off, the C locale.
623  SCH_SHEET* sheet;
624 
625  wxFileName fn = aFileName;
626 
627  // Unfortunately child sheet file names the legacy schematic file format are not fully
628  // qualified and are always appended to the project path. The aFileName attribute must
629  // always be an absolute path so the project path can be used for load child sheet files.
630  wxASSERT( fn.IsAbsolute() );
631 
632  if( aAppendToMe )
633  {
634  wxLogTrace( traceSchLegacyPlugin, "Append \"%s\" to sheet \"%s\".",
635  aFileName, aAppendToMe->GetFileName() );
636 
637  wxFileName normedFn = aAppendToMe->GetFileName();
638 
639  if( !normedFn.IsAbsolute() )
640  {
641  if( aFileName.Right( normedFn.GetFullPath().Length() ) == normedFn.GetFullPath() )
642  m_path = aFileName.Left( aFileName.Length() - normedFn.GetFullPath().Length() );
643  }
644 
645  if( m_path.IsEmpty() )
646  m_path = aSchematic->Prj().GetProjectPath();
647 
648  wxLogTrace( traceSchLegacyPlugin, "m_Normalized append path \"%s\".", m_path );
649  }
650  else
651  {
652  m_path = aSchematic->Prj().GetProjectPath();
653  }
654 
655  m_currentPath.push( m_path );
656  init( aSchematic, aProperties );
657 
658  if( aAppendToMe == nullptr )
659  {
660  // Clean up any allocated memory if an exception occurs loading the schematic.
661  std::unique_ptr<SCH_SHEET> newSheet = std::make_unique<SCH_SHEET>( aSchematic );
662  newSheet->SetFileName( aFileName );
663  m_rootSheet = newSheet.get();
664  loadHierarchy( newSheet.get() );
665 
666  // If we got here, the schematic loaded successfully.
667  sheet = newSheet.release();
668  m_rootSheet = nullptr; // Quiet Coverity warning.
669  }
670  else
671  {
672  wxCHECK_MSG( aSchematic->IsValid(), nullptr, "Can't append to a schematic with no root!" );
673  m_rootSheet = &aSchematic->Root();
674  sheet = aAppendToMe;
675  loadHierarchy( sheet );
676  }
677 
678  wxASSERT( m_currentPath.size() == 1 ); // only the project path should remain
679 
680  return sheet;
681 }
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
const wxChar *const traceSchLegacyPlugin
Flag to enable legacy schematic plugin debug output.
bool IsValid() const
A simple test if the schematic is loaded, not a complete one.
Definition: schematic.h:108
void init(SCHEMATIC *aSchematic, const PROPERTIES *aProperties=nullptr)
initialize PLUGIN like a constructor would.
SCH_SHEET * m_rootSheet
The root sheet of the schematic being loaded.
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:122
wxString m_path
Root project path for loading child sheets.
void loadHierarchy(SCH_SHEET *aSheet)
wxString GetFileName() const
Return the filename corresponding to this sheet.
Definition: sch_sheet.h:314
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:54
PROJECT & Prj() const override
Return a reference to the project this schematic is part of.
Definition: schematic.h:75
SCH_SHEET & Root() const
Definition: schematic.h:92
std::stack< wxString > m_currentPath
Stack to maintain nested sheet paths.

References SCH_SHEET::GetFileName(), PROJECT::GetProjectPath(), init(), SCHEMATIC::IsValid(), loadHierarchy(), 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 1130 of file sch_legacy_plugin.cpp.

1131 {
1132  std::unique_ptr<SCH_BITMAP> bitmap = std::make_unique<SCH_BITMAP>();
1133 
1134  const char* line = aReader.Line();
1135 
1136  wxCHECK( strCompare( "$Bitmap", line, &line ), nullptr );
1137 
1138  line = aReader.ReadLine();
1139 
1140  while( line != nullptr )
1141  {
1142  if( strCompare( "Pos", line, &line ) )
1143  {
1144  wxPoint position;
1145 
1146  position.x = Mils2Iu( parseInt( aReader, line, &line ) );
1147  position.y = Mils2Iu( parseInt( aReader, line, &line ) );
1148  bitmap->SetPosition( position );
1149  }
1150  else if( strCompare( "Scale", line, &line ) )
1151  {
1152  auto scalefactor = parseDouble( aReader, line, &line );
1153 
1154  // Prevent scalefactor values that cannot be displayed.
1155  // In the case of a bad value, we accept that the image might be mis-scaled
1156  // rather than removing the full image. Users can then edit the scale factor in
1157  // Eeschema to the appropriate value
1158  if( !std::isnormal( scalefactor ) )
1159  scalefactor = 1.0;
1160 
1161  bitmap->GetImage()->SetScale( scalefactor );
1162  }
1163  else if( strCompare( "Data", line, &line ) )
1164  {
1165  wxMemoryOutputStream stream;
1166 
1167  while( line )
1168  {
1169  if( !aReader.ReadLine() )
1170  SCH_PARSE_ERROR( _( "Unexpected end of file" ), aReader, line );
1171 
1172  line = aReader.Line();
1173 
1174  if( strCompare( "EndData", line ) )
1175  {
1176  // all the PNG date is read.
1177  // We expect here m_image and m_bitmap are void
1178  wxImage* image = new wxImage();
1179  wxMemoryInputStream istream( stream );
1180  image->LoadFile( istream, wxBITMAP_TYPE_PNG );
1181  bitmap->GetImage()->SetImage( image );
1182  bitmap->GetImage()->SetBitmap( new wxBitmap( *image ) );
1183  break;
1184  }
1185 
1186  // Read PNG data, stored in hexadecimal,
1187  // each byte = 2 hexadecimal digits and a space between 2 bytes
1188  // and put it in memory stream buffer
1189  // Note:
1190  // Some old files created bu the V4 schematic versions have a extra
1191  // "$EndBitmap" at the end of the hexadecimal data. (Probably due to
1192  // a bug). So discard it
1193  int len = strlen( line );
1194 
1195  for( ; len > 0 && !isspace( *line ) && '$' != *line; len -= 3, line += 3 )
1196  {
1197  int value = 0;
1198 
1199  if( sscanf( line, "%X", &value ) == 1 )
1200  stream.PutC( (char) value );
1201  else
1202  THROW_IO_ERROR( "invalid PNG data" );
1203  }
1204  }
1205 
1206  if( line == nullptr )
1207  THROW_IO_ERROR( _( "unexpected end of file" ) );
1208  }
1209  else if( strCompare( "$EndBitmap", line ) )
1210  return bitmap.release();
1211 
1212  line = aReader.ReadLine();
1213  }
1214 
1215  THROW_IO_ERROR( _( "unexpected end of file" ) );
1216 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static double parseDouble(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parses an ASCII point string with possible leading whitespace into a double precision floating point ...
#define Mils2Iu(x)
#define _(s)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38

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

Referenced by LoadContent().

◆ loadBusAlias()

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

Definition at line 1850 of file sch_legacy_plugin.cpp.

1852 {
1853  auto busAlias = std::make_shared<BUS_ALIAS>( aScreen );
1854  const char* line = aReader.Line();
1855 
1856  wxCHECK( strCompare( "BusAlias", line, &line ), nullptr );
1857 
1858  wxString buf;
1859  parseUnquotedString( buf, aReader, line, &line );
1860  busAlias->SetName( buf );
1861 
1862  while( *line != '\0' )
1863  {
1864  buf.clear();
1865  parseUnquotedString( buf, aReader, line, &line, true );
1866 
1867  if( buf.Len() > 0 )
1868  {
1869  busAlias->AddMember( buf );
1870  }
1871  }
1872 
1873  return busAlias;
1874 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.

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

1362 {
1363  const char* line = aReader.Line();
1364 
1365  wxCHECK( strCompare( "Entry", line, &line ), nullptr );
1366 
1367  std::unique_ptr<SCH_BUS_ENTRY_BASE> busEntry;
1368 
1369  if( strCompare( "Wire", line, &line ) )
1370  {
1371  busEntry = std::make_unique<SCH_BUS_WIRE_ENTRY>();
1372 
1373  if( !strCompare( "Line", line, &line ) )
1374  SCH_PARSE_ERROR( "invalid bus entry definition expected 'Line'", aReader, line );
1375  }
1376  else if( strCompare( "Bus", line, &line ) )
1377  {
1378  busEntry = std::make_unique<SCH_BUS_BUS_ENTRY>();
1379 
1380  if( !strCompare( "Bus", line, &line ) )
1381  SCH_PARSE_ERROR( "invalid bus entry definition expected 'Bus'", aReader, line );
1382  }
1383  else
1384  SCH_PARSE_ERROR( "invalid bus entry type", aReader, line );
1385 
1386  line = aReader.ReadLine();
1387 
1388  wxPoint pos;
1389  wxSize size;
1390 
1391  pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
1392  pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
1393  size.x = Mils2Iu( parseInt( aReader, line, &line ) );
1394  size.y = Mils2Iu( parseInt( aReader, line, &line ) );
1395 
1396  size.x -= pos.x;
1397  size.y -= pos.y;
1398 
1399  busEntry->SetPosition( pos );
1400  busEntry->SetSize( size );
1401 
1402  return busEntry.release();
1403 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
#define Mils2Iu(x)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)

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

Referenced by LoadContent().

◆ LoadContent()

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

Definition at line 804 of file sch_legacy_plugin.cpp.

805 {
806  m_version = version;
807 
808  // We cannot safely load content without a set root level.
809  wxCHECK_RET( m_rootSheet,
810  "Cannot call SCH_LEGACY_PLUGIN::LoadContent() without setting root sheet." );
811 
812  while( aReader.ReadLine() )
813  {
814  checkpoint();
815 
816  char* line = aReader.Line();
817 
818  while( *line == ' ' )
819  line++;
820 
821  // Either an object will be loaded properly or the file load will fail and raise
822  // an exception.
823  if( strCompare( "$Descr", line ) )
824  loadPageSettings( aReader, aScreen );
825  else if( strCompare( "$Comp", line ) )
826  aScreen->Append( loadSymbol( aReader ) );
827  else if( strCompare( "$Sheet", line ) )
828  aScreen->Append( loadSheet( aReader ) );
829  else if( strCompare( "$Bitmap", line ) )
830  aScreen->Append( loadBitmap( aReader ) );
831  else if( strCompare( "Connection", line ) )
832  aScreen->Append( loadJunction( aReader ) );
833  else if( strCompare( "NoConn", line ) )
834  aScreen->Append( loadNoConnect( aReader ) );
835  else if( strCompare( "Wire", line ) )
836  aScreen->Append( loadWire( aReader ) );
837  else if( strCompare( "Entry", line ) )
838  aScreen->Append( loadBusEntry( aReader ) );
839  else if( strCompare( "Text", line ) )
840  aScreen->Append( loadText( aReader ) );
841  else if( strCompare( "BusAlias", line ) )
842  aScreen->AddBusAlias( loadBusAlias( aReader, aScreen ) );
843  else if( strCompare( "$EndSCHEMATC", line ) )
844  return;
845  else
846  SCH_PARSE_ERROR( "unrecognized token", aReader, line );
847  }
848 }
SCH_SHEET * loadSheet(LINE_READER &aReader)
SCH_JUNCTION * loadJunction(LINE_READER &aReader)
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
SCH_SHEET * m_rootSheet
The root sheet of the schematic being loaded.
SCH_BUS_ENTRY_BASE * loadBusEntry(LINE_READER &aReader)
int m_version
Version of file being loaded.
void loadPageSettings(LINE_READER &aReader, SCH_SCREEN *aScreen)
SCH_BITMAP * loadBitmap(LINE_READER &aReader)
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
void AddBusAlias(std::shared_ptr< BUS_ALIAS > aAlias)
Add a bus alias definition (and transfers ownership of the pointer).
void Append(SCH_ITEM *aItem)
Definition: sch_screen.cpp:146
SCH_NO_CONNECT * loadNoConnect(LINE_READER &aReader)
SCH_LINE * loadWire(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)

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

766 {
767  FILE_LINE_READER reader( aFileName );
768 
769  if( m_progressReporter )
770  {
771  m_progressReporter->Report( wxString::Format( _( "Loading %s..." ), aFileName ) );
772 
774  THROW_IO_ERROR( ( "Open cancelled by user." ) );
775 
776  m_lineReader = &reader;
777  m_lineCount = 0;
778 
779  while( reader.ReadLine() )
780  m_lineCount++;
781 
782  reader.Rewind();
783  }
784 
785  loadHeader( reader, aScreen );
786 
787  LoadContent( reader, aScreen, m_version );
788 
789  // Unfortunately schematic files prior to version 2 are not terminated with $EndSCHEMATC
790  // so checking for its existance will fail so just exit here and take our chances. :(
791  if( m_version > 1 )
792  {
793  char* line = reader.Line();
794 
795  while( *line == ' ' )
796  line++;
797 
798  if( !strCompare( "$EndSCHEMATC", line ) )
799  THROW_IO_ERROR( "'$EndSCHEMATC' not found" );
800  }
801 }
void LoadContent(LINE_READER &aReader, SCH_SCREEN *aScreen, int version=EESCHEMA_VERSION)
virtual void Report(const wxString &aMessage)=0
Display aMessage in the progress bar dialog.
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
int m_version
Version of file being loaded.
A LINE_READER that reads from an open file.
Definition: richio.h:172
#define _(s)
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, const CPTREE &aTree)
Output a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:200
LINE_READER * m_lineReader
for progress reporting
PROGRESS_REPORTER * m_progressReporter
optional; may be nullptr
unsigned m_lineCount
for progress reporting
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
void loadHeader(LINE_READER &aReader, SCH_SCREEN *aScreen)
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38

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

852 {
853  const char* line = aReader.ReadLine();
854 
855  if( !line || !strCompare( "Eeschema Schematic File Version", line, &line ) )
856  {
857  m_error.Printf( _( "'%s' does not appear to be an Eeschema file." ),
858  aScreen->GetFileName() );
860  }
861 
862  // get the file version here.
863  m_version = parseInt( aReader, line, &line );
864 
865  // The next lines are the lib list section, and are mainly comments, like:
866  // LIBS:power
867  // the lib list is not used, but is in schematic file just in case.
868  // It is usually not empty, but we accept empty list.
869  // If empty, there is a legacy section, not used
870  // EELAYER i j
871  // and the last line is
872  // EELAYER END
873  // Skip all lines until the end of header "EELAYER END" is found
874  while( aReader.ReadLine() )
875  {
876  checkpoint();
877 
878  line = aReader.Line();
879 
880  while( *line == ' ' )
881  line++;
882 
883  if( strCompare( "EELAYER END", line ) )
884  return;
885  }
886 
887  THROW_IO_ERROR( _( "Missing 'EELAYER END'" ) );
888 }
const wxString & GetFileName() const
Definition: sch_screen.h:145
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
wxString m_error
For throwing exceptions or errors on partial schematic loads.
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
int m_version
Version of file being loaded.
#define _(s)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38

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

687 {
688  SCH_SCREEN* screen = nullptr;
689 
690  if( !aSheet->GetScreen() )
691  {
692  // SCH_SCREEN objects store the full path and file name where the SCH_SHEET object only
693  // stores the file name and extension. Add the project path to the file name and
694  // extension to compare when calling SCH_SHEET::SearchHierarchy().
695  wxFileName fileName = aSheet->GetFileName();
696  fileName.SetExt( "sch" );
697 
698  if( !fileName.IsAbsolute() )
699  fileName.MakeAbsolute( m_currentPath.top() );
700 
701  // Save the current path so that it gets restored when descending and ascending the
702  // sheet hierarchy which allows for sheet schematic files to be nested in folders
703  // relative to the last path a schematic was loaded from.
704  wxLogTrace( traceSchLegacyPlugin, "Saving path '%s'", m_currentPath.top() );
705  m_currentPath.push( fileName.GetPath() );
706  wxLogTrace( traceSchLegacyPlugin, "Current path '%s'", m_currentPath.top() );
707  wxLogTrace( traceSchLegacyPlugin, "Loading '%s'", fileName.GetFullPath() );
708 
709  m_rootSheet->SearchHierarchy( fileName.GetFullPath(), &screen );
710 
711  if( screen )
712  {
713  aSheet->SetScreen( screen );
714  screen->SetParent( m_schematic );
715  // Do not need to load the sub-sheets - this has already been done.
716  }
717  else
718  {
719  aSheet->SetScreen( new SCH_SCREEN( m_schematic ) );
720  aSheet->GetScreen()->SetFileName( fileName.GetFullPath() );
721 
722  try
723  {
724  loadFile( fileName.GetFullPath(), aSheet->GetScreen() );
725  }
726  catch( const IO_ERROR& ioe )
727  {
728  // If there is a problem loading the root sheet, there is no recovery.
729  if( aSheet == m_rootSheet )
730  throw( ioe );
731 
732  // For all subsheets, queue up the error message for the caller.
733  if( !m_error.IsEmpty() )
734  m_error += "\n";
735 
736  m_error += ioe.What();
737  }
738 
739  aSheet->GetScreen()->SetFileReadOnly( !fileName.IsFileWritable() );
740  aSheet->GetScreen()->SetFileExists( true );
741 
742  for( auto aItem : aSheet->GetScreen()->Items().OfType( SCH_SHEET_T ) )
743  {
744  wxCHECK2( aItem->Type() == SCH_SHEET_T, continue );
745  auto sheet = static_cast<SCH_SHEET*>( aItem );
746 
747  // Set the parent to aSheet. This effectively creates a method to find
748  // the root sheet from any sheet so a pointer to the root sheet does not
749  // need to be stored globally. Note: this is not the same as a hierarchy.
750  // Complex hierarchies can have multiple copies of a sheet. This only
751  // provides a simple tree to find the root sheet.
752  sheet->SetParent( aSheet );
753 
754  // Recursion starts here.
755  loadHierarchy( sheet );
756  }
757  }
758 
759  m_currentPath.pop();
760  wxLogTrace( traceSchLegacyPlugin, "Restoring path \"%s\"", m_currentPath.top() );
761  }
762 }
EE_TYPE OfType(KICAD_T aType) const
Definition: sch_rtree.h:230
bool SearchHierarchy(const wxString &aFilename, SCH_SCREEN **aScreen)
Search the existing hierarchy for an instance of screen loaded from aFileName.
Definition: sch_sheet.cpp:693
wxString m_error
For throwing exceptions or errors on partial schematic loads.
void SetScreen(SCH_SCREEN *aScreen)
Set the SCH_SCREEN associated with this sheet to aScreen.
Definition: sch_sheet.cpp:175
const wxChar *const traceSchLegacyPlugin
Flag to enable legacy schematic plugin debug output.
SCH_SHEET * m_rootSheet
The root sheet of the schematic being loaded.
void SetFileExists(bool aFileExists)
Definition: sch_screen.h:150
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:102
virtual void SetParent(EDA_ITEM *aParent)
Definition: eda_item.h:115
void loadFile(const wxString &aFileName, SCH_SCREEN *aScreen)
void SetFileReadOnly(bool aIsReadOnly)
Definition: sch_screen.h:147
void loadHierarchy(SCH_SHEET *aSheet)
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:30
wxString GetFileName() const
Return the filename corresponding to this sheet.
Definition: sch_sheet.h:314
EE_RTREE & Items()
Gets the full RTree, usually for iterating.
Definition: sch_screen.h:110
void SetFileName(const wxString &aFileName)
Set the file name for this screen to aFileName.
Definition: sch_screen.cpp:110
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
Definition: ki_exception.h:75
std::stack< wxString > m_currentPath
Stack to maintain nested sheet paths.

References SCH_SHEET::GetFileName(), SCH_SHEET::GetScreen(), SCH_SCREEN::Items(), loadFile(), m_currentPath, m_error, m_rootSheet, m_schematic, 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().

◆ loadJunction()

SCH_JUNCTION * SCH_LEGACY_PLUGIN::loadJunction ( LINE_READER aReader)
private

Definition at line 1219 of file sch_legacy_plugin.cpp.

1220 {
1221  std::unique_ptr<SCH_JUNCTION> junction = std::make_unique<SCH_JUNCTION>();
1222 
1223  const char* line = aReader.Line();
1224 
1225  wxCHECK( strCompare( "Connection", line, &line ), nullptr );
1226 
1227  wxString name;
1228 
1229  parseUnquotedString( name, aReader, line, &line );
1230 
1231  wxPoint position;
1232 
1233  position.x = Mils2Iu( parseInt( aReader, line, &line ) );
1234  position.y = Mils2Iu( parseInt( aReader, line, &line ) );
1235  junction->SetPosition( position );
1236 
1237  return junction.release();
1238 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.
#define Mils2Iu(x)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
const char * name
Definition: DXF_plotter.cpp:56

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

Referenced by LoadContent().

◆ loadNoConnect()

SCH_NO_CONNECT * SCH_LEGACY_PLUGIN::loadNoConnect ( LINE_READER aReader)
private

Definition at line 1241 of file sch_legacy_plugin.cpp.

1242 {
1243  std::unique_ptr<SCH_NO_CONNECT> no_connect = std::make_unique<SCH_NO_CONNECT>();
1244 
1245  const char* line = aReader.Line();
1246 
1247  wxCHECK( strCompare( "NoConn", line, &line ), nullptr );
1248 
1249  wxString name;
1250 
1251  parseUnquotedString( name, aReader, line, &line );
1252 
1253  wxPoint position;
1254 
1255  position.x = Mils2Iu( parseInt( aReader, line, &line ) );
1256  position.y = Mils2Iu( parseInt( aReader, line, &line ) );
1257  no_connect->SetPosition( position );
1258 
1259  return no_connect.release();
1260 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.
#define Mils2Iu(x)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
const char * name
Definition: DXF_plotter.cpp:56

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

Referenced by LoadContent().

◆ loadPageSettings()

void SCH_LEGACY_PLUGIN::loadPageSettings ( LINE_READER aReader,
SCH_SCREEN aScreen 
)
private

Definition at line 891 of file sch_legacy_plugin.cpp.

892 {
893  wxASSERT( aScreen != nullptr );
894 
895  wxString buf;
896  const char* line = aReader.Line();
897 
898  PAGE_INFO pageInfo;
899  TITLE_BLOCK tb;
900 
901  wxCHECK_RET( strCompare( "$Descr", line, &line ), "Invalid sheet description" );
902 
903  parseUnquotedString( buf, aReader, line, &line );
904 
905  if( !pageInfo.SetType( buf ) )
906  SCH_PARSE_ERROR( "invalid page size", aReader, line );
907 
908  int pagew = parseInt( aReader, line, &line );
909  int pageh = parseInt( aReader, line, &line );
910 
911  if( buf == PAGE_INFO::Custom )
912  {
913  pageInfo.SetWidthMils( pagew );
914  pageInfo.SetHeightMils( pageh );
915  }
916  else
917  {
918  wxString orientation;
919 
920  // Non custom size, set portrait if its present. Can be empty string which defaults
921  // to landscape.
922  parseUnquotedString( orientation, aReader, line, &line, true );
923 
924  if( orientation == "portrait" )
925  pageInfo.SetPortrait( true );
926  }
927 
928  aScreen->SetPageSettings( pageInfo );
929 
930  while( line != nullptr )
931  {
932  buf.clear();
933 
934  if( !aReader.ReadLine() )
935  SCH_PARSE_ERROR( _( "unexpected end of file" ), aReader, line );
936 
937  line = aReader.Line();
938 
939  if( strCompare( "Sheet", line, &line ) )
940  {
941  aScreen->SetVirtualPageNumber( parseInt( aReader, line, &line ) );
942  aScreen->SetPageCount( parseInt( aReader, line, &line ) );
943  }
944  else if( strCompare( "Title", line, &line ) )
945  {
946  parseQuotedString( buf, aReader, line, &line, true );
947  tb.SetTitle( buf );
948  }
949  else if( strCompare( "Date", line, &line ) )
950  {
951  parseQuotedString( buf, aReader, line, &line, true );
952  tb.SetDate( buf );
953  }
954  else if( strCompare( "Rev", line, &line ) )
955  {
956  parseQuotedString( buf, aReader, line, &line, true );
957  tb.SetRevision( buf );
958  }
959  else if( strCompare( "Comp", line, &line ) )
960  {
961  parseQuotedString( buf, aReader, line, &line, true );
962  tb.SetCompany( buf );
963  }
964  else if( strCompare( "Comment1", line, &line ) )
965  {
966  parseQuotedString( buf, aReader, line, &line, true );
967  tb.SetComment( 0, buf );
968  }
969  else if( strCompare( "Comment2", line, &line ) )
970  {
971  parseQuotedString( buf, aReader, line, &line, true );
972  tb.SetComment( 1, buf );
973  }
974  else if( strCompare( "Comment3", line, &line ) )
975  {
976  parseQuotedString( buf, aReader, line, &line, true );
977  tb.SetComment( 2, buf );
978  }
979  else if( strCompare( "Comment4", line, &line ) )
980  {
981  parseQuotedString( buf, aReader, line, &line, true );
982  tb.SetComment( 3, buf );
983  }
984  else if( strCompare( "Comment5", line, &line ) )
985  {
986  parseQuotedString( buf, aReader, line, &line, true );
987  tb.SetComment( 4, buf );
988  }
989  else if( strCompare( "Comment6", line, &line ) )
990  {
991  parseQuotedString( buf, aReader, line, &line, true );
992  tb.SetComment( 5, buf );
993  }
994  else if( strCompare( "Comment7", line, &line ) )
995  {
996  parseQuotedString( buf, aReader, line, &line, true );
997  tb.SetComment( 6, buf );
998  }
999  else if( strCompare( "Comment8", line, &line ) )
1000  {
1001  parseQuotedString( buf, aReader, line, &line, true );
1002  tb.SetComment( 7, buf );
1003  }
1004  else if( strCompare( "Comment9", line, &line ) )
1005  {
1006  parseQuotedString( buf, aReader, line, &line, true );
1007  tb.SetComment( 8, buf );
1008  }
1009  else if( strCompare( "$EndDescr", line ) )
1010  {
1011  aScreen->SetTitleBlock( tb );
1012  return;
1013  }
1014  }
1015 
1016  SCH_PARSE_ERROR( "missing 'EndDescr'", aReader, line );
1017 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
void SetVirtualPageNumber(int aPageNumber)
Definition: base_screen.h:76
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
void SetRevision(const wxString &aRevision)
Definition: title_block.h:81
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.
bool SetType(const wxString &aStandardPageDescriptionName, bool aIsPortrait=false)
Set the name of the page type and also the sizes and margins commonly associated with that type name.
Definition: page_info.cpp:119
void SetDate(const wxString &aDate)
Set the date field, and defaults to the current time and date.
Definition: title_block.h:71
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: sch_screen.h:133
static const wxChar Custom[]
"User" defined page type
Definition: page_info.h:77
Hold the information shown in the lower right corner of a plot, printout, or editing view.
Definition: title_block.h:40
void SetComment(int aIdx, const wxString &aComment)
Definition: title_block.h:101
Describe the page size and margins of a paper page on which to eventually print or plot.
Definition: page_info.h:53
void SetCompany(const wxString &aCompany)
Definition: title_block.h:91
#define _(s)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock)
Definition: sch_screen.h:158
void SetTitle(const wxString &aTitle)
Definition: title_block.h:58
void SetHeightMils(int aHeightInMils)
Definition: page_info.cpp:257
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
void SetWidthMils(int aWidthInMils)
Definition: page_info.cpp:243
static void parseQuotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an quoted ASCII utf8 and updates the pointer at aOutput if it is not NULL.
void SetPageCount(int aPageCount)
Definition: base_screen.cpp:63
void SetPortrait(bool aIsPortrait)
Rotate the paper page 90 degrees.
Definition: page_info.cpp:186

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

1021 {
1022  std::unique_ptr<SCH_SHEET> sheet = std::make_unique<SCH_SHEET>();
1023 
1024  const char* line = aReader.ReadLine();
1025 
1026  while( line != nullptr )
1027  {
1028  if( strCompare( "S", line, &line ) ) // Sheet dimensions.
1029  {
1030  wxPoint position;
1031 
1032  position.x = Mils2Iu( parseInt( aReader, line, &line ) );
1033  position.y = Mils2Iu( parseInt( aReader, line, &line ) );
1034  sheet->SetPosition( position );
1035 
1036  wxSize size;
1037 
1038  size.SetWidth( Mils2Iu( parseInt( aReader, line, &line ) ) );
1039  size.SetHeight( Mils2Iu( parseInt( aReader, line, &line ) ) );
1040  sheet->SetSize( size );
1041  }
1042  else if( strCompare( "U", line, &line ) ) // Sheet UUID.
1043  {
1044  wxString text;
1045  parseUnquotedString( text, aReader, line );
1046 
1047  if( text != "00000000" )
1048  const_cast<KIID&>( sheet->m_Uuid ) = KIID( text );
1049  }
1050  else if( *line == 'F' ) // Sheet field.
1051  {
1052  line++;
1053 
1054  wxString text;
1055  int size;
1056  int fieldId = parseInt( aReader, line, &line );
1057 
1058  if( fieldId == 0 || fieldId == 1 ) // Sheet name and file name.
1059  {
1060  parseQuotedString( text, aReader, line, &line );
1061  size = Mils2Iu( parseInt( aReader, line, &line ) );
1062 
1063  SCH_FIELD& field = sheet->GetFields()[ fieldId ];
1064  field.SetText( text );
1065  field.SetTextSize( wxSize( size, size ) );
1066  }
1067  else // Sheet pin.
1068  {
1069  // Use a unique_ptr so that we clean up in the case of a throw
1070  std::unique_ptr<SCH_SHEET_PIN> sheetPin = std::make_unique<SCH_SHEET_PIN>( sheet.get() );
1071 
1072  sheetPin->SetNumber( fieldId );
1073 
1074  // Can be empty fields.
1075  parseQuotedString( text, aReader, line, &line, true );
1076 
1077  sheetPin->SetText( ConvertToNewOverbarNotation( text ) );
1078 
1079  if( line == nullptr )
1080  THROW_IO_ERROR( _( "unexpected end of line" ) );
1081 
1082  switch( parseChar( aReader, line, &line ) )
1083  {
1084  case 'I': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_INPUT ); break;
1085  case 'O': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_OUTPUT ); break;
1086  case 'B': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_BIDI ); break;
1087  case 'T': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_TRISTATE ); break;
1088  case 'U': sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_UNSPECIFIED ); break;
1089  default: SCH_PARSE_ERROR( "invalid sheet pin type", aReader, line );
1090  }
1091 
1092  switch( parseChar( aReader, line, &line ) )
1093  {
1094  case 'R': sheetPin->SetSide( SHEET_SIDE::RIGHT ); break;
1095  case 'T': sheetPin->SetSide( SHEET_SIDE::TOP ); break;
1096  case 'B': sheetPin->SetSide( SHEET_SIDE::BOTTOM ); break;
1097  case 'L': sheetPin->SetSide( SHEET_SIDE::LEFT ); break;
1098  default:
1099  SCH_PARSE_ERROR( "invalid sheet pin side", aReader, line );
1100  }
1101 
1102  wxPoint position;
1103 
1104  position.x = Mils2Iu( parseInt( aReader, line, &line ) );
1105  position.y = Mils2Iu( parseInt( aReader, line, &line ) );
1106  sheetPin->SetPosition( position );
1107 
1108  size = Mils2Iu( parseInt( aReader, line, &line ) );
1109 
1110  sheetPin->SetTextSize( wxSize( size, size ) );
1111 
1112  sheet->AddPin( sheetPin.release() );
1113  }
1114  }
1115  else if( strCompare( "$EndSheet", line ) )
1116  {
1117  sheet->AutoplaceFields( /* aScreen */ nullptr, /* aManual */ false );
1118  return sheet.release();
1119  }
1120 
1121  line = aReader.ReadLine();
1122  }
1123 
1124  SCH_PARSE_ERROR( "missing '$EndSheet`", aReader, line );
1125 
1126  return nullptr; // Prevents compiler warning. Should never get here.
1127 }
wxString ConvertToNewOverbarNotation(const wxString &aOldStr)
Convert the old ~...~ overbar notation to the new ~{...} one.
Instances are attached to a symbol or sheet and provide a place for the symbol's value,...
Definition: sch_field.h:49
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:258
#define Mils2Iu(x)
Definition: kiid.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:124
#define _(s)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
static char parseChar(LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr)
Parse a single ASCII character and updates the pointer at aOutput if it is not NULL.
static void parseQuotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an quoted ASCII utf8 and updates the pointer at aOutput if it is not NULL.
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38

References _, BOTTOM, ConvertToNewOverbarNotation(), LEFT, Mils2Iu, parseChar(), parseInt(), parseQuotedString(), parseUnquotedString(), PS_BIDI, PS_INPUT, PS_OUTPUT, PS_TRISTATE, PS_UNSPECIFIED, LINE_READER::ReadLine(), RIGHT, SCH_PARSE_ERROR, EDA_TEXT::SetText(), EDA_TEXT::SetTextSize(), strCompare(), text, THROW_IO_ERROR, and TOP.

Referenced by LoadContent().

◆ LoadSymbol()

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

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

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several symbols.
aPartNameis the name of the LIB_SYMBOL to load.
aPropertiesis 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_ERRORif 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 4411 of file sch_legacy_plugin.cpp.

4414 {
4415  LOCALE_IO toggle; // toggles on, then off, the C locale.
4416 
4417  cacheLib( aLibraryPath, aProperties );
4418 
4419  LIB_SYMBOL_MAP::const_iterator it = m_cache->m_symbols.find( aSymbolName );
4420 
4421  if( it == m_cache->m_symbols.end() )
4422  return nullptr;
4423 
4424  return it->second;
4425 }
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
SCH_LEGACY_PLUGIN_CACHE * m_cache
void cacheLib(const wxString &aLibraryFileName, const PROPERTIES *aProperties)

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

◆ loadSymbol()

SCH_SYMBOL * SCH_LEGACY_PLUGIN::loadSymbol ( LINE_READER aReader)
private

Definition at line 1534 of file sch_legacy_plugin.cpp.

1535 {
1536  const char* line = aReader.Line();
1537 
1538  wxCHECK( strCompare( "$Comp", line, &line ), nullptr );
1539 
1540  std::unique_ptr<SCH_SYMBOL> symbol = std::make_unique<SCH_SYMBOL>();
1541 
1542  line = aReader.ReadLine();
1543 
1544  while( line != nullptr )
1545  {
1546  if( strCompare( "L", line, &line ) )
1547  {
1548  wxString libName;
1549  size_t pos = 2; // "X" plus ' ' space character.
1550  wxString utf8Line = wxString::FromUTF8( line );
1551  wxStringTokenizer tokens( utf8Line, " \r\n\t" );
1552 
1553  if( tokens.CountTokens() < 2 )
1554  THROW_PARSE_ERROR( "invalid symbol library definition", aReader.GetSource(),
1555  aReader.Line(), aReader.LineNumber(), pos );
1556 
1557  libName = tokens.GetNextToken();
1558  libName.Replace( "~", " " );
1559 
1560  LIB_ID libId;
1561 
1562  // Prior to schematic version 4, library IDs did not have a library nickname so
1563  // parsing the symbol name with LIB_ID::Parse() would break symbol library links
1564  // that contained '/' and ':' characters.
1565  if( m_version > 3 )
1566  libId.Parse( libName, true );
1567  else
1568  libId.SetLibItemName( libName );
1569 
1570  symbol->SetLibId( libId );
1571 
1572  wxString refDesignator = tokens.GetNextToken();
1573 
1574  refDesignator.Replace( "~", " " );
1575 
1576  wxString prefix = refDesignator;
1577 
1578  while( prefix.Length() )
1579  {
1580  if( ( prefix.Last() < '0' || prefix.Last() > '9') && prefix.Last() != '?' )
1581  break;
1582 
1583  prefix.RemoveLast();
1584  }
1585 
1586  // Avoid a prefix containing trailing/leading spaces
1587  prefix.Trim( true );
1588  prefix.Trim( false );
1589 
1590  if( prefix.IsEmpty() )
1591  symbol->SetPrefix( wxString( "U" ) );
1592  else
1593  symbol->SetPrefix( prefix );
1594  }
1595  else if( strCompare( "U", line, &line ) )
1596  {
1597  // This fixes a potentially buggy files caused by unit being set to zero which
1598  // causes netlist issues. See https://bugs.launchpad.net/kicad/+bug/1677282.
1599  int unit = parseInt( aReader, line, &line );
1600 
1601  if( unit == 0 )
1602  {
1603  unit = 1;
1604 
1605  // Set the file as modified so the user can be warned.
1606  if( m_rootSheet->GetScreen() )
1608  }
1609 
1610  symbol->SetUnit( unit );
1611 
1612  // Same can also happen with the convert parameter
1613  int convert = parseInt( aReader, line, &line );
1614 
1615  if( convert == 0 )
1616  {
1617  convert = 1;
1618 
1619  // Set the file as modified so the user can be warned.
1620  if( m_rootSheet->GetScreen() )
1622  }
1623 
1624  symbol->SetConvert( convert );
1625 
1626  wxString text;
1627  parseUnquotedString( text, aReader, line, &line );
1628 
1629  if( text != "00000000" )
1630  const_cast<KIID&>( symbol->m_Uuid ) = KIID( text );
1631  }
1632  else if( strCompare( "P", line, &line ) )
1633  {
1634  wxPoint pos;
1635 
1636  pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
1637  pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
1638  symbol->SetPosition( pos );
1639  }
1640  else if( strCompare( "AR", line, &line ) )
1641  {
1642  const char* strCompare = "Path=";
1643  int len = strlen( strCompare );
1644 
1645  if( strncasecmp( strCompare, line, len ) != 0 )
1646  SCH_PARSE_ERROR( "missing 'Path=' token", aReader, line );
1647 
1648  line += len;
1649  wxString pathStr, reference, unit;
1650 
1651  parseQuotedString( pathStr, aReader, line, &line );
1652 
1653  // Note: AR path excludes root sheet, but includes symbol. Normalize to
1654  // internal format by shifting everything down one and adding the root sheet.
1655  KIID_PATH path( pathStr );
1656 
1657  if( path.size() > 0 )
1658  {
1659  for( size_t i = path.size() - 1; i > 0; --i )
1660  path[i] = path[i-1];
1661 
1662  path[0] = m_rootSheet->m_Uuid;
1663  }
1664  else
1665  path.push_back( m_rootSheet->m_Uuid );
1666 
1667  strCompare = "Ref=";
1668  len = strlen( strCompare );
1669 
1670  if( strncasecmp( strCompare, line, len ) != 0 )
1671  SCH_PARSE_ERROR( "missing 'Ref=' token", aReader, line );
1672 
1673  line+= len;
1674  parseQuotedString( reference, aReader, line, &line );
1675 
1676  strCompare = "Part=";
1677  len = strlen( strCompare );
1678 
1679  if( strncasecmp( strCompare, line, len ) != 0 )
1680  SCH_PARSE_ERROR( "missing 'Part=' token", aReader, line );
1681 
1682  line+= len;
1683  parseQuotedString( unit, aReader, line, &line );
1684 
1685  long tmp;
1686 
1687  if( !unit.ToLong( &tmp, 10 ) )
1688  SCH_PARSE_ERROR( "expected integer value", aReader, line );
1689 
1690  if( tmp < 0 || tmp > MAX_UNIT_COUNT_PER_PACKAGE )
1691  SCH_PARSE_ERROR( "unit value out of range", aReader, line );
1692 
1693  symbol->AddHierarchicalReference( path, reference, (int)tmp );
1694  symbol->GetField( REFERENCE_FIELD )->SetText( reference );
1695 
1696  }
1697  else if( strCompare( "F", line, &line ) )
1698  {
1699  int index = parseInt( aReader, line, &line );
1700 
1701  wxString text, name;
1702 
1703  parseQuotedString( text, aReader, line, &line, true );
1704 
1705  char orientation = parseChar( aReader, line, &line );
1706  wxPoint pos;
1707  pos.x = Mils2Iu( parseInt( aReader, line, &line ) );
1708  pos.y = Mils2Iu( parseInt( aReader, line, &line ) );
1709  int size = Mils2Iu( parseInt( aReader, line, &line ) );
1710  int attributes = parseHex( aReader, line, &line );
1711 
1712  if( index >= symbol->GetFieldCount() )
1713  {
1714  // The first MANDATOR_FIELDS _must_ be constructed within the SCH_SYMBOL
1715  // constructor. This assert is simply here to guard against a change in that
1716  // constructor.
1717  wxASSERT( symbol->GetFieldCount() >= MANDATORY_FIELDS );
1718 
1719  // Ignore the _supplied_ fieldNdx. It is not important anymore if within the
1720  // user defined fields region (i.e. >= MANDATORY_FIELDS).
1721  // We freely renumber the index to fit the next available field slot.
1722  index = symbol->GetFieldCount(); // new has this index after insertion
1723 
1724  SCH_FIELD field( wxPoint( 0, 0 ), index, symbol.get(), name );
1725  symbol->AddField( field );
1726  }
1727 
1728  SCH_FIELD& field = symbol->GetFields()[index];
1729 
1730  // Prior to version 2 of the schematic file format, none of the following existed.
1731  if( m_version > 1 )
1732  {
1733  wxString textAttrs;
1734  char hjustify = parseChar( aReader, line, &line );
1735 
1736  parseUnquotedString( textAttrs, aReader, line, &line );
1737 
1738  // The name of the field is optional.
1739  parseQuotedString( name, aReader, line, &line, true );
1740 
1741  if( hjustify == 'L' )
1743  else if( hjustify == 'R' )
1745  else if( hjustify != 'C' )
1746  SCH_PARSE_ERROR( "symbol field text horizontal justification must be "
1747  "L, R, or C", aReader, line );
1748 
1749  // We are guaranteed to have a least one character here for older file formats
1750  // otherwise an exception would have been raised..
1751  if( textAttrs[0] == 'T' )
1753  else if( textAttrs[0] == 'B' )
1755  else if( textAttrs[0] != 'C' )
1756  SCH_PARSE_ERROR( "symbol field text vertical justification must be "
1757  "B, T, or C", aReader, line );
1758 
1759  // Newer file formats include the bold and italics text attribute.
1760  if( textAttrs.Length() > 1 )
1761  {
1762  if( textAttrs.Length() != 3 )
1763  SCH_PARSE_ERROR( _( "symbol field text attributes must be 3 characters wide" ),
1764  aReader, line );
1765 
1766  if( textAttrs[1] == 'I' )
1767  field.SetItalic( true );
1768  else if( textAttrs[1] != 'N' )
1769  SCH_PARSE_ERROR( "symbol field text italics indicator must be I or N",
1770  aReader, line );
1771 
1772  if( textAttrs[2] == 'B' )
1773  field.SetBold( true );
1774  else if( textAttrs[2] != 'N' )
1775  SCH_PARSE_ERROR( "symbol field text bold indicator must be B or N",
1776  aReader, line );
1777  }
1778  }
1779 
1780  field.SetText( text );
1781  field.SetTextPos( pos );
1782  field.SetVisible( !attributes );
1783  field.SetTextSize( wxSize( size, size ) );
1784 
1785  if( orientation == 'H' )
1786  field.SetTextAngle( TEXT_ANGLE_HORIZ );
1787  else if( orientation == 'V' )
1788  field.SetTextAngle( TEXT_ANGLE_VERT );
1789  else
1790  SCH_PARSE_ERROR( "symbol field orientation must be H or V", aReader, line );
1791 
1792  if( name.IsEmpty() )
1794 
1795  field.SetName( name );
1796  }
1797  else if( strCompare( "$EndComp", line ) )
1798  {
1799  // Ensure all flags (some are set by previous initializations) are reset:
1800  symbol->ClearFlags();
1801  return symbol.release();
1802  }
1803  else
1804  {
1805  // There are two lines that begin with a tab or spaces that includes a line with the
1806  // redundant position information and the transform matrix settings.
1807 
1808  // Parse the redundant position information just the same to check for formatting
1809  // errors.
1810  parseInt( aReader, line, &line ); // Always 1.
1811  parseInt( aReader, line, &line ); // The X coordinate.
1812  parseInt( aReader, line, &line ); // The Y coordinate.
1813 
1814  line = aReader.ReadLine();
1815 
1816  TRANSFORM transform;
1817 
1818  transform.x1 = parseInt( aReader, line, &line );
1819 
1820  if( transform.x1 < -1 || transform.x1 > 1 )
1821  SCH_PARSE_ERROR( "invalid symbol X1 transform value", aReader, line );
1822 
1823  transform.y1 = parseInt( aReader, line, &line );
1824 
1825  if( transform.y1 < -1 || transform.y1 > 1 )
1826  SCH_PARSE_ERROR( "invalid symbol Y1 transform value", aReader, line );
1827 
1828  transform.x2 = parseInt( aReader, line, &line );
1829 
1830  if( transform.x2 < -1 || transform.x2 > 1 )
1831  SCH_PARSE_ERROR( "invalid symbol X2 transform value", aReader, line );
1832 
1833  transform.y2 = parseInt( aReader, line, &line );
1834 
1835  if( transform.y2 < -1 || transform.y2 > 1 )
1836  SCH_PARSE_ERROR( "invalid symbol Y2 transform value", aReader, line );
1837 
1838  symbol->SetTransform( transform );
1839  }
1840 
1841  line = aReader.ReadLine();
1842  }
1843 
1844  SCH_PARSE_ERROR( "invalid symbol line", aReader, line );
1845 
1846  return nullptr; // Prevents compiler warning. Should never get here.
1847 }
Field Reference of part, i.e. "IC21".
#define TEXT_ANGLE_HORIZ
Frequent text rotations, used with {Set,Get}TextAngle(), in 0.1 degrees for now, hoping to migrate to...
Definition: eda_text.h:71
Instances are attached to a symbol or sheet and provide a place for the symbol's value,...
Definition: sch_field.h:49
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
int y2
Definition: transform.h:51
virtual const wxString & GetSource() const
Returns the name of the source of the lines in an abstract sense.
Definition: richio.h:109
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.
void SetItalic(bool isItalic)
Definition: eda_text.h:200
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:267
int x2
Definition: transform.h:50
SCH_SHEET * m_rootSheet
The root sheet of the schematic being loaded.
static uint32_t parseHex(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII hex integer string with possible leading whitespace into a long integer and updates th...
int x1
Definition: transform.h:48
#define MAX_UNIT_COUNT_PER_PACKAGE
The maximum number of units per package.
Definition: eeschema_id.h:44
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:258
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:51
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:102
#define Mils2Iu(x)
int m_version
Version of file being loaded.
int y1
Definition: transform.h:49
virtual void SetVisible(bool aVisible)
Definition: eda_text.h:206
Definition: kiid.h:44
for transforming drawing coordinates for a wxDC device context.
Definition: transform.h:45
#define THROW_PARSE_ERROR(aProblem, aSource, aInputLine, aLineNumber, aByteIndex)
Definition: ki_exception.h:164
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:124
virtual unsigned LineNumber() const
Return the line number of the last line read from this LINE_READER.
Definition: richio.h:135
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:223
#define _(s)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
static const wxString GetDefaultFieldName(int aFieldNdx, bool aTranslate=true)
Return a default symbol field name for field aFieldNdx for all components.
int SetLibItemName(const UTF8 &aLibItemName)
Override the library item name portion of the LIB_ID to aLibItemName.
Definition: lib_id.cpp:108
const KIID m_Uuid
Definition: eda_item.h:474
void SetContentModified(bool aModified=true)
Definition: base_screen.h:59
The first 4 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
int Parse(const UTF8 &aId, bool aFix=false)
Parse LIB_ID with the information from aId.
Definition: lib_id.cpp:49
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
const char * name
Definition: DXF_plotter.cpp:56
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:222
static char parseChar(LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr)
Parse a single ASCII character and updates the pointer at aOutput if it is not NULL.
void SetName(const wxString &aName)
Definition: sch_field.h:111
static void parseQuotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an quoted ASCII utf8 and updates the pointer at aOutput if it is not NULL.
#define TEXT_ANGLE_VERT
Definition: eda_text.h:72
virtual void SetTextAngle(double aAngle)
Definition: eda_text.h:188
void SetBold(bool aBold)
Definition: eda_text.h:203

References _, convert, TEMPLATE_FIELDNAME::GetDefaultFieldName(), SCH_SHEET::GetScreen(), LINE_READER::GetSource(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, LINE_READER::Line(), LINE_READER::LineNumber(), m_rootSheet, EDA_ITEM::m_Uuid, m_version, MANDATORY_FIELDS, MAX_UNIT_COUNT_PER_PACKAGE, Mils2Iu, name, LIB_ID::Parse(), parseChar(), parseHex(), parseInt(), parseQuotedString(), parseUnquotedString(), path, LINE_READER::ReadLine(), REFERENCE_FIELD, SCH_PARSE_ERROR, 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, TEXT_ANGLE_HORIZ, TEXT_ANGLE_VERT, THROW_PARSE_ERROR, TRANSFORM::x1, TRANSFORM::x2, TRANSFORM::y1, and TRANSFORM::y2.

Referenced by LoadContent().

◆ loadText()

SCH_TEXT * SCH_LEGACY_PLUGIN::loadText ( LINE_READER aReader)
private

Definition at line 1417 of file sch_legacy_plugin.cpp.

1418 {
1419  const char* line = aReader.Line();
1420 
1421  wxCHECK( strCompare( "Text", line, &line ), nullptr );
1422 
1423  std::unique_ptr<SCH_TEXT> text;
1424 
1425  if( strCompare( "Notes", line, &line ) )
1426  text.reset( new SCH_TEXT );
1427  else if( strCompare( "Label", line, &line ) )
1428  text.reset( new SCH_LABEL );
1429  else if( strCompare( "HLabel", line, &line ) )
1430  text.reset( new SCH_HIERLABEL );
1431  else if( strCompare( "GLabel", line, &line ) )
1432  {
1433  // Prior to version 2, the SCH_GLOBALLABEL object did not exist.
1434  if( m_version == 1 )
1435  text = std::make_unique<SCH_HIERLABEL>();
1436  else
1437  text = std::make_unique<SCH_GLOBALLABEL>();
1438  }
1439  else
1440  SCH_PARSE_ERROR( "unknown Text type", aReader, line );
1441 
1442  // Parse the parameters common to all text objects.
1443  wxPoint position;
1444 
1445  position.x = Mils2Iu( parseInt( aReader, line, &line ) );
1446  position.y = Mils2Iu( parseInt( aReader, line, &line ) );
1447  text->SetPosition( position );
1448 
1449  int spinStyle = parseInt( aReader, line, &line );
1450 
1451  // Sadly we store the orientation of hierarchical and global labels using a different
1452  // int encoding than that for local labels:
1453  // Global Local
1454  // Left justified 0 2
1455  // Up 1 3
1456  // Right justified 2 0
1457  // Down 3 1
1458  // So we must flip it as the enum is setup with the "global" numbering
1459  if( text->Type() != SCH_GLOBAL_LABEL_T && text->Type() != SCH_HIER_LABEL_T )
1460  {
1461  if( spinStyle == 0 )
1462  spinStyle = 2;
1463  else if( spinStyle == 2 )
1464  spinStyle = 0;
1465  }
1466 
1467  text->SetLabelSpinStyle( (LABEL_SPIN_STYLE::SPIN) spinStyle );
1468 
1469  int size = Mils2Iu( parseInt( aReader, line, &line ) );
1470 
1471  text->SetTextSize( wxSize( size, size ) );
1472 
1473  // Parse the global and hierarchical label type.
1474  if( text->Type() == SCH_HIER_LABEL_T || text->Type() == SCH_GLOBAL_LABEL_T )
1475  {
1476  auto resultIt = std::find_if( sheetLabelNames.begin(), sheetLabelNames.end(),
1477  [ &line ]( const auto& it )
1478  {
1479  return strCompare( it.second, line, &line );
1480  } );
1481 
1482  if( resultIt != sheetLabelNames.end() )
1483  text->SetShape( resultIt->first );
1484  else
1485  SCH_PARSE_ERROR( "invalid label type", aReader, line );
1486  }
1487 
1488  int penWidth = 0;
1489 
1490  // The following tokens do not exist in version 1 schematic files,
1491  // and not always in version 2 for HLabels and GLabels
1492  if( m_version > 1 )
1493  {
1494  if( m_version > 2 || *line >= ' ' )
1495  {
1496  if( strCompare( "Italic", line, &line ) )
1497  text->SetItalic( true );
1498  else if( !strCompare( "~", line, &line ) )
1499  SCH_PARSE_ERROR( _( "expected 'Italics' or '~'" ), aReader, line );
1500  }
1501 
1502  // The penWidth token does not exist in older versions of the schematic file format
1503  // so calling parseInt will be made only if the EOL is not reached.
1504  if( *line >= ' ' )
1505  penWidth = parseInt( aReader, line, &line );
1506  }
1507 
1508  text->SetBold( penWidth != 0 );
1509  text->SetTextThickness( penWidth != 0 ? GetPenSizeForBold( size ) : 0 );
1510 
1511  // Read the text string for the text.
1512  char* tmp = aReader.ReadLine();
1513 
1514  tmp = strtok( tmp, "\r\n" );
1515  wxString val = FROM_UTF8( tmp );
1516 
1517  for( ; ; )
1518  {
1519  int i = val.find( wxT( "\\n" ) );
1520 
1521  if( i == wxNOT_FOUND )
1522  break;
1523 
1524  val.erase( i, 2 );
1525  val.insert( i, wxT( "\n" ) );
1526  }
1527 
1528  text->SetText( ConvertToNewOverbarNotation( val ) );
1529 
1530  return text.release();
1531 }
wxString ConvertToNewOverbarNotation(const wxString &aOldStr)
Convert the old ~...~ overbar notation to the new ~{...} one.
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static wxString FROM_UTF8(const char *cstring)
Convert a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:110
int GetPenSizeForBold(int aTextSize)
Definition: gr_text.cpp:46
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
#define Mils2Iu(x)
int m_version
Version of file being loaded.
#define _(s)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
const std::map< PINSHEETLABEL_SHAPE, const char * > sheetLabelNames

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

Referenced by LoadContent().

◆ loadWire()

SCH_LINE * SCH_LEGACY_PLUGIN::loadWire ( LINE_READER aReader)
private

Definition at line 1263 of file sch_legacy_plugin.cpp.

1264 {
1265  std::unique_ptr<SCH_LINE> wire = std::make_unique<SCH_LINE>();
1266 
1267  const char* line = aReader.Line();
1268 
1269  wxCHECK( strCompare( "Wire", line, &line ), nullptr );
1270 
1271  if( strCompare( "Wire", line, &line ) )
1272  wire->SetLayer( LAYER_WIRE );
1273  else if( strCompare( "Bus", line, &line ) )
1274  wire->SetLayer( LAYER_BUS );
1275  else if( strCompare( "Notes", line, &line ) )
1276  wire->SetLayer( LAYER_NOTES );
1277  else
1278  SCH_PARSE_ERROR( "invalid line type", aReader, line );
1279 
1280  if( !strCompare( "Line", line, &line ) )
1281  SCH_PARSE_ERROR( "invalid wire definition", aReader, line );
1282 
1283  // Since Sept 15, 2017, a line style is alloved (width, style, color)
1284  // Only non default values are stored
1285  while( !is_eol( *line ) )
1286  {
1287  wxString buf;
1288 
1289  parseUnquotedString( buf, aReader, line, &line );
1290 
1291  if( buf == ")" )
1292  continue;
1293 
1294  else if( buf == T_WIDTH )
1295  {
1296  int size = Mils2Iu( parseInt( aReader, line, &line ) );
1297  wire->SetLineWidth( size );
1298  }
1299  else if( buf == T_STYLE )
1300  {
1301  parseUnquotedString( buf, aReader, line, &line );
1303  wire->SetLineStyle( style );
1304  }
1305  else // should be the color parameter.
1306  {
1307  // The color param is something like rgb(150, 40, 191)
1308  // and because there is no space between ( and 150
1309  // the first param is inside buf.
1310  // So break keyword and the first param into 2 separate strings.
1311  wxString prm, keyword;
1312  keyword = buf.BeforeLast( '(', &prm );
1313 
1314  if( ( keyword == T_COLOR ) || ( keyword == T_COLORA ) )
1315  {
1316  long color[4] = { 0 };
1317 
1318  int ii = 0;
1319 
1320  if( !prm.IsEmpty() )
1321  {
1322  prm.ToLong( &color[ii] );
1323  ii++;
1324  }
1325 
1326  int prm_count = ( keyword == T_COLORA ) ? 4 : 3;
1327  // fix opacity to 1.0 or 255, when not exists in file
1328  color[3] = 255;
1329 
1330  for(; ii < prm_count && !is_eol( *line ); ii++ )
1331  {
1332  color[ii] = parseInt( aReader, line, &line );
1333 
1334  // Skip the separator between values
1335  if( *line == ',' || *line == ' ')
1336  line++;
1337  }
1338 
1339  wire->SetLineColor( color[0]/255.0, color[1]/255.0, color[2]/255.0,color[3]/255.0 );
1340  }
1341  }
1342  }
1343 
1344  // Read the segment en points coordinates:
1345  line = aReader.ReadLine();
1346 
1347  wxPoint begin, end;
1348 
1349  begin.x = Mils2Iu( parseInt( aReader, line, &line ) );
1350  begin.y = Mils2Iu( parseInt( aReader, line, &line ) );
1351  end.x = Mils2Iu( parseInt( aReader, line, &line ) );
1352  end.y = Mils2Iu( parseInt( aReader, line, &line ) );
1353 
1354  wire->SetStartPoint( begin );
1355  wire->SetEndPoint( end );
1356 
1357  return wire.release();
1358 }
char * Line() const
Return a pointer to the last line that was read in.
Definition: richio.h:117
static bool strCompare(const char *aString, const char *aLine, const char **aOutput=nullptr)
Compare aString to the string starting at aLine and advances the character point to the end of String...
static void parseUnquotedString(wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=nullptr, bool aCanBeEmpty=false)
Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.
int color
Definition: DXF_plotter.cpp:57
#define Mils2Iu(x)
#define T_WIDTH
#define T_STYLE
static bool is_eol(char c)
static int parseInt(LINE_READER &aReader, const char *aLine, const char **aOutput=nullptr)
Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointe...
#define T_COLOR
static PLOT_DASH_TYPE GetLineStyleByName(const wxString &aStyleName)
Definition: sch_line.cpp:115
PLOT_DASH_TYPE
Dashed line types.
Definition: plotter.h:104
virtual char * ReadLine()=0
Read a line of text into the buffer and increments the line number counter.
#define SCH_PARSE_ERROR(text, reader, pos)
#define T_COLORA

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

Referenced by LoadContent().

◆ ParsePart()

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

Definition at line 4542 of file sch_legacy_plugin.cpp.

4544 {
4545  return SCH_LEGACY_PLUGIN_CACHE::LoadPart( reader, aMajorVersion, aMinorVersion );
4546 }
static LIB_SYMBOL * LoadPart(LINE_READER &aReader, int aMajorVersion, int aMinorVersion, LIB_SYMBOL_MAP *aMap=nullptr)

References SCH_LEGACY_PLUGIN_CACHE::LoadPart().

◆ Save()

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

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

Parameters
aFileNameis the name of a file to save to on disk.
aSheetis 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.
aSchematicis the SCHEMATIC object used to access any schematic-wide or project information needed to save the document.
aPropertiesis 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_ERRORif there is a problem saving or exporting.

Reimplemented from SCH_PLUGIN.

Definition at line 1877 of file sch_legacy_plugin.cpp.

1879 {
1880  wxCHECK_RET( aSheet != nullptr, "NULL SCH_SHEET object." );
1881  wxCHECK_RET( !aFileName.IsEmpty(), "No schematic file name defined." );
1882 
1883  LOCALE_IO toggle; // toggles on, then off, the C locale, to write floating point values.
1884 
1885  init( aSchematic, aProperties );
1886 
1887  wxFileName fn = aFileName;
1888 
1889  // File names should be absolute. Don't assume everything relative to the project path
1890  // works properly.
1891  wxASSERT( fn.IsAbsolute() );
1892 
1893  FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
1894 
1895  m_out = &formatter; // no ownership
1896 
1897  Format( aSheet );
1898 
1899  aSheet->GetScreen()->SetFileExists( true );
1900 }
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
void init(SCHEMATIC *aSchematic, const PROPERTIES *aProperties=nullptr)
initialize PLUGIN like a constructor would.
void SetFileExists(bool aFileExists)
Definition: sch_screen.h:150
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:102
void Format(SCH_SHEET *aSheet)
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
Used for text file output.
Definition: richio.h:456

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

2190 {
2191  wxCHECK_RET( aBitmap != nullptr, "SCH_BITMAP* is NULL" );
2192 
2193  const wxImage* image = aBitmap->GetImage()->GetImageData();
2194 
2195  wxCHECK_RET( image != nullptr, "wxImage* is NULL" );
2196 
2197  m_out->Print( 0, "$Bitmap\n" );
2198  m_out->Print( 0, "Pos %-4d %-4d\n",
2199  Iu2Mils( aBitmap->GetPosition().x ),
2200  Iu2Mils( aBitmap->GetPosition().y ) );
2201  m_out->Print( 0, "Scale %f\n", aBitmap->GetImage()->GetScale() );
2202  m_out->Print( 0, "Data\n" );
2203 
2204  wxMemoryOutputStream stream;
2205 
2206  image->SaveFile( stream, wxBITMAP_TYPE_PNG );
2207 
2208  // Write binary data in hexadecimal form (ASCII)
2209  wxStreamBuffer* buffer = stream.GetOutputStreamBuffer();
2210  char* begin = (char*) buffer->GetBufferStart();
2211 
2212  for( int ii = 0; begin < buffer->GetBufferEnd(); begin++, ii++ )
2213  {
2214  if( ii >= 32 )
2215  {
2216  ii = 0;
2217 
2218  m_out->Print( 0, "\n" );
2219  }
2220 
2221  m_out->Print( 0, "%2.2X ", *begin & 0xFF );
2222  }
2223 
2224  m_out->Print( 0, "\nEndData\n" );
2225  m_out->Print( 0, "$EndBitmap\n" );
2226 }
double GetScale() const
Definition: bitmap_base.h:79
wxImage * GetImageData()
Definition: bitmap_base.h:70
wxPoint GetPosition() const override
Definition: sch_bitmap.h:136
BITMAP_BASE * GetImage() const
Definition: sch_bitmap.h:54
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426

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

Referenced by Format().

◆ saveBusAlias()

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

Definition at line 2442 of file sch_legacy_plugin.cpp.

2443 {
2444  wxCHECK_RET( aAlias != nullptr, "BUS_ALIAS* is NULL" );
2445 
2446  wxString members = boost::algorithm::join( aAlias->Members(), " " );
2447 
2448  m_out->Print( 0, "BusAlias %s %s\n",
2449  TO_UTF8( aAlias->GetName() ), TO_UTF8( members ) );
2450 }
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426

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

2314 {
2315  wxCHECK_RET( aBusEntry != nullptr, "SCH_BUS_ENTRY_BASE* is NULL" );
2316 
2317  if( aBusEntry->GetLayer() == LAYER_WIRE )
2318  m_out->Print( 0, "Entry Wire Line\n\t%-4d %-4d %-4d %-4d\n",
2319  Iu2Mils( aBusEntry->GetPosition().x ),
2320  Iu2Mils( aBusEntry->GetPosition().y ),
2321  Iu2Mils( aBusEntry->GetEnd().x ), Iu2Mils( aBusEntry->GetEnd().y ) );
2322  else
2323  m_out->Print( 0, "Entry Bus Bus\n\t%-4d %-4d %-4d %-4d\n",
2324  Iu2Mils( aBusEntry->GetPosition().x ),
2325  Iu2Mils( aBusEntry->GetPosition().y ),
2326  Iu2Mils( aBusEntry->GetEnd().x ), Iu2Mils( aBusEntry->GetEnd().y ) );
2327 }
SCH_LAYER_ID GetLayer() const
Return the layer this item is on.
Definition: sch_item.h:259
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
wxPoint GetEnd() const
wxPoint GetPosition() const override

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

Referenced by Format().

◆ saveField()

void SCH_LEGACY_PLUGIN::saveField ( SCH_FIELD aField)
private

Definition at line 2153 of file sch_legacy_plugin.cpp.

2154 {
2155  char hjustify = 'C';
2156 
2157  if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_LEFT )
2158  hjustify = 'L';
2159  else if( aField->GetHorizJustify() == GR_TEXT_HJUSTIFY_RIGHT )
2160  hjustify = 'R';
2161 
2162  char vjustify = 'C';
2163 
2164  if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_BOTTOM )
2165  vjustify = 'B';
2166  else if( aField->GetVertJustify() == GR_TEXT_VJUSTIFY_TOP )
2167  vjustify = 'T';
2168 
2169  m_out->Print( 0, "F %d %s %c %-3d %-3d %-3d %4.4X %c %c%c%c",
2170  aField->GetId(),
2171  EscapedUTF8( aField->GetText() ).c_str(), // wraps in quotes too
2172  aField->GetTextAngle() == TEXT_ANGLE_HORIZ ? 'H' : 'V',
2173  Iu2Mils( aField->GetLibPosition().x ),
2174  Iu2Mils( aField->GetLibPosition().y ),
2175  Iu2Mils( aField->GetTextWidth() ),
2176  !aField->IsVisible(),
2177  hjustify, vjustify,
2178  aField->IsItalic() ? 'I' : 'N',
2179  aField->IsBold() ? 'B' : 'N' );
2180 
2181  // Save field name, if the name is user definable
2182  if( aField->GetId() >= MANDATORY_FIELDS )
2183  m_out->Print( 0, " %s", EscapedUTF8( aField->GetName() ).c_str() );
2184 
2185  m_out->Print( 0, "\n" );
2186 }
#define TEXT_ANGLE_HORIZ
Frequent text rotations, used with {Set,Get}TextAngle(), in 0.1 degrees for now, hoping to migrate to...
Definition: eda_text.h:71
bool IsBold() const
Definition: eda_text.h:204
EDA_TEXT_VJUSTIFY_T GetVertJustify() const
Definition: eda_text.h:220
double GetTextAngle() const
Definition: eda_text.h:195
int GetId() const
Definition: sch_field.h:113
bool IsItalic() const
Definition: eda_text.h:201
EDA_TEXT_HJUSTIFY_T GetHorizJustify() const
Definition: eda_text.h:219
virtual bool IsVisible() const
Definition: eda_text.h:207
wxPoint GetLibPosition() const
Definition: sch_field.h:199
The first 4 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
int GetTextWidth() const
Definition: eda_text.h:262
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
wxString GetName(bool aUseDefaultName=true) const
Return the field name.
Definition: sch_field.cpp:678
std::string EscapedUTF8(const wxString &aString)
Return an 8 bit UTF8 string given aString in Unicode form.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:154

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

Referenced by saveSymbol().

◆ saveJunction()

void SCH_LEGACY_PLUGIN::saveJunction ( SCH_JUNCTION aJunction)
private

Definition at line 2293 of file sch_legacy_plugin.cpp.

2294 {
2295  wxCHECK_RET( aJunction != nullptr, "SCH_JUNCTION* is NULL" );
2296 
2297  m_out->Print( 0, "Connection ~ %-4d %-4d\n",
2298  Iu2Mils( aJunction->GetPosition().x ),
2299  Iu2Mils( aJunction->GetPosition().y ) );
2300 }
wxPoint GetPosition() const override
Definition: sch_junction.h:103
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426

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

Referenced by Format().

◆ SaveLibrary()

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

Reimplemented from SCH_PLUGIN.

Definition at line 4501 of file sch_legacy_plugin.cpp.

4502 {
4503  if( !m_cache )
4504  m_cache = new SCH_LEGACY_PLUGIN_CACHE( aLibraryPath );
4505 
4506  wxString oldFileName = m_cache->GetFileName();
4507 
4508  if( !m_cache->IsFile( aLibraryPath ) )
4509  {
4510  m_cache->SetFileName( aLibraryPath );
4511  }
4512 
4513  // This is a forced save.
4514  m_cache->SetModified();
4515  m_cache->Save( writeDocFile( aProperties ) );
4516  m_cache->SetFileName( oldFileName );
4517 }
SCH_LEGACY_PLUGIN_CACHE * m_cache
A cache assistant for the symbol library portion of the SCH_PLUGIN API, and only for the SCH_LEGACY_P...
void SetModified(bool aModified=true)
void SetFileName(const wxString &aFileName)
bool IsFile(const wxString &aFullPathAndFileName) const
void Save(bool aSaveDocFile=true)
Save the entire library to file m_libFileName;.
bool writeDocFile(const PROPERTIES *aProperties)

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

◆ saveLine()

void SCH_LEGACY_PLUGIN::saveLine ( SCH_LINE aLine)
private

Definition at line 2330 of file sch_legacy_plugin.cpp.

2331 {
2332  wxCHECK_RET( aLine != nullptr, "SCH_LINE* is NULL" );
2333 
2334  const char* layer = "Notes";
2335  const char* width = "Line";
2336 
2337  if( aLine->GetLayer() == LAYER_WIRE )
2338  layer = "Wire";
2339  else if( aLine->GetLayer() == LAYER_BUS )
2340  layer = "Bus";
2341 
2342  m_out->Print( 0, "Wire %s %s", layer, width );
2343 
2344  // Write line style (width, type, color) only for non default values
2345  if( aLine->IsGraphicLine() )
2346  {
2347  if( aLine->GetLineSize() != 0 )
2348  m_out->Print( 0, " %s %d", T_WIDTH, Iu2Mils( aLine->GetLineSize() ) );
2349 
2350  if( aLine->GetLineStyle() != aLine->GetDefaultStyle() )
2351  m_out->Print( 0, " %s %s", T_STYLE,
2353 
2354  if( aLine->GetLineColor() != COLOR4D::UNSPECIFIED )
2355  m_out->Print( 0, " %s",
2356  TO_UTF8( aLine->GetLineColor().ToColour().GetAsString( wxC2S_CSS_SYNTAX ) ) );
2357  }
2358 
2359  m_out->Print( 0, "\n" );
2360 
2361  m_out->Print( 0, "\t%-4d %-4d %-4d %-4d",
2362  Iu2Mils( aLine->GetStartPoint().x ), Iu2Mils( aLine->GetStartPoint().y ),
2363  Iu2Mils( aLine->GetEndPoint().x ), Iu2Mils( aLine->GetEndPoint().y ) );
2364 
2365  m_out->Print( 0, "\n");
2366 }
static const char * GetLineStyleName(PLOT_DASH_TYPE aStyle)
Definition: sch_line.cpp:105
COLOR4D GetLineColor() const
Returns COLOR4D::UNSPECIFIED if a custom color hasn't been set for this line.
Definition: sch_line.cpp:236
bool IsGraphicLine() const
Return if the line is a graphic (non electrical line)
Definition: sch_line.cpp:966
wxPoint GetStartPoint() const
Definition: sch_line.h:90
#define T_WIDTH
#define T_STYLE
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
PLOT_DASH_TYPE GetDefaultStyle() const
Definition: sch_line.cpp:254
PLOT_DASH_TYPE GetLineStyle() const
Definition: sch_line.cpp:278
SCH_LAYER_ID GetLayer() const
Return the layer this item is on.
Definition: sch_item.h:259
int GetLineSize() const
Definition: sch_line.h:164
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
wxPoint GetEndPoint() const
Definition: sch_line.h:93

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

Referenced by Format().

◆ saveNoConnect()

void SCH_LEGACY_PLUGIN::saveNoConnect ( SCH_NO_CONNECT aNoConnect)
private

Definition at line 2303 of file sch_legacy_plugin.cpp.

2304 {
2305  wxCHECK_RET( aNoConnect != nullptr, "SCH_NOCONNECT* is NULL" );
2306 
2307  m_out->Print( 0, "NoConn ~ %-4d %-4d\n",
2308  Iu2Mils( aNoConnect->GetPosition().x ),
2309  Iu2Mils( aNoConnect->GetPosition().y ) );
2310 }
wxPoint GetPosition() const override
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426

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

Referenced by Format().

◆ saveSheet()

void SCH_LEGACY_PLUGIN::saveSheet ( SCH_SHEET aSheet)
private

Definition at line 2229 of file sch_legacy_plugin.cpp.

2230 {
2231  wxCHECK_RET( aSheet != nullptr, "SCH_SHEET* is NULL" );
2232 
2233  m_out->Print( 0, "$Sheet\n" );
2234  m_out->Print( 0, "S %-4d %-4d %-4d %-4d\n",
2235  Iu2Mils( aSheet->GetPosition().x ),
2236  Iu2Mils( aSheet->GetPosition().y ),
2237  Iu2Mils( aSheet->GetSize().x ),
2238  Iu2Mils( aSheet->GetSize().y ) );
2239 
2240  m_out->Print( 0, "U %8.8X\n", aSheet->m_Uuid.AsLegacyTimestamp() );
2241 
2242  SCH_FIELD& sheetName = aSheet->GetFields()[SHEETNAME];
2243  SCH_FIELD& fileName = aSheet->GetFields()[SHEETFILENAME];
2244 
2245  if( !sheetName.GetText().IsEmpty() )
2246  m_out->Print( 0, "F0 %s %d\n",
2247  EscapedUTF8( sheetName.GetText() ).c_str(),
2248  Iu2Mils( sheetName.GetTextSize().x ) );
2249 
2250  if( !fileName.GetText().IsEmpty() )
2251  m_out->Print( 0, "F1 %s %d\n",
2252  EscapedUTF8( fileName.GetText() ).c_str(),
2253  Iu2Mils( fileName.GetTextSize().x ) );
2254 
2255  for( const SCH_SHEET_PIN* pin : aSheet->GetPins() )
2256  {
2257  int type, side;
2258 
2259  if( pin->GetText().IsEmpty() )
2260  break;
2261 
2262  switch( pin->GetSide() )
2263  {
2264  default:
2265  case SHEET_SIDE::LEFT: side = 'L'; break;
2266  case SHEET_SIDE::RIGHT: side = 'R'; break;
2267  case SHEET_SIDE::TOP: side = 'T'; break;
2268  case SHEET_SIDE::BOTTOM: side = 'B'; break;
2269  }
2270 
2271  switch( pin->GetShape() )
2272  {
2273  default:
2274  case PINSHEETLABEL_SHAPE::PS_UNSPECIFIED: type = 'U'; break;
2275  case PINSHEETLABEL_SHAPE::PS_INPUT: type = 'I'; break;
2276  case PINSHEETLABEL_SHAPE::PS_OUTPUT: type = 'O'; break;
2277  case PINSHEETLABEL_SHAPE::PS_BIDI: type = 'B'; break;
2278  case PINSHEETLABEL_SHAPE::PS_TRISTATE: type = 'T'; break;
2279  }
2280 
2281  m_out->Print( 0, "F%d %s %c %c %-3d %-3d %-3d\n",
2282  pin->GetNumber(),
2283  EscapedUTF8( pin->GetText() ).c_str(), // supplies wrapping quotes
2284  type, side, Iu2Mils( pin->GetPosition().x ),
2285  Iu2Mils( pin->GetPosition().y ),
2286  Iu2Mils( pin->GetTextWidth() ) );
2287  }
2288 
2289  m_out->Print( 0, "$EndSheet\n" );
2290 }
Instances are attached to a symbol or sheet and provide a place for the symbol's value,...
Definition: sch_field.h:49
std::vector< SCH_FIELD > & GetFields()
Definition: sch_sheet.h:90
timestamp_t AsLegacyTimestamp() const
Definition: kiid.cpp:209
const wxSize & GetTextSize() const
Definition: eda_text.h:259
Define a sheet pin (label) used in sheets to create hierarchical schematics.
Definition: sch_sheet_pin.h:65
wxPoint GetPosition() const override
Definition: sch_sheet.h:379
const KIID m_Uuid
Definition: eda_item.h:474
std::vector< SCH_SHEET_PIN * > & GetPins()
Definition: sch_sheet.h:183
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
wxSize GetSize() const
Definition: sch_sheet.h:104
std::string EscapedUTF8(const wxString &aString)
Return an 8 bit UTF8 string given aString in Unicode form.
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:154

References KIID::AsLegacyTimestamp(), BOTTOM, EscapedUTF8(), SCH_SHEET::GetFields(), SCH_SHEET::GetPins(), SCH_SHEET::GetPosition(), SCH_SHEET::GetSize(), EDA_TEXT::GetText(), EDA_TEXT::GetTextSize(), LEFT, m_out, EDA_ITEM::m_Uuid, pin, OUTPUTFORMATTER::Print(), PS_BIDI, PS_INPUT, PS_OUTPUT, PS_TRISTATE, PS_UNSPECIFIED, RIGHT, SHEETFILENAME, SHEETNAME, and TOP.

Referenced by Format().

◆ SaveSymbol()

void SCH_LEGACY_PLUGIN::SaveSymbol ( const wxString &  aLibraryPath,
const LIB_SYMBOL aSymbol,
const PROPERTIES 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
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several symbols.
aSymbolis what to store in the library. The library is refreshed and the caller must update any LIB_SYMBOL pointers that may have changed.
aPropertiesis 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_ERRORif there is a problem saving.

Reimplemented from SCH_PLUGIN.

Definition at line 4428 of file sch_legacy_plugin.cpp.

4430 {
4431  LOCALE_IO toggle; // toggles on, then off, the C locale.
4432 
4433  cacheLib( aLibraryPath, aProperties );
4434 
4435  m_cache->AddSymbol( aSymbol );
4436 
4437  if( !isBuffering( aProperties ) )
4438  m_cache->Save( writeDocFile( aProperties ) );
4439 }
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: locale_io.h:40
SCH_LEGACY_PLUGIN_CACHE * m_cache
void AddSymbol(const LIB_SYMBOL *aSymbol)
bool isBuffering(const PROPERTIES *aProperties)
void cacheLib(const wxString &aLibraryFileName, const PROPERTIES *aProperties)
void Save(bool aSaveDocFile=true)
Save the entire library to file m_libFileName;.
bool writeDocFile(const PROPERTIES *aProperties)

References SCH_LEGACY_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 2047 of file sch_legacy_plugin.cpp.

2048 {
2049  std::string name1;
2050  std::string name2;
2051 
2052  static wxString delimiters( wxT( " " ) );
2053 
2054  // This is redundant with the AR entries below, but it makes the files backwards-compatible.
2055  if( aSymbol->GetInstanceReferences().size() > 0 )
2056  {
2057  const SYMBOL_INSTANCE_REFERENCE& instance = aSymbol->GetInstanceReferences()[0];
2058  name1 = toUTFTildaText( instance.m_Reference );
2059  }
2060  else
2061  {
2062  if( aSymbol->GetField( REFERENCE_FIELD )->GetText().IsEmpty() )
2063  name1 = toUTFTildaText( aSymbol->GetPrefix() );
2064  else
2065  name1 = toUTFTildaText( aSymbol->GetField( REFERENCE_FIELD )->GetText() );
2066  }
2067 
2068  wxString symbol_name = aSymbol->GetLibId().Format();
2069 
2070  if( symbol_name.size() )
2071  {
2072  name2 = toUTFTildaText( symbol_name );
2073  }
2074  else
2075  {
2076  name2 = "_NONAME_";
2077  }
2078 
2079  m_out->Print( 0, "$Comp\n" );
2080  m_out->Print( 0, "L %s %s\n", name2.c_str(), name1.c_str() );
2081 
2082  // Generate unit number, conversion and timestamp
2083  m_out->Print( 0, "U %d %d %8.8X\n",
2084  aSymbol->GetUnit(),
2085  aSymbol->GetConvert(),
2086  aSymbol->m_Uuid.AsLegacyTimestamp() );
2087 
2088  // Save the position
2089  m_out->Print( 0, "P %d %d\n",
2090  Iu2Mils( aSymbol->GetPosition().x ),
2091  Iu2Mils( aSymbol->GetPosition().y ) );
2092 
2093  /* If this is a complex hierarchy; save hierarchical references.
2094  * but for simple hierarchies it is not necessary.
2095  * the reference inf is already saved
2096  * this is useful for old Eeschema version compatibility
2097  */
2098  if( aSymbol->GetInstanceReferences().size() > 1 )
2099  {
2100  for( const SYMBOL_INSTANCE_REFERENCE& instance : aSymbol->GetInstanceReferences() )
2101  {
2102  /*format:
2103  * AR Path="/140/2" Ref="C99" Part="1"
2104  * where 140 is the uid of the containing sheet and 2 is the timestamp of this symbol.
2105  * (timestamps are actually 8 hex chars)
2106  * Ref is the conventional symbol reference designator for this 'path'
2107  * Part is the conventional symbol unit selection for this 'path'
2108  */
2109  wxString path = "/";
2110 
2111  // Skip root sheet
2112  for( int i = 1; i < (int) instance.m_Path.size(); ++i )
2113  path += instance.m_Path[i].AsLegacyTimestampString() + "/";
2114 
2115  m_out->Print( 0, "AR Path=\"%s\" Ref=\"%s\" Part=\"%d\" \n",
2116  TO_UTF8( path + aSymbol->m_Uuid.AsLegacyTimestampString() ),
2117  TO_UTF8( instance.m_Reference ),
2118  instance.m_Unit );
2119  }
2120  }
2121 
2122  // update the ugly field id, which I would like to see go away someday soon.
2123  for( int i = 0; i < aSymbol->GetFieldCount(); ++i )
2124  aSymbol->GetFields()[i].SetId( i );
2125 
2126  // Fixed fields:
2127  // Save mandatory fields even if they are blank,
2128  // because the visibility, size and orientation are set from library editor.
2129  for( unsigned i = 0; i < MANDATORY_FIELDS; ++i )
2130  saveField( &aSymbol->GetFields()[i] );
2131 
2132  // User defined fields:
2133  // The *policy* about which user defined fields are symbol of a symbol is now
2134  // only in the dialog editors. No policy should be enforced here, simply
2135  // save all the user defined fields, they are present because a dialog editor
2136  // thought they should be. If you disagree, go fix the dialog editors.
2137  for( int i = MANDATORY_FIELDS; i < aSymbol->GetFieldCount(); ++i )
2138  saveField( &aSymbol->GetFields()[i] );
2139 
2140  // Unit number, position, box ( old standard )
2141  m_out->Print( 0, "\t%-4d %-4d %-4d\n", aSymbol->GetUnit(),
2142  Iu2Mils( aSymbol->GetPosition().x ),
2143  Iu2Mils( aSymbol->GetPosition().y ) );
2144 
2145  TRANSFORM transform = aSymbol->GetTransform();
2146 
2147  m_out->Print( 0, "\t%-4d %-4d %-4d %-4d\n",
2148  transform.x1, transform.y1, transform.x2, transform.y2 );
2149  m_out->Print( 0, "$EndComp\n" );
2150 }
Field Reference of part, i.e. "IC21".
int y2
Definition: transform.h:51
SCH_FIELD * GetField(MANDATORY_FIELD_T aFieldType)
Return a mandatory field in this symbol.
Definition: sch_symbol.cpp:705
void GetFields(std::vector< SCH_FIELD * > &aVector, bool aVisibleOnly)
Populate a std::vector with SCH_FIELDs.
Definition: sch_symbol.cpp:741
int x2
Definition: transform.h:50
int x1
Definition: transform.h:48
std::string toUTFTildaText(const wxString &txt)
Convert a wxString to UTF8 and replace any control characters with a ~, where a control character is ...
Definition: sch_symbol.cpp:46
TRANSFORM & GetTransform()
Definition: sch_symbol.h:232
void saveField(SCH_FIELD *aField)
const std::vector< SYMBOL_INSTANCE_REFERENCE > & GetInstanceReferences()
Definition: sch_symbol.h:123
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
int y1
Definition: transform.h:49
for transforming drawing coordinates for a wxDC device context.
Definition: transform.h:45
timestamp_t AsLegacyTimestamp() const
Definition: kiid.cpp:209
int GetFieldCount() const
Return the number of fields in this symbol.
Definition: sch_symbol.h:425
A simple container for schematic symbol instance information.
UTF8 Format() const
Definition: lib_id.cpp:116
const KIID m_Uuid
Definition: eda_item.h:474
The first 4 are mandatory, and must be instantiated in SCH_COMPONENT and LIB_PART constructors.
wxString AsLegacyTimestampString() const
Definition: kiid.cpp:242
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
wxString GetPrefix() const
Definition: sch_symbol.h:228
wxPoint GetPosition() const override
Definition: sch_symbol.h:645
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
int GetUnit() const
Definition: sch_symbol.h:196
int GetConvert() const
Definition: sch_symbol.h:224
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:154
const LIB_ID & GetLibId() const
Definition: sch_symbol.h:148

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(), m_out, SYMBOL_INSTANCE_REFERENCE::m_Reference, EDA_ITEM::m_Uuid, MANDATORY_FIELDS, path, OUTPUTFORMATTER::Print(), REFERENCE_FIELD, saveField(), TO_UTF8, toUTFTildaText(), TRANSFORM::x1, TRANSFORM::x2, TRANSFORM::y1, and TRANSFORM::y2.

Referenced by Format().

◆ saveText()

void SCH_LEGACY_PLUGIN::saveText ( SCH_TEXT aText)
private

Definition at line 2369 of file sch_legacy_plugin.cpp.

2370 {
2371  wxCHECK_RET( aText != nullptr, "SCH_TEXT* is NULL" );
2372 
2373  const char* italics = "~";
2374  const char* textType = "Notes";
2375 
2376  if( aText->IsItalic() )
2377  italics = "Italic";
2378 
2379  wxString text = aText->GetText();
2380 
2381  SCH_LAYER_ID layer = aText->GetLayer();
2382 
2383  if( layer == LAYER_NOTES || layer == LAYER_LOCLABEL )
2384  {
2385  if( layer == LAYER_NOTES )
2386  {
2387  // For compatibility reasons, the text must be saved in only one text line
2388  // so replace all EOLs with \\n
2389  text.Replace( wxT( "\n" ), wxT( "\\n" ) );
2390 
2391  // Here we should have no CR or LF character in line
2392  // This is not always the case if a multiline text was copied (using a copy/paste
2393  // function) from a text that uses E.O.L characters that differs from the current
2394  // EOL format. This is mainly the case under Linux using LF symbol when copying
2395  // a text from Windows (using CRLF symbol) so we must just remove the extra CR left
2396  // (or LF left under MacOSX)
2397  for( unsigned ii = 0; ii < text.Len(); )
2398  {
2399  if( text[ii] == 0x0A || text[ii] == 0x0D )
2400  text.erase( ii, 1 );
2401  else
2402  ii++;
2403  }
2404  }
2405  else
2406  {
2407  textType = "Label";
2408  }
2409 
2410  // Local labels must have their spin style inverted for left and right
2411  int spinStyle = static_cast<int>( aText->GetLabelSpinStyle() );
2412 
2413  if( spinStyle == 0 )
2414  spinStyle = 2;
2415  else if( spinStyle == 2 )
2416  spinStyle = 0;
2417 
2418  m_out->Print( 0, "Text %s %-4d %-4d %-4d %-4d %s %d\n%s\n", textType,
2419  Iu2Mils( aText->GetPosition().x ), Iu2Mils( aText->GetPosition().y ),
2420  spinStyle,
2421  Iu2Mils( aText->GetTextWidth() ),
2422  italics, Iu2Mils( aText->GetTextThickness() ), TO_UTF8( text ) );
2423  }
2424  else if( layer == LAYER_GLOBLABEL || layer == LAYER_HIERLABEL )
2425  {
2426  textType = ( layer == LAYER_GLOBLABEL ) ? "GLabel" : "HLabel";
2427 
2428  auto shapeLabelIt = sheetLabelNames.find( aText->GetShape() );
2429  wxCHECK_RET( shapeLabelIt != sheetLabelNames.end(), "Shape not found in names list" );
2430 
2431  m_out->Print( 0, "Text %s %-4d %-4d %-4d %-4d %s %s %d\n%s\n", textType,
2432  Iu2Mils( aText->GetPosition().x ), Iu2Mils( aText->GetPosition().y ),
2433  static_cast<int>( aText->GetLabelSpinStyle() ),
2434  Iu2Mils( aText->GetTextWidth() ),
2435  shapeLabelIt->second,
2436  italics,
2437  Iu2Mils( aText->GetTextThickness() ), TO_UTF8( text ) );
2438  }
2439 }
int GetTextThickness() const
Definition: eda_text.h:181
bool IsItalic() const
Definition: eda_text.h:201
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:96
SCH_LAYER_ID
Eeschema drawing layers.
Definition: layer_ids.h:335
LABEL_SPIN_STYLE GetLabelSpinStyle() const
Definition: sch_text.h:159
wxPoint GetPosition() const override
Definition: sch_text.h:241
SCH_LAYER_ID GetLayer() const
Return the layer this item is on.
Definition: sch_item.h:259
int GetTextWidth() const
Definition: eda_text.h:262
OUTPUTFORMATTER * m_out
The formatter for saving SCH_SCREEN objects.
const std::map< PINSHEETLABEL_SHAPE, const char * > sheetLabelNames
int PRINTF_FUNC Print(int nestLevel, const char *fmt,...)
Format and write text to the output stream.
Definition: richio.cpp:426
virtual const wxString & GetText() const
Return the string associated with the text object.
Definition: eda_text.h:154
PINSHEETLABEL_SHAPE GetShape() const
Definition: sch_text.h:161

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

Referenced by Format().

◆ 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.

86  {
87  m_progressReporter = aReporter;
88  }
PROGRESS_REPORTER * m_progressReporter
optional; may be nullptr

References m_progressReporter.

◆ SetReporter()

virtual void SCH_PLUGIN::SetReporter ( REPORTER aReporter)
inlinevirtualinherited

Set an optional reporter for warnings/errors.

Reimplemented in SCH_EAGLE_PLUGIN, SCH_ALTIUM_PLUGIN, and CADSTAR_SCH_ARCHIVE_PLUGIN.

Definition at line 166 of file sch_io_mgr.h.

166 {}

◆ SymbolLibOptions()

void SCH_PLUGIN::SymbolLibOptions ( PROPERTIES aListToAppendTo) const
virtualinherited

Append supported SCH_PLUGIN options to aListToAppenTo along with internationalized descriptions.

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

Parameters
aListToAppendToholds 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.

134 {
135  // disable all these in another couple of months, after everyone has seen them:
136 #if 1
137  (*aListToAppendTo)["debug_level"] = UTF8( _(
138  "Enable <b>debug</b> logging for Symbol*() functions in this SCH_PLUGIN."
139  ) );
140 
141  (*aListToAppendTo)["read_filter_regex"] = UTF8( _(
142  "Regular expression <b>symbol name</b> filter."
143  ) );
144 
145  (*aListToAppendTo)["enable_transaction_logging"] = UTF8( _(
146  "Enable transaction logging. The mere presence of this option turns on the "
147  "logging, no need to set a Value."
148  ) );
149 
150  (*aListToAppendTo)["username"] = UTF8( _(
151  "User name for <b>login</b> to some special library server."
152  ) );
153 
154  (*aListToAppendTo)["password"] = UTF8( _(
155  "Password for <b>login</b> to some special library server."
156  ) );
157 #endif
158 
159 #if 1
160  // Suitable for a C++ to python SCH_PLUGIN::Footprint*() adapter, move it to the adapter
161  // if and when implemented.
162  (*aListToAppendTo)["python_symbol_plugin"] = UTF8( _(
163  "Enter the python symbol which implements the SCH_PLUGIN::Symbol*() functions."
164  ) );
165 #endif
166 }
An 8 bit string that is assuredly encoded in UTF8, and supplies special conversion support to and fro...
Definition: utf8.h:70
#define _(s)

References _.

◆ writeDocFile()

bool SCH_LEGACY_PLUGIN::writeDocFile ( const PROPERTIES aProperties)
private

Definition at line 4342 of file sch_legacy_plugin.cpp.

4343 {
4344  std::string propName( SCH_LEGACY_PLUGIN::PropNoDocFile );
4345 
4346  if( aProperties && aProperties->find( propName ) != aProperties->end() )
4347  return false;
4348 
4349  return true;
4350 }
static const char * PropNoDocFile
The property used internally by the plugin to disable writing the library documentation (....

References PropNoDocFile.

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

Member Data Documentation

◆ m_cache

◆ m_currentPath

std::stack<wxString> SCH_LEGACY_PLUGIN::m_currentPath
protected

Stack to maintain nested sheet paths.

Definition at line 189 of file sch_legacy_plugin.h.

Referenced by Load(), and loadHierarchy().

◆ m_error

wxString SCH_LEGACY_PLUGIN::m_error
protected

For throwing exceptions or errors on partial schematic loads.

Definition at line 181 of file sch_legacy_plugin.h.

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

◆ m_lastProgressLine

unsigned SCH_LEGACY_PLUGIN::m_lastProgressLine
protected

Definition at line 185 of file sch_legacy_plugin.h.

Referenced by checkpoint().

◆ m_lineCount

unsigned SCH_LEGACY_PLUGIN::m_lineCount
protected

for progress reporting

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

Referenced by checkpoint(), and loadFile().

◆ m_out

OUTPUTFORMATTER* SCH_LEGACY_PLUGIN::m_out
protected

◆ m_path

wxString SCH_LEGACY_PLUGIN::m_path
protected

Root project path for loading child sheets.

Definition at line 188 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 183 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 190 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 193 of file sch_legacy_plugin.h.

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

◆ m_version

int SCH_LEGACY_PLUGIN::m_version
protected

Version of file being loaded.

Definition at line 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(), isBuffering(), SYMBOL_LIB::IsBuffering(), SCH_EAGLE_PLUGIN::Load(), SYMBOL_LIB_TABLE_RESCUER::OpenRescueLibrary(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer(), and SYMBOL_LIBRARY_MANAGER::SaveLibrary().

◆ PropNoDocFile

const char * SCH_LEGACY_PLUGIN::PropNoDocFile = "no_doc_file"
static

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

Definition at line 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: