SYMBOL_LIBRARY_MANAGER Class Reference

Class to handle modifications to the symbol libraries. More...

#include <symbol_library_manager.h>

Classes
class	LIB_BUFFER
class	SYMBOL_BUFFER
	Store a working copy of a library. More...

Public Member Functions
	SYMBOL_LIBRARY_MANAGER (SYMBOL_EDIT_FRAME &aFrame)
	~SYMBOL_LIBRARY_MANAGER ()
void	Sync (const wxString &aForceRefresh, std::function< void(int, int, const wxString &)> aProgressCallback)
	Updates the SYMBOL_LIBRARY_MANAGER data to synchronize with Symbol Library Table. More...
void	Preload (PROGRESS_REPORTER &aReporter)
	Preloads all symbol libraries in the symbol library table using SYMBOL_ASYNC_LOADER. More...
int	GetHash () const
bool	HasModifications () const
int	GetLibraryHash (const wxString &aLibrary) const
	Return a library hash value to determine if it has changed. More...
wxArrayString	GetLibraryNames () const
	Return the array of library names. More...
SYMBOL_LIB_TABLE_ROW *	GetLibrary (const wxString &aLibrary) const
	Find a single library within the (aggregate) library table. More...
std::list< LIB_SYMBOL * >	GetAliases (const wxString &aLibrary) const
bool	CreateLibrary (const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
	Create an empty library and adds it to the library table. More...
bool	AddLibrary (const wxString &aFilePath, SYMBOL_LIB_TABLE *aTable)
	Add an existing library. More...
bool	UpdateSymbol (LIB_SYMBOL *aSymbol, const wxString &aLibrary)
	Update the symbol buffer with a new version of the symbol. More...
bool	UpdateSymbolAfterRename (LIB_SYMBOL *aSymbol, const wxString &oldAlias, const wxString &aLibrary)
	Update the symbol buffer with a new version of the symbol when the name has changed. More...
bool	RemoveSymbol (const wxString &aName, const wxString &aLibrary)
	Remove the symbol from the symbol buffer. More...
LIB_SYMBOL *	GetAlias (const wxString &aAlias, const wxString &aLibrary) const
	Return either an alias of a working LIB_SYMBOL copy, or alias of the original symbol if there is no working copy. More...
LIB_SYMBOL *	GetBufferedSymbol (const wxString &aAlias, const wxString &aLibrary)
	Return the symbol copy from the buffer. More...
SCH_SCREEN *	GetScreen (const wxString &aAlias, const wxString &aLibrary)
	Return the screen used to edit a specific symbol. More...
bool	SymbolExists (const wxString &aAlias, const wxString &aLibrary) const
	Return true if symbol with a specific alias exists in library (either original one or buffered). More...
bool	LibraryExists (const wxString &aLibrary, bool aCheckEnabled=false) const
	Return true if library exists. More...
bool	IsLibraryLoaded (const wxString &aLibrary) const
	Return true if the library was successfully loaded. More...
bool	IsLibraryModified (const wxString &aLibrary) const
	Return true if library has unsaved modifications. More...
bool	IsSymbolModified (const wxString &aAlias, const wxString &aLibrary) const
	Return true if symbol has unsaved modifications. More...
bool	ClearLibraryModified (const wxString &aLibrary) const
	Clear the modified flag for all symbols in a library. More...
bool	ClearSymbolModified (const wxString &aAlias, const wxString &aLibrary) const
	Clear the modified flag for a symbol. More...
bool	IsLibraryReadOnly (const wxString &aLibrary) const
	Return true if the library is stored in a read-only file. More...
bool	FlushSymbol (const wxString &aAlias, const wxString &aLibrary)
	Save symbol changes to the library copy used by the schematic editor. More...
bool	SaveLibrary (const wxString &aLibrary, const wxString &aFileName, SCH_IO_MGR::SCH_FILE_T aFileType=SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY)
	Save library to a file, including unsaved changes. More...
LIB_ID	RevertSymbol (const wxString &aAlias, const wxString &aLibrary)
	Revert unsaved changes for a symbolicular symbol. More...
bool	RevertLibrary (const wxString &aLibrary)
	Revert unsaved changes for a symbolicular library. More...
bool	RevertAll ()
	Revert all pending changes. More...
wxString	GetUniqueLibraryName () const
	Return a library name that is not currently in use. More...
wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER > &	GetAdapter ()
	Return the adapter object that provides the stored data. More...
void	GetRootSymbolNames (const wxString &aLibName, wxArrayString &aRootSymbolNames)
bool	HasDerivedSymbols (const wxString &aSymbolName, const wxString &aLibraryName)
	Check if symbol aSymbolName in library aLibraryName is a root symbol that has derived symbols. More...
size_t	GetLibraryCount () const

Private Member Functions
bool	addLibrary (const wxString &aFilePath, bool aCreate, SYMBOL_LIB_TABLE *aTable)
	Return the current Symbol Library Table. More...
SYMBOL_LIB_TABLE *	symTable () const
SYMBOL_TREE_SYNCHRONIZING_ADAPTER *	getAdapter ()
	Class to store a working copy of a LIB_SYMBOL object and editor context. More...
std::set< LIB_SYMBOL * >	getOriginalSymbols (const wxString &aLibrary)
	Return a set of LIB_SYMBOL objects belonging to the original library. More...
LIB_BUFFER &	getLibraryBuffer (const wxString &aLibrary)
	Return an existing library buffer or creates one to using Symbol Library Table to get the original data. More...

Static Private Member Functions
static wxString	getLibraryName (const wxString &aFilePath)
	< Extract library name basing on the file name. More...

Private Attributes
std::map< wxString, LIB_BUFFER >	m_libs
SYMBOL_EDIT_FRAME &	m_frame
	Parent frame. More...
LIB_LOGGER *	m_logger
int	m_syncHash
	Symbol lib table hash value from last synchronization. More...
wxObjectDataPtr< LIB_TREE_MODEL_ADAPTER >	m_adapter

Detailed Description

Class to handle modifications to the symbol libraries.

Definition at line 53 of file symbol_library_manager.h.

Constructor & Destructor Documentation

SYMBOL_LIBRARY_MANAGER()

SYMBOL_LIBRARY_MANAGER::SYMBOL_LIBRARY_MANAGER

(

SYMBOL_EDIT_FRAME &

aFrame

)

Definition at line 46 of file symbol_library_manager.cpp.

                                                                          :
        m_frame( aFrame ),
        m_syncHash( 0 )
{
    m_adapter = SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Create( &m_frame, this );
    m_adapter->ShowUnits( false );
    m_logger = new LIB_LOGGER();
}

References SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Create(), m_adapter, m_frame, and m_logger.

~SYMBOL_LIBRARY_MANAGER()

SYMBOL_LIBRARY_MANAGER::~SYMBOL_LIBRARY_MANAGER

(

)

Definition at line 56 of file symbol_library_manager.cpp.

{
    delete m_logger;
}

References m_logger.

Member Function Documentation

AddLibrary()

bool SYMBOL_LIBRARY_MANAGER::AddLibrary ( const wxString &  aFilePath, SYMBOL_LIB_TABLE *  aTable  )

inline

Add an existing library.

The library is added to the library table as well.

Definition at line 108 of file symbol_library_manager.h.

    {
        return addLibrary( aFilePath, false, aTable );
    }

References addLibrary().

Referenced by SYMBOL_EDIT_FRAME::AddLibraryFile(), and SYMBOL_EDIT_FRAME::ExportSymbol().

addLibrary()

bool SYMBOL_LIBRARY_MANAGER::addLibrary ( const wxString &  aFilePath, bool  aCreate, SYMBOL_LIB_TABLE *  aTable  )

private

Return the current Symbol Library Table.

Definition at line 712 of file symbol_library_manager.cpp.

{
    wxCHECK( aTable, false );
    wxString libName = getLibraryName( aFilePath );
    wxCHECK( !LibraryExists( libName ), false );  // either create or add an existing one

    // try to use path normalized to an environmental variable or project path
    wxString relPath = NormalizePath( aFilePath, &Pgm().GetLocalEnvVariables(), &m_frame.Prj() );

    SCH_IO_MGR::SCH_FILE_T schFileType = SCH_IO_MGR::GuessPluginTypeFromLibPath( aFilePath );
    wxString typeName = SCH_IO_MGR::ShowType( schFileType );
    SYMBOL_LIB_TABLE_ROW* libRow = new SYMBOL_LIB_TABLE_ROW( libName, relPath, typeName );
    aTable->InsertRow( libRow );

    if( aCreate )
    {
        wxCHECK( schFileType != SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY, false );

        try
        {
            aTable->CreateSymbolLib( libName );
        }
        catch( const IO_ERROR& )
        {
            aTable->RemoveRow( libRow );
            return false;
        }
    }

    m_frame.SyncLibraries( false );

    return true;
}

References SYMBOL_LIB_TABLE::CreateSymbolLib(), getLibraryName(), SCH_IO_MGR::GuessPluginTypeFromLibPath(), LIB_TABLE::InsertRow(), LibraryExists(), m_frame, NormalizePath(), Pgm(), KIWAY_HOLDER::Prj(), LIB_TABLE::RemoveRow(), SCH_IO_MGR::ShowType(), and SYMBOL_EDIT_FRAME::SyncLibraries().

Referenced by AddLibrary(), and CreateLibrary().

ClearLibraryModified()

bool SYMBOL_LIBRARY_MANAGER::ClearLibraryModified

(

const wxString &

aLibrary

)

const

Clear the modified flag for all symbols in a library.

Definition at line 300 of file symbol_library_manager.cpp.

{
    auto libIt = m_libs.find( aLibrary );

    if( libIt == m_libs.end() )
        return false;

    for( auto& symbolBuf : libIt->second.GetBuffers() )
    {
        SCH_SCREEN* screen = symbolBuf->GetScreen();

        if( screen )
            screen->SetContentModified( false );
    }

    return true;
}

References m_libs, and BASE_SCREEN::SetContentModified().

Referenced by SYMBOL_EDIT_FRAME::saveLibrary().

ClearSymbolModified()

bool SYMBOL_LIBRARY_MANAGER::ClearSymbolModified	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Clear the modified flag for a symbol.

Definition at line 319 of file symbol_library_manager.cpp.

{
    auto libI = m_libs.find( aLibrary );

    if( libI == m_libs.end() )
        return false;

    auto symbolBuf = libI->second.GetBuffer( aAlias );
    wxCHECK( symbolBuf, false );

    symbolBuf->GetScreen()->SetContentModified( false );
    return true;
}

References m_libs.

Referenced by SYMBOL_EDIT_FRAME::Revert(), and SYMBOL_EDIT_FRAME::saveCurrentSymbol().

CreateLibrary()

bool SYMBOL_LIBRARY_MANAGER::CreateLibrary ( const wxString &  aFilePath, SYMBOL_LIB_TABLE *  aTable  )

inline

Create an empty library and adds it to the library table.

The library file is created.

Definition at line 100 of file symbol_library_manager.h.

    {
        return addLibrary( aFilePath, true, aTable );
    }

References addLibrary().

Referenced by SYMBOL_EDIT_FRAME::AddLibraryFile().

FlushSymbol()

bool SYMBOL_LIBRARY_MANAGER::FlushSymbol	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Save symbol changes to the library copy used by the schematic editor.

Not it is not necessarily saved to the file.

Returns

True on success, false otherwise.

Definition at line 502 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it == m_libs.end() )    // no items to flush
        return true;

    auto symbolBuf = it->second.GetBuffer( aAlias );
    wxCHECK( symbolBuf, false );

    return it->second.SaveBuffer( symbolBuf, symTable() );
}

