2015-06-22 15:38:54 +00:00
|
|
|
/*
|
|
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
|
|
*
|
2017-07-24 19:02:59 +00:00
|
|
|
* Copyright (C) 2015 Chris Pavlina <pavlina.chris@gmail.com>
|
2020-04-02 00:17:25 +00:00
|
|
|
* Copyright (C) 2015-2020 KiCad Developers, see change_log.txt for contributors.
|
2015-06-22 15:38:54 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, you may find one here:
|
|
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
|
|
*/
|
|
|
|
|
2018-08-03 12:18:26 +00:00
|
|
|
#include <sch_draw_panel.h>
|
2015-06-22 15:38:54 +00:00
|
|
|
#include <class_library.h>
|
|
|
|
#include <confirm.h>
|
2019-12-09 19:47:29 +00:00
|
|
|
#include <connection_graph.h>
|
2015-06-22 15:38:54 +00:00
|
|
|
#include <invoke_sch_dialog.h>
|
2017-10-22 00:48:25 +00:00
|
|
|
#include <kiway.h>
|
2019-12-19 14:05:46 +00:00
|
|
|
#include <lib_view_frame.h>
|
2015-06-22 15:38:54 +00:00
|
|
|
#include <project_rescue.h>
|
|
|
|
#include <sch_component.h>
|
|
|
|
#include <sch_sheet.h>
|
2018-01-30 10:49:51 +00:00
|
|
|
#include <sch_edit_frame.h>
|
2020-05-13 02:00:37 +00:00
|
|
|
#include <schematic.h>
|
2017-10-22 00:48:25 +00:00
|
|
|
#include <symbol_lib_table.h>
|
2015-06-22 15:38:54 +00:00
|
|
|
#include <wildcards_and_files_ext.h>
|
|
|
|
|
2015-08-17 23:12:34 +00:00
|
|
|
#include <cctype>
|
2015-06-22 15:38:54 +00:00
|
|
|
#include <map>
|
|
|
|
|
|
|
|
|
|
|
|
typedef std::pair<SCH_COMPONENT*, wxString> COMPONENT_NAME_PAIR;
|
|
|
|
|
|
|
|
|
2017-06-21 07:32:19 +00:00
|
|
|
// Helper sort function, used in get_components, to sort a component list by lib_id
|
|
|
|
static bool sort_by_libid( const SCH_COMPONENT* ref, SCH_COMPONENT* cmp )
|
|
|
|
{
|
|
|
|
return ref->GetLibId() < cmp->GetLibId();
|
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
/**
|
2017-11-09 23:07:16 +00:00
|
|
|
* Fill a vector with all of the project's symbols, to ease iterating over them.
|
2017-10-22 00:48:25 +00:00
|
|
|
*
|
2017-11-09 23:07:16 +00:00
|
|
|
* The list is sorted by #LIB_ID, therefore components using the same library
|
2017-03-09 17:13:03 +00:00
|
|
|
* symbol are grouped, allowing later faster calculations (one library search by group
|
|
|
|
* of symbols)
|
2015-06-22 15:38:54 +00:00
|
|
|
*
|
2017-11-09 23:07:16 +00:00
|
|
|
* @param aComponents - a vector that will take the symbols
|
2015-06-22 15:38:54 +00:00
|
|
|
*/
|
2020-05-13 02:00:37 +00:00
|
|
|
static void get_components( SCHEMATIC* aSchematic, std::vector<SCH_COMPONENT*>& aComponents )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2020-05-13 02:00:37 +00:00
|
|
|
SCH_SCREENS screens( aSchematic->Root() );
|
2017-03-09 17:13:03 +00:00
|
|
|
|
|
|
|
// Get the full list
|
2015-06-22 15:38:54 +00:00
|
|
|
for( SCH_SCREEN* screen = screens.GetFirst(); screen; screen = screens.GetNext() )
|
|
|
|
{
|
2019-06-25 23:39:58 +00:00
|
|
|
for( auto aItem : screen->Items().OfType( SCH_COMPONENT_T ) )
|
|
|
|
aComponents.push_back( static_cast<SCH_COMPONENT*>( aItem ) );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
2017-03-09 17:13:03 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
if( aComponents.empty() )
|
|
|
|
return;
|
|
|
|
|
2017-03-09 17:13:03 +00:00
|
|
|
// sort aComponents by lib part. Components will be grouped by same lib part.
|
|
|
|
std::sort( aComponents.begin(), aComponents.end(), sort_by_libid );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Search the libraries for the first component with a given name.
|
|
|
|
*
|
|
|
|
* @param aName - name to search for
|
|
|
|
* @param aLibs - the loaded PART_LIBS
|
|
|
|
* @param aCached - whether we are looking for the cached part
|
|
|
|
*/
|
2017-09-23 09:20:10 +00:00
|
|
|
static LIB_PART* find_component( const wxString& aName, PART_LIBS* aLibs, bool aCached )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
|
|
|
LIB_PART *part = NULL;
|
2018-06-21 04:12:11 +00:00
|
|
|
wxString new_name = LIB_ID::FixIllegalChars( aName, LIB_ID::ID_SCH );
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2016-06-29 20:07:55 +00:00
|
|
|
for( PART_LIB& each_lib : *aLibs )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
|
|
|
if( aCached && !each_lib.IsCache() )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if( !aCached && each_lib.IsCache() )
|
|
|
|
continue;
|
|
|
|
|
2018-06-21 04:12:11 +00:00
|
|
|
part = each_lib.FindPart( new_name );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
if( part )
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return part;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-13 02:00:37 +00:00
|
|
|
static wxFileName GetRescueLibraryFileName( SCHEMATIC* aSchematic )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2020-05-13 02:00:37 +00:00
|
|
|
wxFileName fn = aSchematic->GetFileName();
|
2017-10-22 00:48:25 +00:00
|
|
|
fn.SetName( fn.GetName() + wxT( "-rescue" ) );
|
2020-05-15 13:25:11 +00:00
|
|
|
fn.SetExt( LegacySymbolLibFileExtension );
|
2017-10-22 00:48:25 +00:00
|
|
|
return fn;
|
|
|
|
}
|
2015-06-22 15:38:54 +00:00
|
|
|
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
RESCUE_CASE_CANDIDATE::RESCUE_CASE_CANDIDATE( const wxString& aRequestedName,
|
|
|
|
const wxString& aNewName,
|
2020-04-02 00:17:25 +00:00
|
|
|
LIB_PART* aLibCandidate,
|
|
|
|
int aUnit,
|
|
|
|
int aConvert )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
|
|
|
m_requested_name = aRequestedName;
|
|
|
|
m_new_name = aNewName;
|
|
|
|
m_lib_candidate = aLibCandidate;
|
2020-04-02 00:17:25 +00:00
|
|
|
m_unit = aUnit;
|
|
|
|
m_convert = aConvert;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
void RESCUE_CASE_CANDIDATE::FindRescues( RESCUER& aRescuer,
|
|
|
|
boost::ptr_vector<RESCUE_CANDIDATE>& aCandidates )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
typedef std::map<wxString, RESCUE_CASE_CANDIDATE> candidate_map_t;
|
|
|
|
candidate_map_t candidate_map;
|
|
|
|
// Remember the list of components is sorted by part name.
|
|
|
|
// So a search in libraries is made only once by group
|
2019-11-06 19:15:42 +00:00
|
|
|
LIB_PART* case_sensitive_match = nullptr;
|
|
|
|
std::vector<LIB_PART*> case_insensitive_matches;
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
wxString last_part_name;
|
2017-03-09 17:13:03 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
for( SCH_COMPONENT* each_component : *( aRescuer.GetComponents() ) )
|
|
|
|
{
|
|
|
|
wxString part_name = each_component->GetLibId().GetLibItemName();
|
2017-03-09 17:13:03 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
if( last_part_name != part_name )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
// A new part name is found (a new group starts here).
|
|
|
|
// Search the symbol names candidates only once for this group:
|
|
|
|
last_part_name = part_name;
|
|
|
|
case_insensitive_matches.clear();
|
2017-03-09 17:13:03 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
LIB_ID id( wxEmptyString, part_name );
|
2017-03-09 17:13:03 +00:00
|
|
|
|
2019-11-06 19:15:42 +00:00
|
|
|
case_sensitive_match = aRescuer.GetPrj()->SchLibs()->FindLibPart( id );
|
2017-03-10 09:31:50 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
if( !case_sensitive_match )
|
|
|
|
// the case sensitive match failed. Try a case insensitive match
|
|
|
|
aRescuer.GetPrj()->SchLibs()->FindLibraryNearEntries( case_insensitive_matches,
|
|
|
|
part_name );
|
|
|
|
}
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
if( case_sensitive_match || !( case_insensitive_matches.size() ) )
|
|
|
|
continue;
|
2017-03-10 09:31:50 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
RESCUE_CASE_CANDIDATE candidate( part_name, case_insensitive_matches[0]->GetName(),
|
2020-04-02 00:17:25 +00:00
|
|
|
case_insensitive_matches[0],
|
|
|
|
each_component->GetUnit(),
|
|
|
|
each_component->GetConvert() );
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
candidate_map[part_name] = candidate;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
// Now, dump the map into aCandidates
|
|
|
|
for( const candidate_map_t::value_type& each_pair : candidate_map )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
aCandidates.push_back( new RESCUE_CASE_CANDIDATE( each_pair.second ) );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
wxString RESCUE_CASE_CANDIDATE::GetActionDescription() const
|
|
|
|
{
|
|
|
|
wxString action;
|
|
|
|
action.Printf( _( "Rename to %s" ), m_new_name );
|
|
|
|
return action;
|
|
|
|
}
|
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
bool RESCUE_CASE_CANDIDATE::PerformAction( RESCUER* aRescuer )
|
|
|
|
{
|
|
|
|
for( SCH_COMPONENT* each_component : *aRescuer->GetComponents() )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
if( each_component->GetLibId().GetLibItemName() != UTF8( m_requested_name ) )
|
|
|
|
continue;
|
2017-01-31 01:31:19 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
LIB_ID libId;
|
2017-01-31 01:31:19 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
libId.SetLibItemName( m_new_name, false );
|
|
|
|
each_component->SetLibId( libId );
|
|
|
|
each_component->ClearFlags();
|
|
|
|
aRescuer->LogRescue( each_component, m_requested_name, m_new_name );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2015-06-22 15:38:54 +00:00
|
|
|
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
RESCUE_CACHE_CANDIDATE::RESCUE_CACHE_CANDIDATE( const wxString& aRequestedName,
|
|
|
|
const wxString& aNewName,
|
|
|
|
LIB_PART* aCacheCandidate,
|
2020-04-02 00:17:25 +00:00
|
|
|
LIB_PART* aLibCandidate,
|
|
|
|
int aUnit,
|
|
|
|
int aConvert )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
m_requested_name = aRequestedName;
|
|
|
|
m_new_name = aNewName;
|
|
|
|
m_cache_candidate = aCacheCandidate;
|
|
|
|
m_lib_candidate = aLibCandidate;
|
2020-04-02 00:17:25 +00:00
|
|
|
m_unit = aUnit;
|
|
|
|
m_convert = aConvert;
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
2015-06-22 15:38:54 +00:00
|
|
|
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
RESCUE_CACHE_CANDIDATE::RESCUE_CACHE_CANDIDATE()
|
|
|
|
{
|
|
|
|
m_cache_candidate = NULL;
|
|
|
|
m_lib_candidate = NULL;
|
|
|
|
}
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-03-09 17:13:03 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
void RESCUE_CACHE_CANDIDATE::FindRescues( RESCUER& aRescuer,
|
|
|
|
boost::ptr_vector<RESCUE_CANDIDATE>& aCandidates )
|
|
|
|
{
|
|
|
|
typedef std::map<wxString, RESCUE_CACHE_CANDIDATE> candidate_map_t;
|
|
|
|
candidate_map_t candidate_map;
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
// Remember the list of components is sorted by part name.
|
|
|
|
// So a search in libraries is made only once by group
|
|
|
|
LIB_PART* cache_match = nullptr;
|
|
|
|
LIB_PART* lib_match = nullptr;
|
|
|
|
wxString old_part_name;
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
for( SCH_COMPONENT* each_component : *( aRescuer.GetComponents() ) )
|
|
|
|
{
|
|
|
|
wxString part_name = each_component->GetLibId().GetLibItemName();
|
|
|
|
|
|
|
|
if( old_part_name != part_name )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
// A new part name is found (a new group starts here).
|
|
|
|
// Search the symbol names candidates only once for this group:
|
|
|
|
old_part_name = part_name;
|
|
|
|
cache_match = find_component( part_name, aRescuer.GetPrj()->SchLibs(), true );
|
2017-11-09 23:07:16 +00:00
|
|
|
lib_match = find_component( part_name, aRescuer.GetPrj()->SchLibs(), false );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2017-11-10 02:24:43 +00:00
|
|
|
if( !cache_match && !lib_match )
|
|
|
|
continue;
|
|
|
|
|
2017-11-23 15:52:28 +00:00
|
|
|
// Test whether there is a conflict or if the symbol can only be found in the cache
|
|
|
|
// and the symbol name does not have any illegal characters.
|
2018-07-26 14:38:30 +00:00
|
|
|
if( LIB_ID::HasIllegalChars( part_name, LIB_ID::ID_SCH ) == -1 )
|
|
|
|
{
|
|
|
|
if( cache_match && lib_match &&
|
|
|
|
!cache_match->PinsConflictWith( *lib_match, true, true, true, true, false ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if( !cache_match && lib_match )
|
|
|
|
continue;
|
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2017-11-09 23:07:16 +00:00
|
|
|
// Check if the symbol has already been rescued.
|
2018-04-13 09:26:28 +00:00
|
|
|
wxString new_name = LIB_ID::FixIllegalChars( part_name, LIB_ID::ID_SCH );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2020-04-02 00:17:25 +00:00
|
|
|
RESCUE_CACHE_CANDIDATE candidate( part_name, new_name, cache_match, lib_match,
|
|
|
|
each_component->GetUnit(),
|
|
|
|
each_component->GetConvert() );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
candidate_map[part_name] = candidate;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
// Now, dump the map into aCandidates
|
|
|
|
for( const candidate_map_t::value_type& each_pair : candidate_map )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
aCandidates.push_back( new RESCUE_CACHE_CANDIDATE( each_pair.second ) );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
wxString RESCUE_CACHE_CANDIDATE::GetActionDescription() const
|
|
|
|
{
|
|
|
|
wxString action;
|
2018-01-09 20:41:26 +00:00
|
|
|
|
|
|
|
if( !m_cache_candidate && !m_lib_candidate )
|
2018-01-10 13:48:00 +00:00
|
|
|
action.Printf( _( "Cannot rescue symbol %s which is not available in any library or "
|
2018-01-09 20:41:26 +00:00
|
|
|
"the cache." ), m_requested_name );
|
|
|
|
else if( m_cache_candidate && !m_lib_candidate )
|
|
|
|
action.Printf( _( "Rescue symbol %s found only in cache library to %s." ),
|
|
|
|
m_requested_name, m_new_name );
|
|
|
|
else
|
|
|
|
action.Printf( _( "Rescue modified symbol %s to %s" ),
|
|
|
|
m_requested_name, m_new_name );
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
return action;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool RESCUE_CACHE_CANDIDATE::PerformAction( RESCUER* aRescuer )
|
|
|
|
{
|
2018-01-08 22:33:01 +00:00
|
|
|
LIB_PART* tmp = ( m_cache_candidate ) ? m_cache_candidate : m_lib_candidate;
|
|
|
|
|
|
|
|
wxCHECK_MSG( tmp, false, "Both cache and library symbols undefined." );
|
|
|
|
|
2020-05-21 12:02:45 +00:00
|
|
|
std::unique_ptr<LIB_PART> new_part = tmp->Flatten();
|
|
|
|
new_part->SetName( m_new_name );
|
|
|
|
aRescuer->AddPart( new_part.get() );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
for( SCH_COMPONENT* each_component : *aRescuer->GetComponents() )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
if( each_component->GetLibId().GetLibItemName() != UTF8( m_requested_name ) )
|
|
|
|
continue;
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
LIB_ID libId;
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
libId.SetLibItemName( m_new_name, false );
|
|
|
|
each_component->SetLibId( libId );
|
|
|
|
each_component->ClearFlags();
|
|
|
|
aRescuer->LogRescue( each_component, m_requested_name, m_new_name );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
RESCUE_SYMBOL_LIB_TABLE_CANDIDATE::RESCUE_SYMBOL_LIB_TABLE_CANDIDATE(
|
|
|
|
const LIB_ID& aRequestedId,
|
|
|
|
const LIB_ID& aNewId,
|
|
|
|
LIB_PART* aCacheCandidate,
|
2020-04-02 00:17:25 +00:00
|
|
|
LIB_PART* aLibCandidate,
|
|
|
|
int aUnit,
|
|
|
|
int aConvert ) : RESCUE_CANDIDATE()
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
|
|
|
m_requested_id = aRequestedId;
|
2018-09-14 21:42:14 +00:00
|
|
|
m_requested_name = aRequestedId.Format();
|
2017-10-22 00:48:25 +00:00
|
|
|
m_new_id = aNewId;
|
|
|
|
m_lib_candidate = aLibCandidate;
|
|
|
|
m_cache_candidate = aCacheCandidate;
|
2020-04-02 00:17:25 +00:00
|
|
|
m_unit = aUnit;
|
|
|
|
m_convert = aConvert;
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
RESCUE_SYMBOL_LIB_TABLE_CANDIDATE::RESCUE_SYMBOL_LIB_TABLE_CANDIDATE()
|
|
|
|
{
|
|
|
|
m_cache_candidate = NULL;
|
|
|
|
m_lib_candidate = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RESCUE_SYMBOL_LIB_TABLE_CANDIDATE::FindRescues(
|
|
|
|
RESCUER& aRescuer,
|
|
|
|
boost::ptr_vector<RESCUE_CANDIDATE>& aCandidates )
|
|
|
|
{
|
|
|
|
typedef std::map<LIB_ID, RESCUE_SYMBOL_LIB_TABLE_CANDIDATE> candidate_map_t;
|
|
|
|
|
|
|
|
candidate_map_t candidate_map;
|
|
|
|
|
|
|
|
// Remember the list of components is sorted by LIB_ID.
|
|
|
|
// So a search in libraries is made only once by group
|
|
|
|
LIB_PART* cache_match = nullptr;
|
|
|
|
LIB_PART* lib_match = nullptr;
|
|
|
|
LIB_ID old_part_id;
|
|
|
|
|
|
|
|
for( SCH_COMPONENT* each_component : *( aRescuer.GetComponents() ) )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2019-12-05 15:40:22 +00:00
|
|
|
const LIB_ID& part_id = each_component->GetLibId();
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
if( old_part_id != part_id )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
// A new part name is found (a new group starts here).
|
|
|
|
// Search the symbol names candidates only once for this group:
|
|
|
|
old_part_id = part_id;
|
2019-12-09 19:47:29 +00:00
|
|
|
|
|
|
|
// Get the library symbol from the cache library. It will be a flattened
|
|
|
|
// symbol by default (no inheritance).
|
2018-01-09 20:41:26 +00:00
|
|
|
cache_match = find_component( part_id.Format().wx_str(), aRescuer.GetPrj()->SchLibs(),
|
2017-10-22 00:48:25 +00:00
|
|
|
true );
|
|
|
|
|
2019-12-09 19:47:29 +00:00
|
|
|
// Get the library symbol from the symbol library table.
|
2019-02-05 17:14:27 +00:00
|
|
|
lib_match = SchGetLibPart( part_id, aRescuer.GetPrj()->SchSymbolLibTable() );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2017-11-10 02:24:43 +00:00
|
|
|
if( !cache_match && !lib_match )
|
|
|
|
continue;
|
|
|
|
|
2019-12-09 19:47:29 +00:00
|
|
|
PART_SPTR lib_match_parent;
|
|
|
|
|
|
|
|
// If it's a derive symbol, use the parent symbol to perform the pin test.
|
|
|
|
if( lib_match && lib_match->IsAlias() )
|
|
|
|
{
|
|
|
|
lib_match_parent = lib_match->GetParent().lock();
|
|
|
|
|
|
|
|
if( !lib_match_parent )
|
|
|
|
{
|
|
|
|
lib_match = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
lib_match = lib_match_parent.get();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-11-09 23:07:16 +00:00
|
|
|
// Test whether there is a conflict or if the symbol can only be found in the cache.
|
2018-07-26 14:38:30 +00:00
|
|
|
if( LIB_ID::HasIllegalChars( part_id.GetLibItemName(), LIB_ID::ID_SCH ) == -1 )
|
2018-04-30 09:44:35 +00:00
|
|
|
{
|
2018-07-26 14:38:30 +00:00
|
|
|
if( cache_match && lib_match &&
|
|
|
|
!cache_match->PinsConflictWith( *lib_match, true, true, true, true, false ) )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if( !cache_match && lib_match )
|
|
|
|
continue;
|
2018-04-30 09:44:35 +00:00
|
|
|
}
|
2017-01-31 01:31:19 +00:00
|
|
|
|
2018-01-09 20:41:26 +00:00
|
|
|
// Fix illegal LIB_ID name characters.
|
2018-04-13 09:26:28 +00:00
|
|
|
wxString new_name = LIB_ID::FixIllegalChars( part_id.GetLibItemName(), LIB_ID::ID_SCH );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2018-04-30 09:44:35 +00:00
|
|
|
// Differentiate symbol name in the rescue library by appending the symbol library
|
2018-01-09 20:41:26 +00:00
|
|
|
// table nickname to the symbol name to prevent name clashes in the rescue library.
|
2020-05-13 02:00:37 +00:00
|
|
|
wxString libNickname = GetRescueLibraryFileName( aRescuer.Schematic() ).GetName();
|
2018-01-10 21:04:32 +00:00
|
|
|
|
|
|
|
// Spaces in the file name will break the symbol name because they are not
|
|
|
|
// quoted in the symbol library file format.
|
|
|
|
libNickname.Replace( " ", "-" );
|
|
|
|
LIB_ID new_id( libNickname, new_name + "-" + part_id.GetLibNickname().wx_str() );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2020-04-02 00:17:25 +00:00
|
|
|
RESCUE_SYMBOL_LIB_TABLE_CANDIDATE candidate( part_id, new_id, cache_match, lib_match,
|
|
|
|
each_component->GetUnit(),
|
|
|
|
each_component->GetConvert() );
|
2017-01-31 01:31:19 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
candidate_map[part_id] = candidate;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
// Now, dump the map into aCandidates
|
|
|
|
for( const candidate_map_t::value_type& each_pair : candidate_map )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
aCandidates.push_back( new RESCUE_SYMBOL_LIB_TABLE_CANDIDATE( each_pair.second ) );
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
2017-01-27 15:56:36 +00:00
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
wxString RESCUE_SYMBOL_LIB_TABLE_CANDIDATE::GetActionDescription() const
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
wxString action;
|
2018-01-09 20:41:26 +00:00
|
|
|
|
|
|
|
if( !m_cache_candidate && !m_lib_candidate )
|
2018-01-10 13:48:00 +00:00
|
|
|
action.Printf( _( "Cannot rescue symbol %s which is not available in any library or "
|
2018-01-09 20:41:26 +00:00
|
|
|
"the cache." ), m_requested_id.GetLibItemName().wx_str() );
|
|
|
|
else if( m_cache_candidate && !m_lib_candidate )
|
|
|
|
action.Printf( _( "Rescue symbol %s found only in cache library to %s." ),
|
|
|
|
m_requested_id.Format().wx_str(), m_new_id.Format().wx_str() );
|
|
|
|
else
|
|
|
|
action.Printf( _( "Rescue modified symbol %s to %s" ),
|
|
|
|
m_requested_id.Format().wx_str(), m_new_id.Format().wx_str() );
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
return action;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
bool RESCUE_SYMBOL_LIB_TABLE_CANDIDATE::PerformAction( RESCUER* aRescuer )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2018-01-08 22:33:01 +00:00
|
|
|
LIB_PART* tmp = ( m_cache_candidate ) ? m_cache_candidate : m_lib_candidate;
|
|
|
|
|
|
|
|
wxCHECK_MSG( tmp, false, "Both cache and library symbols undefined." );
|
|
|
|
|
2020-05-21 12:02:45 +00:00
|
|
|
std::unique_ptr<LIB_PART> new_part = tmp->Flatten();
|
|
|
|
new_part->SetLibId( m_new_id );
|
|
|
|
new_part->SetName( m_new_id.GetLibItemName() );
|
|
|
|
aRescuer->AddPart( new_part.get() );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
for( SCH_COMPONENT* each_component : *aRescuer->GetComponents() )
|
|
|
|
{
|
|
|
|
if( each_component->GetLibId() != m_requested_id )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
each_component->SetLibId( m_new_id );
|
|
|
|
each_component->ClearFlags();
|
|
|
|
aRescuer->LogRescue( each_component, m_requested_id.Format(), m_new_id.Format() );
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-13 02:00:37 +00:00
|
|
|
RESCUER::RESCUER( PROJECT& aProject, SCHEMATIC* aSchematic, SCH_SHEET_PATH* aCurrentSheet,
|
2019-02-05 17:14:27 +00:00
|
|
|
EDA_DRAW_PANEL_GAL::GAL_TYPE aGalBackEndType )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2020-05-13 02:00:37 +00:00
|
|
|
m_schematic = aSchematic ? aSchematic : aCurrentSheet->LastScreen()->Schematic();
|
|
|
|
|
|
|
|
wxASSERT( m_schematic );
|
|
|
|
|
2020-05-19 02:58:28 +00:00
|
|
|
if( m_schematic )
|
|
|
|
get_components( m_schematic, m_components );
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
m_prj = &aProject;
|
2019-02-05 17:14:27 +00:00
|
|
|
m_currentSheet = aCurrentSheet;
|
|
|
|
m_galBackEndType = aGalBackEndType;
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RESCUER::LogRescue( SCH_COMPONENT *aComponent, const wxString &aOldName,
|
2017-10-22 00:48:25 +00:00
|
|
|
const wxString &aNewName )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
|
|
|
RESCUE_LOG logitem;
|
|
|
|
logitem.component = aComponent;
|
|
|
|
logitem.old_name = aOldName;
|
|
|
|
logitem.new_name = aNewName;
|
|
|
|
m_rescue_log.push_back( logitem );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool RESCUER::DoRescues()
|
|
|
|
{
|
2016-06-29 20:07:55 +00:00
|
|
|
for( RESCUE_CANDIDATE* each_candidate : m_chosen_candidates )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
|
|
|
if( ! each_candidate->PerformAction( this ) )
|
|
|
|
return false;
|
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void RESCUER::UndoRescues()
|
|
|
|
{
|
2016-06-29 20:07:55 +00:00
|
|
|
for( RESCUE_LOG& each_logitem : m_rescue_log )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-01-31 01:31:19 +00:00
|
|
|
LIB_ID libId;
|
|
|
|
|
2017-07-24 19:02:59 +00:00
|
|
|
libId.SetLibItemName( each_logitem.old_name, false );
|
2017-01-31 01:31:19 +00:00
|
|
|
each_logitem.component->SetLibId( libId );
|
2015-06-25 08:53:45 +00:00
|
|
|
each_logitem.component->ClearFlags();
|
2015-06-22 15:38:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
bool RESCUER::RescueProject( wxWindow* aParent, RESCUER& aRescuer, bool aRunningOnDemand )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
|
|
|
aRescuer.FindCandidates();
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
if( !aRescuer.GetCandidateCount() )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
|
|
|
if( aRunningOnDemand )
|
|
|
|
{
|
2019-02-05 17:14:27 +00:00
|
|
|
wxMessageDialog dlg( aParent, _( "This project has nothing to rescue." ),
|
2017-10-22 00:48:25 +00:00
|
|
|
_( "Project Rescue Helper" ) );
|
2015-06-22 15:38:54 +00:00
|
|
|
dlg.ShowModal();
|
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2015-06-22 15:38:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
aRescuer.RemoveDuplicates();
|
2019-02-05 17:14:27 +00:00
|
|
|
aRescuer.InvokeDialog( aParent, !aRunningOnDemand );
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
// If no symbols were rescued, let the user know what's going on. He might
|
2015-06-22 15:38:54 +00:00
|
|
|
// have clicked cancel by mistake, and should have some indication of that.
|
2017-10-22 00:48:25 +00:00
|
|
|
if( !aRescuer.GetChosenCandidateCount() )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2019-02-05 17:14:27 +00:00
|
|
|
wxMessageDialog dlg( aParent, _( "No symbols were rescued." ),
|
2017-10-22 00:48:25 +00:00
|
|
|
_( "Project Rescue Helper" ) );
|
2015-06-22 15:38:54 +00:00
|
|
|
dlg.ShowModal();
|
2015-06-29 16:31:00 +00:00
|
|
|
|
|
|
|
// Set the modified flag even on Cancel. Many users seem to instinctively want to Save at
|
|
|
|
// this point, due to the reloading of the symbols, so we'll make the save button active.
|
2015-06-22 15:38:54 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
aRescuer.OpenRescueLibrary();
|
2015-06-22 15:38:54 +00:00
|
|
|
|
2017-10-22 00:48:25 +00:00
|
|
|
if( !aRescuer.DoRescues() )
|
2015-06-22 15:38:54 +00:00
|
|
|
{
|
2017-10-22 00:48:25 +00:00
|
|
|
aRescuer.UndoRescues();
|
2015-06-22 15:38:54 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
aRescuer.WriteRescueLibrary( aParent );
|
2015-06-22 15:38:54 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
|
|
|
|
void RESCUER::RemoveDuplicates()
|
|
|
|
{
|
|
|
|
std::vector<wxString> names_seen;
|
|
|
|
|
|
|
|
for( boost::ptr_vector<RESCUE_CANDIDATE>::iterator it = m_all_candidates.begin();
|
|
|
|
it != m_all_candidates.end(); )
|
|
|
|
{
|
|
|
|
bool seen_already = false;
|
|
|
|
|
|
|
|
for( wxString& name_seen : names_seen )
|
|
|
|
{
|
|
|
|
if( name_seen == it->GetRequestedName() )
|
|
|
|
{
|
|
|
|
seen_already = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( seen_already )
|
|
|
|
{
|
|
|
|
it = m_all_candidates.erase( it );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
names_seen.push_back( it->GetRequestedName() );
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LEGACY_RESCUER::FindCandidates()
|
|
|
|
{
|
|
|
|
RESCUE_CASE_CANDIDATE::FindRescues( *this, m_all_candidates );
|
|
|
|
RESCUE_CACHE_CANDIDATE::FindRescues( *this, m_all_candidates );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
void LEGACY_RESCUER::InvokeDialog( wxWindow* aParent, bool aAskShowAgain )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
2019-02-05 17:14:27 +00:00
|
|
|
InvokeDialogRescueEach( aParent, static_cast< RESCUER& >( *this ), m_currentSheet,
|
|
|
|
m_galBackEndType, aAskShowAgain );
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LEGACY_RESCUER::OpenRescueLibrary()
|
|
|
|
{
|
2020-05-13 02:00:37 +00:00
|
|
|
wxFileName fn = GetRescueLibraryFileName( m_schematic );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
2020-10-14 01:33:15 +00:00
|
|
|
std::unique_ptr<PART_LIB> rescue_lib(
|
|
|
|
new PART_LIB( SCH_LIB_TYPE::LT_EESCHEMA, fn.GetFullPath() ) );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
m_rescue_lib = std::move( rescue_lib );
|
|
|
|
m_rescue_lib->EnableBuffering();
|
2017-11-10 02:24:43 +00:00
|
|
|
|
|
|
|
// If a rescue library already exists copy the contents of that library so we do not
|
|
|
|
// lose an previous rescues.
|
|
|
|
PART_LIB* rescueLib = m_prj->SchLibs()->FindLibrary( fn.GetName() );
|
|
|
|
|
|
|
|
if( rescueLib )
|
|
|
|
{
|
|
|
|
// For items in the rescue library, aliases are the root symbol.
|
2019-11-06 19:15:42 +00:00
|
|
|
std::vector< LIB_PART* > symbols;
|
2017-11-10 02:24:43 +00:00
|
|
|
|
2019-11-06 19:15:42 +00:00
|
|
|
rescueLib->GetParts( symbols );
|
2017-11-10 02:24:43 +00:00
|
|
|
|
2019-11-06 19:15:42 +00:00
|
|
|
for( auto symbol : symbols )
|
2017-11-10 02:24:43 +00:00
|
|
|
{
|
2019-11-06 19:15:42 +00:00
|
|
|
// The LIB_PART copy constructor flattens derived symbols (formerly known as aliases).
|
|
|
|
m_rescue_lib->AddPart( new LIB_PART( *symbol, m_rescue_lib.get() ) );
|
2017-11-10 02:24:43 +00:00
|
|
|
}
|
|
|
|
}
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
bool LEGACY_RESCUER::WriteRescueLibrary( wxWindow *aParent )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
m_rescue_lib->Save( false );
|
|
|
|
}
|
|
|
|
catch( ... /* IO_ERROR ioe */ )
|
|
|
|
{
|
|
|
|
wxString msg;
|
|
|
|
|
2017-12-15 11:37:46 +00:00
|
|
|
msg.Printf( _( "Failed to create symbol library file \"%s\"" ),
|
2017-10-22 00:48:25 +00:00
|
|
|
m_rescue_lib->GetFullFileName() );
|
2019-02-05 17:14:27 +00:00
|
|
|
DisplayError( aParent, msg );
|
2017-10-22 00:48:25 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
wxArrayString libNames;
|
|
|
|
wxString libPaths;
|
|
|
|
|
|
|
|
wxString libName = m_rescue_lib->GetName();
|
|
|
|
PART_LIBS *libs = dynamic_cast<PART_LIBS*>( m_prj->GetElem( PROJECT::ELEM_SCH_PART_LIBS ) );
|
|
|
|
|
|
|
|
if( !libs )
|
|
|
|
{
|
|
|
|
libs = new PART_LIBS();
|
|
|
|
m_prj->SetElem( PROJECT::ELEM_SCH_PART_LIBS, libs );
|
|
|
|
}
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
PART_LIBS::LibNamesAndPaths( m_prj, false, &libPaths, &libNames );
|
|
|
|
|
|
|
|
// Make sure the library is not already in the list
|
|
|
|
while( libNames.Index( libName ) != wxNOT_FOUND )
|
|
|
|
libNames.Remove( libName );
|
|
|
|
|
|
|
|
// Add the library to the top of the list and save.
|
|
|
|
libNames.Insert( libName, 0 );
|
|
|
|
PART_LIBS::LibNamesAndPaths( m_prj, true, &libPaths, &libNames );
|
|
|
|
}
|
|
|
|
catch( const IO_ERROR& )
|
|
|
|
{
|
|
|
|
// Could not get or save the current libraries.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Save the old libraries in case there is a problem after clear(). We'll
|
|
|
|
// put them back in.
|
|
|
|
boost::ptr_vector<PART_LIB> libsSave;
|
|
|
|
libsSave.transfer( libsSave.end(), libs->begin(), libs->end(), *libs );
|
|
|
|
|
|
|
|
m_prj->SetElem( PROJECT::ELEM_SCH_PART_LIBS, NULL );
|
|
|
|
|
|
|
|
libs = new PART_LIBS();
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
libs->LoadAllLibraries( m_prj );
|
|
|
|
}
|
|
|
|
catch( const PARSE_ERROR& )
|
|
|
|
{
|
|
|
|
// Some libraries were not found. There's no point in showing the error,
|
|
|
|
// because it was already shown. Just don't do anything.
|
|
|
|
}
|
|
|
|
catch( const IO_ERROR& )
|
|
|
|
{
|
|
|
|
// Restore the old list
|
|
|
|
libs->clear();
|
|
|
|
libs->transfer( libs->end(), libsSave.begin(), libsSave.end(), libsSave );
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_prj->SetElem( PROJECT::ELEM_SCH_PART_LIBS, libs );
|
|
|
|
|
|
|
|
// Update the schematic symbol library links since the library list has changed.
|
2020-05-13 02:00:37 +00:00
|
|
|
SCH_SCREENS schematic( m_schematic->Root() );
|
2017-10-22 00:48:25 +00:00
|
|
|
schematic.UpdateSymbolLinks();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LEGACY_RESCUER::AddPart( LIB_PART* aNewPart )
|
|
|
|
{
|
|
|
|
wxCHECK_RET( aNewPart, "Invalid LIB_PART pointer." );
|
|
|
|
|
|
|
|
aNewPart->SetLib( m_rescue_lib.get() );
|
|
|
|
m_rescue_lib->AddPart( aNewPart );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-13 02:00:37 +00:00
|
|
|
SYMBOL_LIB_TABLE_RESCUER::SYMBOL_LIB_TABLE_RESCUER( PROJECT& aProject, SCHEMATIC* aSchematic,
|
2019-02-05 17:14:27 +00:00
|
|
|
SCH_SHEET_PATH* aCurrentSheet,
|
|
|
|
EDA_DRAW_PANEL_GAL::GAL_TYPE aGalBackEndType ) :
|
2020-05-13 02:00:37 +00:00
|
|
|
RESCUER( aProject, aSchematic, aCurrentSheet, aGalBackEndType )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
|
|
|
m_properties = std::make_unique<PROPERTIES>();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SYMBOL_LIB_TABLE_RESCUER::FindCandidates()
|
|
|
|
{
|
|
|
|
RESCUE_SYMBOL_LIB_TABLE_CANDIDATE::FindRescues( *this, m_all_candidates );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
void SYMBOL_LIB_TABLE_RESCUER::InvokeDialog( wxWindow* aParent, bool aAskShowAgain )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
2019-02-05 17:14:27 +00:00
|
|
|
InvokeDialogRescueEach( aParent, static_cast< RESCUER& >( *this ), m_currentSheet,
|
|
|
|
m_galBackEndType, aAskShowAgain );
|
2017-10-22 00:48:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SYMBOL_LIB_TABLE_RESCUER::OpenRescueLibrary()
|
|
|
|
{
|
|
|
|
m_pi.set( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_LEGACY ) );
|
|
|
|
(*m_properties)[ SCH_LEGACY_PLUGIN::PropBuffering ] = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-02-05 17:14:27 +00:00
|
|
|
bool SYMBOL_LIB_TABLE_RESCUER::WriteRescueLibrary( wxWindow *aParent )
|
2017-10-22 00:48:25 +00:00
|
|
|
{
|
|
|
|
wxString msg;
|
2020-05-13 02:00:37 +00:00
|
|
|
wxFileName fn = GetRescueLibraryFileName( m_schematic );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
// If the rescue library already exists in the symbol library table no need save it to add
|
|
|
|
// it to the table.
|
|
|
|
if( !m_prj->SchSymbolLibTable()->HasLibrary( fn.GetName() ) )
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
m_pi->SaveLibrary( fn.GetFullPath() );
|
|
|
|
}
|
|
|
|
catch( const IO_ERROR& ioe )
|
|
|
|
{
|
|
|
|
msg.Printf( _( "Failed to save rescue library %s." ), fn.GetFullPath() );
|
2019-02-05 17:14:27 +00:00
|
|
|
DisplayErrorMessage( aParent, msg, ioe.What() );
|
2017-10-22 00:48:25 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
wxString uri = "${KIPRJMOD}/" + fn.GetFullName();
|
2018-01-10 21:04:32 +00:00
|
|
|
wxString libNickname = fn.GetName();
|
|
|
|
|
|
|
|
// Spaces in the file name will break the symbol name because they are not
|
|
|
|
// quoted in the symbol library file format.
|
|
|
|
libNickname.Replace( " ", "-" );
|
|
|
|
|
|
|
|
SYMBOL_LIB_TABLE_ROW* row = new SYMBOL_LIB_TABLE_ROW( libNickname, uri,
|
2017-10-22 00:48:25 +00:00
|
|
|
wxString( "Legacy" ) );
|
|
|
|
m_prj->SchSymbolLibTable()->InsertRow( row );
|
|
|
|
|
|
|
|
fn = wxFileName( m_prj->GetProjectPath(), SYMBOL_LIB_TABLE::GetSymbolLibTableFileName() );
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
m_prj->SchSymbolLibTable()->Save( fn.GetFullPath() );
|
|
|
|
}
|
|
|
|
catch( const IO_ERROR& ioe )
|
|
|
|
{
|
|
|
|
msg.Printf( _( "Error occurred saving project specific symbol library table." ) );
|
2019-02-05 17:14:27 +00:00
|
|
|
DisplayErrorMessage( aParent, msg, ioe.What() );
|
2017-10-22 00:48:25 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Relaod the symbol library table.
|
|
|
|
m_prj->SetElem( PROJECT::ELEM_SYMBOL_LIB_TABLE, NULL );
|
|
|
|
|
|
|
|
// This can only happen if the symbol library table file was currupted on write.
|
|
|
|
if( !m_prj->SchSymbolLibTable() )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Update the schematic symbol library links since the library list has changed.
|
2020-05-13 02:00:37 +00:00
|
|
|
SCH_SCREENS schematic( m_schematic->Root() );
|
2020-04-16 16:43:50 +00:00
|
|
|
schematic.UpdateSymbolLinks();
|
2017-10-22 00:48:25 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void SYMBOL_LIB_TABLE_RESCUER::AddPart( LIB_PART* aNewPart )
|
|
|
|
{
|
|
|
|
wxCHECK_RET( aNewPart, "Invalid LIB_PART pointer." );
|
|
|
|
|
2020-05-13 02:00:37 +00:00
|
|
|
wxFileName fn = GetRescueLibraryFileName( m_schematic );
|
2017-10-22 00:48:25 +00:00
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
if( !m_prj->SchSymbolLibTable()->HasLibrary( fn.GetName() ) )
|
|
|
|
m_pi->SaveSymbol( fn.GetFullPath(), new LIB_PART( *aNewPart ), m_properties.get() );
|
|
|
|
else
|
|
|
|
m_prj->SchSymbolLibTable()->SaveSymbol( fn.GetName(), new LIB_PART( *aNewPart ) );
|
|
|
|
}
|
|
|
|
catch( ... /* IO_ERROR */ )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
}
|