References m_libs, and symTable().

Referenced by SYMBOL_EDIT_FRAME::saveCurrentSymbol().

GetAdapter()

wxObjectDataPtr<LIB_TREE_MODEL_ADAPTER>& SYMBOL_LIBRARY_MANAGER::GetAdapter ( )

inline

Return the adapter object that provides the stored data.

Definition at line 244 of file symbol_library_manager.h.

{ return m_adapter; }

References m_adapter.

Referenced by SYMBOL_EDIT_FRAME::FreezeLibraryTree(), SYMBOL_TREE_PANE::SYMBOL_TREE_PANE(), SYMBOL_EDIT_FRAME::SyncLibraries(), and SYMBOL_EDIT_FRAME::ThawLibraryTree().

getAdapter()

SYMBOL_TREE_SYNCHRONIZING_ADAPTER* SYMBOL_LIBRARY_MANAGER::getAdapter ( )

inlineprivate

Class to store a working copy of a LIB_SYMBOL object and editor context.

Definition at line 268 of file symbol_library_manager.h.

References m_adapter.

Referenced by Sync().

GetAlias()

LIB_SYMBOL * SYMBOL_LIBRARY_MANAGER::GetAlias	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Return either an alias of a working LIB_SYMBOL copy, or alias of the original symbol if there is no working copy.

Definition at line 596 of file symbol_library_manager.cpp.

{
    // Try the library buffers first
    auto libIt = m_libs.find( aLibrary );

    if( libIt != m_libs.end() )
    {
        LIB_SYMBOL* symbol = libIt->second.GetSymbol( aAlias );

        if( symbol )
            return symbol;
    }

    // Get the original symbol
    LIB_SYMBOL* alias = nullptr;

    try
    {
        alias = symTable()->LoadSymbol( aLibrary, aAlias );
    }
    catch( const IO_ERROR& e )
    {
        wxLogMessage( _( "Cannot load symbol '%s' from library '%s'." ) + e.What(),
                      aAlias,
                      aLibrary );
    }

    return alias;
}

References _, SYMBOL_LIB_TABLE::LoadSymbol(), m_libs, symTable(), and IO_ERROR::What().

Referenced by SYMBOL_EDIT_FRAME::CreateNewSymbol(), SYMBOL_EDIT_FRAME::getTargetSymbol(), and DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataFromWindow().

GetAliases()

std::list< LIB_SYMBOL * > SYMBOL_LIBRARY_MANAGER::GetAliases

(

const wxString &

aLibrary

)

const

Definition at line 351 of file symbol_library_manager.cpp.

{
    std::list<LIB_SYMBOL*> ret;
    wxCHECK( LibraryExists( aLibrary ), ret );

    auto libIt = m_libs.find( aLibrary );

    if( libIt != m_libs.end() )
    {
        for( auto& symbolBuf : libIt->second.GetBuffers() )
        {
            ret.push_back( symbolBuf->GetSymbol() );
        }
    }
    else
    {
        std::vector<LIB_SYMBOL*> aliases;

        try
        {
            symTable()->LoadSymbolLib( aliases, aLibrary );
        }
        catch( const IO_ERROR& e )
        {
            wxLogWarning( e.Problem() );
        }

        std::copy( aliases.begin(), aliases.end(), std::back_inserter( ret ) );
    }

    return ret;
}

References LibraryExists(), SYMBOL_LIB_TABLE::LoadSymbolLib(), m_libs, IO_ERROR::Problem(), and symTable().

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::updateLibrary().

GetBufferedSymbol()

LIB_SYMBOL * SYMBOL_LIBRARY_MANAGER::GetBufferedSymbol	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Return the symbol copy from the buffer.

In case it does not exist yet, the copy is created. SYMBOL_LIBRARY_MANAGER retains the ownership.

Definition at line 385 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), nullptr );

    // try the library buffers first
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    LIB_SYMBOL* bufferedSymbol = libBuf.GetSymbol( aAlias );

    if( !bufferedSymbol ) // no buffer symbol found
    {
        // create a copy of the symbol
        try
        {
            LIB_SYMBOL* symbol = symTable()->LoadSymbol( aLibrary, aAlias );

            if( symbol == nullptr )
                THROW_IO_ERROR( _( "Symbol not found." ) );

            LIB_SYMBOL* bufferedParent = nullptr;

            // Create parent symbols on demand so parent symbol can be set.
            if( symbol->IsAlias() )
            {
                std::shared_ptr< LIB_SYMBOL > parent = symbol->GetParent().lock();
                wxCHECK_MSG( parent, nullptr,
                             wxString::Format( "Derived symbol '%s' found with undefined parent.",
                                               symbol->GetName() ) );

                // Check if the parent symbol buffer has already be created.
                bufferedParent = libBuf.GetSymbol( parent->GetName() );

                if( !bufferedParent )
                {
                    bufferedParent = new LIB_SYMBOL( *parent.get() );
                    libBuf.CreateBuffer( bufferedParent, new SCH_SCREEN );
                }
            }

            bufferedSymbol = new LIB_SYMBOL( *symbol );

            if( bufferedParent )
                bufferedSymbol->SetParent( bufferedParent );

            libBuf.CreateBuffer( bufferedSymbol, new SCH_SCREEN );
        }
        catch( const IO_ERROR& e )
        {
            wxLogMessage( _( "Error loading symbol %s from library '%s'. (%s)" ),
                          aAlias, aLibrary, e.What() );
            bufferedSymbol = nullptr;
        }
    }

    return bufferedSymbol;
}

References _, SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::CreateBuffer(), Format(), getLibraryBuffer(), LIB_SYMBOL::GetName(), LIB_SYMBOL::GetParent(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetSymbol(), LIB_SYMBOL::IsAlias(), LibraryExists(), SYMBOL_LIB_TABLE::LoadSymbol(), LIB_SYMBOL::SetParent(), symTable(), THROW_IO_ERROR, and IO_ERROR::What().

Referenced by SYMBOL_EDIT_FRAME::CopySymbolToClipboard(), SYMBOL_EDIT_FRAME::DuplicateSymbol(), SYMBOL_EDIT_FRAME::isCurrentSymbol(), SYMBOL_EDIT_FRAME::LoadOneLibrarySymbolAux(), and SYMBOL_EDIT_FRAME::LoadSymbol().

GetHash()

int SYMBOL_LIBRARY_MANAGER::GetHash

(

)

const

Definition at line 129 of file symbol_library_manager.cpp.

{
    int hash = symTable()->GetModifyHash();

    for( const auto& lib : m_libs )
        hash += lib.second.GetHash();

    return hash;
}

References SYMBOL_LIB_TABLE::GetModifyHash(), m_libs, and symTable().

Referenced by RevertAll(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

GetLibrary()

SYMBOL_LIB_TABLE_ROW * SYMBOL_LIBRARY_MANAGER::GetLibrary

(

const wxString &

aLibrary

)

const

Find a single library within the (aggregate) library table.

Definition at line 166 of file symbol_library_manager.cpp.

{
    SYMBOL_LIB_TABLE_ROW* row = nullptr;

    try
    {
        row = symTable()->FindRow( aLibrary, true );
    }
    catch( const IO_ERROR& e )
    {
        wxLogMessage( _( "Library '%s' not found in the Symbol Library Table." ) + e.What(),
                      aLibrary );
    }

    return row;
}

References _, SYMBOL_LIB_TABLE::FindRow(), symTable(), and IO_ERROR::What().

Referenced by GetLibraryHash(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue(), SYMBOL_EDIT_FRAME::IsSymbolFromLegacyLibrary(), SaveLibrary(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

getLibraryBuffer()

SYMBOL_LIBRARY_MANAGER::LIB_BUFFER & SYMBOL_LIBRARY_MANAGER::getLibraryBuffer ( const wxString &  aLibrary )

private

Return an existing library buffer or creates one to using Symbol Library Table to get the original data.

The library buffers

Definition at line 779 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it != m_libs.end() )
        return it->second;

    // The requested buffer does not exist yet, so create one
    auto ret = m_libs.emplace( aLibrary, LIB_BUFFER( aLibrary ) );
    LIB_BUFFER& buf = ret.first->second;

    for( auto symbol : getOriginalSymbols( aLibrary ) )
    {
        LIB_SYMBOL* newSymbol;

        if( symbol->IsAlias() )
        {
            std::shared_ptr< LIB_SYMBOL > oldParent = symbol->GetParent().lock();

            wxCHECK_MSG( oldParent, buf,
                         wxString::Format( "Derived symbol '%s' found with undefined parent.",
                                           symbol->GetName() ) );

            LIB_SYMBOL* libParent = buf.GetSymbol( oldParent->GetName() );

            if( !libParent )
            {
                libParent = new LIB_SYMBOL( *oldParent.get() );
                buf.CreateBuffer( libParent, new SCH_SCREEN );
            }

            newSymbol = new LIB_SYMBOL( *symbol );
            newSymbol->SetParent( libParent );
            buf.CreateBuffer( newSymbol, new SCH_SCREEN );
        }
        else if( !buf.GetSymbol( symbol->GetName() ) )
        {
            buf.CreateBuffer( new LIB_SYMBOL( *symbol ), new SCH_SCREEN );
        }
    }

    return buf;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::CreateBuffer(), Format(), getOriginalSymbols(), LIB_SYMBOL::GetParent(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetSymbol(), m_libs, and LIB_SYMBOL::SetParent().

Referenced by GetBufferedSymbol(), GetRootSymbolNames(), HasDerivedSymbols(), RemoveSymbol(), UpdateSymbol(), and UpdateSymbolAfterRename().

GetLibraryCount()

size_t SYMBOL_LIBRARY_MANAGER::GetLibraryCount

(

)

const

Definition at line 699 of file symbol_library_manager.cpp.

{
    return symTable()->GetLogicalLibs().size();
}

References LIB_TABLE::GetLogicalLibs(), and symTable().

GetLibraryHash()

int SYMBOL_LIBRARY_MANAGER::GetLibraryHash

(

const wxString &

aLibrary

)

const

Return a library hash value to determine if it has changed.

For buffered libraries, it returns a number corresponding to the number of modifications. For original libraries, hash is computed basing on the library URI. Returns -1 when the requested library does not exist.

Definition at line 140 of file symbol_library_manager.cpp.

{
    const auto libBufIt = m_libs.find( aLibrary );

    if( libBufIt != m_libs.end() )
        return libBufIt->second.GetHash();

    auto row = GetLibrary( aLibrary );

    // return -1 if library does not exist or 0 if not modified
    return row ? std::hash<std::string>{}( aLibrary.ToStdString() +
                                           row->GetFullURI( true ).ToStdString() ) : -1;
}

References GetLibrary(), and m_libs.

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::updateLibrary().

getLibraryName()

wxString SYMBOL_LIBRARY_MANAGER::getLibraryName ( const wxString &  aFilePath )

staticprivate

< Extract library name basing on the file name.

Helper function to add either existing or create new library

Definition at line 705 of file symbol_library_manager.cpp.

{
    wxFileName fn( aFilePath );
    return fn.GetName();
}

Referenced by addLibrary().

GetLibraryNames()

wxArrayString SYMBOL_LIBRARY_MANAGER::GetLibraryNames

(

)

const

Return the array of library names.

Definition at line 155 of file symbol_library_manager.cpp.

{
    wxArrayString res;

    for( const auto& libName : symTable()->GetLogicalLibs() )
        res.Add( libName );

    return res;
}

References symTable().

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetLibrariesCount(), SYMBOL_EDIT_FRAME::IsContentModified(), SYMBOL_EDIT_FRAME::saveAllLibraries(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

getOriginalSymbols()

std::set< LIB_SYMBOL * > SYMBOL_LIBRARY_MANAGER::getOriginalSymbols ( const wxString &  aLibrary )

private

Return a set of LIB_SYMBOL objects belonging to the original library.

Definition at line 754 of file symbol_library_manager.cpp.

{
    std::set<LIB_SYMBOL*> symbols;
    wxCHECK( LibraryExists( aLibrary ), symbols );

    try
    {
        wxArrayString aliases;
        symTable()->EnumerateSymbolLib( aLibrary, aliases );

        for( const auto& aliasName : aliases )
        {
            LIB_SYMBOL* alias = symTable()->LoadSymbol( aLibrary, aliasName );
            symbols.insert( alias );
        }
    }
    catch( const IO_ERROR& e )
    {
        wxLogMessage( _( "Cannot enumerate library '%s'." ) + e.What(), aLibrary );
    }

    return symbols;
}

References _, SYMBOL_LIB_TABLE::EnumerateSymbolLib(), LibraryExists(), SYMBOL_LIB_TABLE::LoadSymbol(), symTable(), and IO_ERROR::What().

Referenced by getLibraryBuffer(), and SaveLibrary().

GetRootSymbolNames()

void SYMBOL_LIBRARY_MANAGER::GetRootSymbolNames	(	const wxString &	aLibName,
		wxArrayString &	aRootSymbolNames
	)

Definition at line 681 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibraryName );

    libBuf.GetRootSymbolNames( aRootSymbolNames );
}

References getLibraryBuffer(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetRootSymbolNames().

Referenced by SYMBOL_EDIT_FRAME::CreateNewSymbol(), and DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataToWindow().

GetScreen()

SCH_SCREEN * SYMBOL_LIBRARY_MANAGER::GetScreen	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Return the screen used to edit a specific symbol.

SYMBOL_LIBRARY_MANAGER retains the ownership.

Definition at line 443 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), nullptr );
    wxCHECK( !aAlias.IsEmpty(), nullptr );
    auto it = m_libs.find( aLibrary );
    wxCHECK( it != m_libs.end(), nullptr );

    LIB_BUFFER& buf = it->second;
    auto symbolBuf = buf.GetBuffer( aAlias );
    return symbolBuf ? symbolBuf->GetScreen() : nullptr;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), LibraryExists(), and m_libs.

Referenced by SYMBOL_EDIT_FRAME::LoadOneLibrarySymbolAux().

GetUniqueLibraryName()

wxString SYMBOL_LIBRARY_MANAGER::GetUniqueLibraryName

(

)

const

Return a library name that is not currently in use.

Used for generating names for new libraries.

Definition at line 661 of file symbol_library_manager.cpp.

{
    wxString name = "New_Library";

    if( !LibraryExists( name ) )
        return name;

    name += "_";

    for( unsigned int i = 0; i < std::numeric_limits<unsigned int>::max(); ++i )
    {
        if( !LibraryExists( name + wxString::Format( "%u", i ) ) )
            return name + wxString::Format( "%u", i );
    }

    wxFAIL;
    return wxEmptyString;
}

References Format(), LibraryExists(), and name.

Referenced by SYMBOL_EDIT_FRAME::AddLibraryFile().

HasDerivedSymbols()

bool SYMBOL_LIBRARY_MANAGER::HasDerivedSymbols	(	const wxString &	aSymbolName,
		const wxString &	aLibraryName
	)

Check if symbol aSymbolName in library aLibraryName is a root symbol that has derived symbols.

Returns

true if \aSymbolName in aLibraryName has derived symbols.

Definition at line 690 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibraryName );

    return libBuf.HasDerivedSymbols( aSymbolName );
}

References getLibraryBuffer(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::HasDerivedSymbols().

Referenced by SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::DeleteBuffer(), and SYMBOL_EDIT_FRAME::DeleteSymbolFromLibrary().

HasModifications()

bool SYMBOL_LIBRARY_MANAGER::HasModifications

(

)

const

Definition at line 117 of file symbol_library_manager.cpp.

{
    for( const auto& lib : m_libs )
    {
        if( lib.second.IsModified() )
            return true;
    }

    return false;
}

References m_libs.

Referenced by SYMBOL_EDIT_FRAME::HasLibModifications(), and SYMBOL_EDIT_FRAME::setupUIConditions().

IsLibraryLoaded()

bool SYMBOL_LIBRARY_MANAGER::IsLibraryLoaded

(

const wxString &

aLibrary

)

const

Return true if the library was successfully loaded.

Definition at line 343 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), false );

    return symTable()->IsSymbolLibLoaded( aLibrary );
}

References SYMBOL_LIB_TABLE::IsSymbolLibLoaded(), LibraryExists(), and symTable().

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetAttr(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue().

IsLibraryModified()

bool SYMBOL_LIBRARY_MANAGER::IsLibraryModified

(

const wxString &

aLibrary

)

const

Return true if library has unsaved modifications.

Definition at line 279 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );
    return it != m_libs.end() ? it->second.IsModified() : false;
}

References m_libs.

Referenced by SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetAttr(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue(), SYMBOL_EDIT_FRAME::IsContentModified(), and SYMBOL_EDIT_FRAME::saveAllLibraries().

IsLibraryReadOnly()

bool SYMBOL_LIBRARY_MANAGER::IsLibraryReadOnly

(

const wxString &

aLibrary

)

const

Return true if the library is stored in a read-only file.

Returns

True on success, false otherwise.

Definition at line 335 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), true );

    return !symTable()->IsSymbolLibWritable( aLibrary );
}

References SYMBOL_LIB_TABLE::IsSymbolLibWritable(), LibraryExists(), and symTable().

Referenced by SYMBOL_EDITOR_CONTROL::AddSymbol(), SYMBOL_EDITOR_CONTROL::CutCopyDelete(), SYMBOL_EDITOR_CONTROL::DuplicateSymbol(), SYMBOL_EDIT_FRAME::IsContentModified(), SYMBOL_EDIT_FRAME::Save(), SYMBOL_EDIT_FRAME::saveAllLibraries(), SYMBOL_EDIT_FRAME::saveLibrary(), SYMBOL_EDIT_FRAME::SelectLibraryFromList(), and SYMBOL_EDIT_FRAME::updateTitle().

IsSymbolModified()

bool SYMBOL_LIBRARY_MANAGER::IsSymbolModified	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Return true if symbol has unsaved modifications.

Definition at line 286 of file symbol_library_manager.cpp.

{
    auto libIt = m_libs.find( aLibrary );

    if( libIt == m_libs.end() )
        return false;

    const LIB_BUFFER& buf = libIt->second;
    auto symbolBuf = buf.GetBuffer( aAlias );
    return symbolBuf ? symbolBuf->IsModified() : false;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), and m_libs.

Referenced by SYMBOL_EDIT_FRAME::DeleteSymbolFromLibrary(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetAttr(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::GetValue().

LibraryExists()

bool SYMBOL_LIBRARY_MANAGER::LibraryExists	(	const wxString &	aLibrary,
		bool	aCheckEnabled = false
	)		const

Return true if library exists.

If aCheckEnabled is set, then the library must also be enabled in the library table.

Definition at line 649 of file symbol_library_manager.cpp.

{
    if( aLibrary.IsEmpty() )
        return false;

    if( m_libs.count( aLibrary ) > 0 )
        return true;

    return symTable()->HasLibrary( aLibrary, aCheckEnabled );
}

References LIB_TABLE::HasLibrary(), m_libs, and symTable().

Referenced by addLibrary(), SYMBOL_EDIT_FRAME::AddLibraryFile(), SYMBOL_EDIT_FRAME::CreateNewSymbol(), SYMBOL_EDIT_FRAME::DuplicateSymbol(), GetAliases(), GetBufferedSymbol(), getOriginalSymbols(), GetScreen(), GetUniqueLibraryName(), SYMBOL_EDIT_FRAME::ImportSymbol(), IsLibraryLoaded(), IsLibraryReadOnly(), SaveLibrary(), SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync(), and UpdateSymbol().

Preload()

void SYMBOL_LIBRARY_MANAGER::Preload

(

PROGRESS_REPORTER &

aReporter

)

Preloads all symbol libraries in the symbol library table using SYMBOL_ASYNC_LOADER.

Call before the first call to Sync() to get better performance.

Parameters

aReporter

is used to report progress of the load

Definition at line 75 of file symbol_library_manager.cpp.

{
    const int progressIntervalMillis = 60;

    SYMBOL_ASYNC_LOADER loader( symTable()->GetLogicalLibs(), symTable(), false, nullptr,
                                &aReporter );

    LOCALE_IO toggle;

    loader.Start();

    while( !loader.Done() )
    {
        aReporter.KeepRefreshing();

        wxMilliSleep( progressIntervalMillis );
    }

    if( aReporter.IsCancelled() )
    {
        loader.Abort();
    }
    else
    {
        loader.Join();
    }

    if( !loader.GetErrors().IsEmpty() )
    {
        HTML_MESSAGE_BOX dlg( &m_frame, _( "Load Error" ) );

        dlg.MessageSet( _( "Errors loading symbols:" ) );

        wxString msg = loader.GetErrors();
        msg.Replace( "\n", "<BR>" );

        dlg.AddHTML_Text( msg );
        dlg.ShowModal();
    }
}

References _, SYMBOL_ASYNC_LOADER::Abort(), HTML_MESSAGE_BOX::AddHTML_Text(), SYMBOL_ASYNC_LOADER::Done(), SYMBOL_ASYNC_LOADER::GetErrors(), PROGRESS_REPORTER::IsCancelled(), SYMBOL_ASYNC_LOADER::Join(), PROGRESS_REPORTER::KeepRefreshing(), m_frame, HTML_MESSAGE_BOX::MessageSet(), SYMBOL_ASYNC_LOADER::Start(), and symTable().

RemoveSymbol()

bool SYMBOL_LIBRARY_MANAGER::RemoveSymbol	(	const wxString &	aName,
		const wxString &	aLibrary
	)

Remove the symbol from the symbol buffer.

It is required to save the library to have the symbol removed in the schematic editor.

Definition at line 581 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    auto symbolBuf = libBuf.GetBuffer( aAlias );
    wxCHECK( symbolBuf, false );

    bool retv = true;

    retv &= libBuf.DeleteBuffer( symbolBuf );
    m_frame.SyncLibraries( false );

    return retv;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::DeleteBuffer(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), getLibraryBuffer(), m_frame, and SYMBOL_EDIT_FRAME::SyncLibraries().

Referenced by SYMBOL_EDIT_FRAME::DeleteSymbolFromLibrary().

RevertAll()

bool SYMBOL_LIBRARY_MANAGER::RevertAll

(

)

Revert all pending changes.

Returns

True if all changes successfully reverted.

Definition at line 555 of file symbol_library_manager.cpp.

{
    bool retv = true;

    // Nothing to revert.
    if( GetHash() == 0 )
        return true;

    for( const auto& lib : m_libs )
    {
        if( !lib.second.IsModified() )
            continue;

        for( const auto& buffer : lib.second.GetBuffers() )
        {
            if( !buffer->IsModified() )
                continue;

            RevertSymbol( lib.first, buffer->GetOriginal()->GetName() );
        }
    }

    return retv;
}

References GetHash(), m_libs, and RevertSymbol().

Referenced by SYMBOL_EDIT_FRAME::RevertAll().

RevertLibrary()

bool SYMBOL_LIBRARY_MANAGER::RevertLibrary

(

const wxString &

aLibrary

)

Revert unsaved changes for a symbolicular library.

Returns

True on success, false otherwise.

Definition at line 541 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it == m_libs.end() )    // nothing to reverse
        return false;

    m_libs.erase( it );
    m_frame.SyncLibraries( false );

    return true;
}

References m_frame, m_libs, and SYMBOL_EDIT_FRAME::SyncLibraries().

Referenced by SYMBOL_EDIT_FRAME::Revert().

RevertSymbol()

LIB_ID SYMBOL_LIBRARY_MANAGER::RevertSymbol	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)

Revert unsaved changes for a symbolicular symbol.

Returns

The LIB_ID of the reverted symbol (which may be different in the case of a rename)

Definition at line 516 of file symbol_library_manager.cpp.

{
    auto it = m_libs.find( aLibrary );

    if( it == m_libs.end() )    // no items to flush
        return LIB_ID( aLibrary, aAlias );

    auto symbolBuf = it->second.GetBuffer( aAlias );
    wxCHECK( symbolBuf, LIB_ID( aLibrary, aAlias ) );
    LIB_SYMBOL original( *symbolBuf->GetOriginal() );

    if( original.GetName() != aAlias )
    {
        UpdateSymbolAfterRename( &original, aAlias, aLibrary );
    }
    else
    {
        symbolBuf->SetSymbol( new LIB_SYMBOL( original ) );
        m_frame.SyncLibraries( false );
    }

    return LIB_ID( aLibrary, original.GetName() );
}

References m_frame, m_libs, SYMBOL_EDIT_FRAME::SyncLibraries(), and UpdateSymbolAfterRename().

Referenced by SYMBOL_EDIT_FRAME::Revert(), and RevertAll().

SaveLibrary()

bool SYMBOL_LIBRARY_MANAGER::SaveLibrary	(	const wxString &	aLibrary,
		const wxString &	aFileName,
		SCH_IO_MGR::SCH_FILE_T	aFileType = SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY
	)

Save library to a file, including unsaved changes.

Parameters

aLibrary	is the library name.
aFileName	is the target file name.

Returns

True on success, false otherwise.

Definition at line 184 of file symbol_library_manager.cpp.

{
    wxCHECK( aFileType != SCH_IO_MGR::SCH_FILE_T::SCH_LEGACY && LibraryExists( aLibrary ), false );
    wxFileName fn( aFileName );
    wxCHECK( !fn.FileExists() || fn.IsFileWritable(), false );
    SCH_PLUGIN::SCH_PLUGIN_RELEASER pi( SCH_IO_MGR::FindPlugin( aFileType ) );
    bool res = true;    // assume all libraries are successfully saved

    PROPERTIES properties;
    properties.emplace( SCH_LEGACY_PLUGIN::PropBuffering, "" );

    auto it = m_libs.find( aLibrary );

    if( it != m_libs.end() )
    {
        // Handle buffered library
        LIB_BUFFER& libBuf = it->second;

        const auto& symbolBuffers = libBuf.GetBuffers();

        for( const auto& symbolBuf : symbolBuffers )
        {
            if( !libBuf.SaveBuffer( symbolBuf, aFileName, &*pi, true ) )
            {
                // Something went wrong, but try to save other libraries
                res = false;
            }
        }

        // clear the deleted symbols buffer only if data is saved to the original file
        wxFileName original, destination( aFileName );
        auto row = GetLibrary( aLibrary );

        if( row )
        {
            original = row->GetFullURI( true );
            original.Normalize();
        }

        destination.Normalize();

        if( res && original == destination )
            libBuf.ClearDeletedBuffer();
    }
    else
    {
        // Handle original library
        for( LIB_SYMBOL* symbol : getOriginalSymbols( aLibrary ) )
        {
            LIB_SYMBOL* newSymbol;

            if( symbol->IsAlias() )
            {
                std::shared_ptr< LIB_SYMBOL > oldParent = symbol->GetParent().lock();

                wxCHECK_MSG( oldParent, false,
                             wxString::Format( "Derived symbol '%s' found with undefined parent.",
                                               symbol->GetName() ) );

                LIB_SYMBOL* libParent = pi->LoadSymbol( aLibrary, oldParent->GetName(),
                                                        &properties );

                if( !libParent )
                {
                    libParent = new LIB_SYMBOL( *oldParent.get() );
                    pi->SaveSymbol( aLibrary, libParent, &properties );
                }

                newSymbol = new LIB_SYMBOL( *symbol );
                newSymbol->SetParent( libParent );
                pi->SaveSymbol( aLibrary, newSymbol, &properties );
            }
            else if( !pi->LoadSymbol( aLibrary, symbol->GetName(), &properties ) )
            {
                pi->SaveSymbol( aLibrary, new LIB_SYMBOL( *symbol ), &properties );
            }
        }
    }

    try
    {
        pi->SaveLibrary( aFileName );
    }
    catch( ... )
    {
        // return false because something happens.
        // The library is not successfully saved
        res = false;
    }

    return res;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::ClearDeletedBuffer(), Format(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffers(), GetLibrary(), getOriginalSymbols(), LIB_SYMBOL::GetParent(), LibraryExists(), m_libs, SCH_LEGACY_PLUGIN::PropBuffering, SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::SaveBuffer(), and LIB_SYMBOL::SetParent().

Referenced by SYMBOL_EDIT_FRAME::saveLibrary().

SymbolExists()

bool SYMBOL_LIBRARY_MANAGER::SymbolExists	(	const wxString &	aAlias,
		const wxString &	aLibrary
	)		const

Return true if symbol with a specific alias exists in library (either original one or buffered).

Definition at line 628 of file symbol_library_manager.cpp.

{
    auto libBufIt = m_libs.find( aLibrary );
    LIB_SYMBOL* alias = nullptr;

    if( libBufIt != m_libs.end() )
        return !!libBufIt->second.GetBuffer( aAlias );

    try
    {
        alias = symTable()->LoadSymbol( aLibrary, aAlias );
    }
    catch( IO_ERROR& )
    {
        // checking if certain symbol exists, so its absence is perfectly fine
    }

    return alias != nullptr;
}

References SYMBOL_LIB_TABLE::LoadSymbol(), m_libs, and symTable().

Referenced by SYMBOL_EDIT_FRAME::CreateNewSymbol(), SYMBOL_EDIT_FRAME::ensureUniqueName(), SYMBOL_EDIT_FRAME::ImportSymbol(), SYMBOL_EDIT_FRAME::Revert(), SYMBOL_EDIT_FRAME::saveSymbolAs(), DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataFromWindow(), and SYMBOL_EDIT_FRAME::UpdateAfterSymbolProperties().

symTable()

SYMBOL_LIB_TABLE * SYMBOL_LIBRARY_MANAGER::symTable ( ) const

private

Definition at line 748 of file symbol_library_manager.cpp.

{
    return m_frame.Prj().SchSymbolLibTable();
}

References m_frame, and KIWAY_HOLDER::Prj().

Referenced by FlushSymbol(), GetAlias(), GetAliases(), GetBufferedSymbol(), GetHash(), GetLibrary(), GetLibraryCount(), GetLibraryNames(), getOriginalSymbols(), IsLibraryLoaded(), IsLibraryReadOnly(), LibraryExists(), Preload(), SymbolExists(), and Sync().

Sync()

void SYMBOL_LIBRARY_MANAGER::Sync	(	const wxString &	aForceRefresh,
		std::function< void(int, int, const wxString &)>	aProgressCallback
	)

Updates the SYMBOL_LIBRARY_MANAGER data to synchronize with Symbol Library Table.

Definition at line 62 of file symbol_library_manager.cpp.

{
    m_logger->Activate();
    {
        getAdapter()->Sync( aForceRefresh, aProgressCallback );
        m_syncHash = symTable()->GetModifyHash();
    }
    m_logger->Deactivate();
}

References LIB_LOGGER::Activate(), LIB_LOGGER::Deactivate(), getAdapter(), SYMBOL_LIB_TABLE::GetModifyHash(), m_logger, m_syncHash, symTable(), and SYMBOL_TREE_SYNCHRONIZING_ADAPTER::Sync().

Referenced by SYMBOL_EDIT_FRAME::SyncLibraries().

UpdateSymbol()

bool SYMBOL_LIBRARY_MANAGER::UpdateSymbol	(	LIB_SYMBOL *	aSymbol,
		const wxString &	aLibrary
	)

Update the symbol buffer with a new version of the symbol.

The library buffer creates a copy of the symbol. It is required to save the library to use the updated symbol in the schematic editor.

Definition at line 456 of file symbol_library_manager.cpp.

{
    wxCHECK( LibraryExists( aLibrary ), false );
    wxCHECK( aSymbol, false );
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    auto symbolBuf = libBuf.GetBuffer( aSymbol->GetName() );

    if( symbolBuf )     // Existing symbol.
    {
        LIB_SYMBOL* bufferedSymbol = const_cast< LIB_SYMBOL* >( symbolBuf->GetSymbol() );

        wxCHECK( bufferedSymbol, false );

        *bufferedSymbol = *aSymbol;
        symbolBuf->GetScreen()->SetContentModified();
    }
    else              // New symbol
    {
        LIB_SYMBOL* symbolCopy = new LIB_SYMBOL( *aSymbol, nullptr );

        symbolCopy->SetLibId( LIB_ID( aLibrary, aSymbol->GetLibId().GetLibItemName() ) );

        SCH_SCREEN* screen = new SCH_SCREEN;
        libBuf.CreateBuffer( symbolCopy, screen );
        screen->SetContentModified();
    }

    return true;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::CreateBuffer(), SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), LIB_SYMBOL::GetLibId(), LIB_ID::GetLibItemName(), getLibraryBuffer(), LIB_SYMBOL::GetName(), LibraryExists(), BASE_SCREEN::SetContentModified(), and LIB_SYMBOL::SetLibId().

Referenced by SYMBOL_EDIT_FRAME::CreateNewSymbol(), SYMBOL_EDIT_FRAME::DuplicateSymbol(), SYMBOL_EDIT_FRAME::ImportSymbol(), SYMBOL_EDIT_FRAME::saveSymbolAs(), and SYMBOL_EDIT_FRAME::storeCurrentSymbol().

UpdateSymbolAfterRename()

bool SYMBOL_LIBRARY_MANAGER::UpdateSymbolAfterRename	(	LIB_SYMBOL *	aSymbol,
		const wxString &	oldAlias,
		const wxString &	aLibrary
	)

Update the symbol buffer with a new version of the symbol when the name has changed.

The old library buffer will be deleted and a new one created with the new name.

Definition at line 487 of file symbol_library_manager.cpp.

{
    LIB_BUFFER& libBuf = getLibraryBuffer( aLibrary );
    auto symbolBuf = libBuf.GetBuffer( aOldName );

    wxCHECK( symbolBuf, false );

    libBuf.UpdateBuffer( symbolBuf, aSymbol );
    m_frame.SyncLibraries( false );

    return true;
}

References SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::GetBuffer(), getLibraryBuffer(), m_frame, SYMBOL_EDIT_FRAME::SyncLibraries(), and SYMBOL_LIBRARY_MANAGER::LIB_BUFFER::UpdateBuffer().

Referenced by SYMBOL_EDIT_FRAME::GetSymbolFromRedoList(), SYMBOL_EDIT_FRAME::GetSymbolFromUndoList(), RevertSymbol(), and SYMBOL_EDIT_FRAME::UpdateAfterSymbolProperties().

Member Data Documentation

m_adapter

wxObjectDataPtr<LIB_TREE_MODEL_ADAPTER> SYMBOL_LIBRARY_MANAGER::m_adapter

private

Definition at line 428 of file symbol_library_manager.h.

Referenced by GetAdapter(), getAdapter(), and SYMBOL_LIBRARY_MANAGER().

m_frame

SYMBOL_EDIT_FRAME& SYMBOL_LIBRARY_MANAGER::m_frame

private

Parent frame.

Definition at line 424 of file symbol_library_manager.h.

Referenced by addLibrary(), Preload(), RemoveSymbol(), RevertLibrary(), RevertSymbol(), SYMBOL_LIBRARY_MANAGER(), symTable(), and UpdateSymbolAfterRename().

m_libs

std::map<wxString, LIB_BUFFER> SYMBOL_LIBRARY_MANAGER::m_libs

private

Definition at line 422 of file symbol_library_manager.h.

Referenced by ClearLibraryModified(), ClearSymbolModified(), FlushSymbol(), GetAlias(), GetAliases(), GetHash(), getLibraryBuffer(), GetLibraryHash(), GetScreen(), HasModifications(), IsLibraryModified(), IsSymbolModified(), LibraryExists(), RevertAll(), RevertLibrary(), RevertSymbol(), SaveLibrary(), and SymbolExists().

m_logger

LIB_LOGGER* SYMBOL_LIBRARY_MANAGER::m_logger

private

Definition at line 425 of file symbol_library_manager.h.

Referenced by SYMBOL_LIBRARY_MANAGER(), Sync(), and ~SYMBOL_LIBRARY_MANAGER().

m_syncHash

int SYMBOL_LIBRARY_MANAGER::m_syncHash

private

Symbol lib table hash value from last synchronization.

Definition at line 426 of file symbol_library_manager.h.

Referenced by Sync().

---

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

• symbol_library_manager.h
• symbol_library_manager.cpp