import_proj.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 */
 
#include "import_proj.h"
 
#include <list>
 
#include <import_proj_properties.h>
#include <confirm.h>
#include <kidialog.h>
#include <wildcards_and_files_ext.h>
#include <macros.h>
#include <string_utils.h>
#include <richio.h>
 
#include <wx/fileconf.h>
#include <wx/filedlg.h>
#include <wx/msgdlg.h>
#include <wx/tokenzr.h>
#include <wx/dir.h>
#include <wx/textfile.h>
#include <wx/wfstream.h>
 
#include <kiway.h>
#include <kiway_player.h>
#include <kicad_manager_frame.h>
#include <pcb_edit_frame.h>
#include <sch_edit_frame.h>
 
#include <sch_io/sch_io_mgr.h>
#include <pcb_io/pcb_io_mgr.h>
#include <project_sch.h>
#include <project_pcb.h>
 
#include <io/easyedapro/easyedapro_import_utils.h>
#include <io/easyedapro/easyedapro_parser.h>
#include <io/easyedapro/easyedapro_v3_parser.h>
#include <io/common/plugin_common_choose_project.h>
#include <io/pads/pads_common.h>
#include <io/easypc/easypc_classes_project.h>
#include <io/easypc/easypc_document.h>
#include <dialogs/dialog_import_choose_project.h>
 
#include <wx/log.h>
 
 
IMPORT_PROJ_HELPER::IMPORT_PROJ_HELPER( KICAD_MANAGER_FRAME*         aFrame,
                                        const std::vector<wxString>& aSchFileExtensions,
                                        const std::vector<wxString>& aPcbFileExtensions ) :
        m_frame( aFrame ),
        m_schExtenstions( aSchFileExtensions ), m_pcbExtenstions( aPcbFileExtensions )
{
}
 
 
void IMPORT_PROJ_HELPER::FindEmptyTargetDir()
{
    // Append a new directory with the same name of the project file
    // Keep iterating until we find an empty directory
    wxString newDir = m_TargetProj.GetName();
    int      attempt = 0;
 
    m_TargetProj.AppendDir( newDir );
 
    while( m_TargetProj.DirExists() )
    {
        m_TargetProj.RemoveLastDir();
        wxString suffix = wxString::Format( "_%d", ++attempt );
        m_TargetProj.AppendDir( newDir + suffix );
    }
}
 
 
class SCOPED_FILE_REMOVER
{
public:
    SCOPED_FILE_REMOVER( const wxString& aFile ) :
            m_file( aFile )
    {
    }
 
    ~SCOPED_FILE_REMOVER()
    {
        wxRemoveFile( m_file );
    }
 
    // No copy operations allowed or the destructor might remove files multiple times.
    SCOPED_FILE_REMOVER( SCOPED_FILE_REMOVER const& ) = delete;
    SCOPED_FILE_REMOVER& operator=( SCOPED_FILE_REMOVER const& ) = delete;
 
private:
    wxString m_file;
};
 
 
void IMPORT_PROJ_HELPER::ImportIndividualFile( KICAD_T aFT, int aImportedFileType )
{
    FRAME_T               frame_type;
    wxString              appImportFile;
    std::vector<wxString> neededExts;
 
    switch( aFT )
    {
    case SCHEMATIC_T:
        neededExts = m_schExtenstions;
        frame_type = FRAME_SCH;
        break;
 
    case PCB_T:
        neededExts = m_pcbExtenstions;
        frame_type = FRAME_PCB_EDITOR;
        break;
 
    default: return;
    }
 
    std::list<SCOPED_FILE_REMOVER> copiedFiles;
 
    for( wxString ext : neededExts )
    {
        if( ext == wxS( "INPUT" ) )
            ext = m_InputFile.GetExt();
 
        wxFileName candidate = m_InputFile;
 
        // Selected file often the one wanted (e.g. schematic in schematic-only
        // import); keep on-disk name so uppercase ext still resolves on
        // case-sensitive fs. Rewrite ext only when seeking differently-typed sibling
        if( m_InputFile.GetExt().CmpNoCase( ext ) != 0 )
            candidate.SetExt( ext );
 
        if( !candidate.FileExists() )
            continue;
 
        wxFileName targetFile( m_TargetProj.GetPath(), candidate.GetName(), candidate.GetExt() );
 
        if( !targetFile.FileExists() )
        {
            bool copied = wxCopyFile( candidate.GetFullPath(), targetFile.GetFullPath(), false );
 
            if( copied )
            {
                // Will be auto-removed
                copiedFiles.emplace_back( targetFile.GetFullPath() );
            }
        }
 
        // Pick the first file to pass to application
        if( appImportFile.empty() && targetFile.FileExists() )
            appImportFile = targetFile.GetFullPath();
    }
 
    if( appImportFile.empty() )
        return;
 
    doImport( appImportFile, frame_type, aImportedFileType );
}
 
 
void IMPORT_PROJ_HELPER::doImport( const wxString& aFile, FRAME_T aFrameType, int aImportedFileType )
{
    if( KIWAY_PLAYER* frame = m_frame->Kiway().Player( aFrameType, true ) )
    {
        std::stringstream ss;
        ss << aImportedFileType << '\n' << TO_UTF8( aFile );
 
        for( const auto& [key, value] : m_properties )
            ss << '\n' << key << '\n' << value.wx_str();
 
        std::string packet = ss.str();
        frame->Kiway().ExpressMail( aFrameType, MAIL_IMPORT_FILE, packet, m_frame );
 
        // Editors reply with an empty packet when the import fails
        if( !packet.empty() )
            m_importedFrames.insert( aFrameType );
 
        if( aFrameType == FRAME_SCH && aImportedFileType == SCH_IO_MGR::SCH_ORCAD
            && IMPORT_PROJ_PROPS::SplitNetNameMap( From_UTF8( packet ) ) )
            m_properties[IMPORT_PROJ_PROPS::NET_NAME_MAP] = packet;
 
        if( !frame->IsShownOnScreen() )
            frame->Show( true );
 
        // On Windows, Raise() does not bring the window on screen, when iconized
        if( frame->IsIconized() )
            frame->Iconize( false );
 
        frame->Raise();
    }
}
 
 
void IMPORT_PROJ_HELPER::SaveImportedFiles()
{
    for( FRAME_T frameType : m_importedFrames )
    {
        std::string payload;
        MAIL_T      mail = frameType == FRAME_SCH ? MAIL_SCH_SAVE : MAIL_PCB_SAVE;
 
        m_frame->Kiway().ExpressMail( frameType, mail, payload, m_frame );
    }
}
 
 
void IMPORT_PROJ_HELPER::EasyEDAProProjectHandler( int aImportedSchFileType, int aImportedPcbFileType )
{
    const bool isV3 =
            aImportedSchFileType == SCH_IO_MGR::SCH_EASYEDAPRO_V3 || aImportedPcbFileType == PCB_IO_MGR::EASYEDAPRO_V3;
 
    // Sch/PCB importers both assign FPIDs under ShortenLibName( archive ); advertise that
    // nickname as the source footprint lib so post-import reconciler keeps it (instead of
    // rewriting schematic Footprint fields onto the generated *-import-fps cache).
    wxArrayString sourceFpLibs;
    sourceFpLibs.Add( EASYEDAPRO::ShortenLibName( m_InputFile.GetName() ) );
    m_properties[IMPORT_PROJ_PROPS::SOURCE_FP_LIBS] = IMPORT_PROJ_PROPS::JoinList( sourceFpLibs );
 
    nlohmann::json project;
 
    if( isV3 )
    {
        // For v3, build a minimal legacy-format project from raw documents
        EASYEDAPRO::V3_DOC_PARSER adapter( m_InputFile.GetFullPath() );
        adapter.Load();
        project = EASYEDAPRO::BuildV3ProjectIndexFromRawDocs( adapter, false );
    }
    else
    {
        project = EASYEDAPRO::ReadProjectOrDeviceFile( m_InputFile.GetFullPath() );
    }
 
    std::vector<IMPORT_PROJECT_DESC> toImport = EASYEDAPRO::ProjectToSelectorDialog( project, false, false );
 
    if( toImport.size() > 1 )
        toImport = DIALOG_IMPORT_CHOOSE_PROJECT::RunModal( m_frame, toImport );
 
    if( toImport.size() == 1 )
    {
        const IMPORT_PROJECT_DESC& desc = toImport[0];
        wxString                   pcbId = desc.PCBId;
        wxString                   schId = desc.SchematicId;
 
        if( pcbId.empty() && project.contains( "pcbs" ) && project.at( "pcbs" ).is_object()
            && project.at( "pcbs" ).size() == 1 )
        {
            pcbId = wxString::FromUTF8( project.at( "pcbs" ).begin().key() );
        }
 
        if( schId.empty() && project.contains( "schematics" ) && project.at( "schematics" ).is_object()
            && project.at( "schematics" ).size() == 1 )
        {
            schId = wxString::FromUTF8( project.at( "schematics" ).begin().key() );
        }
 
        if( !pcbId.empty() )
            m_properties["pcb_id"] = pcbId;
 
        if( !schId.empty() )
            m_properties["sch_id"] = schId;
    }
    else
    {
        m_properties["pcb_id"] = "";
        m_properties["sch_id"] = "";
    }
}
 
 
void IMPORT_PROJ_HELPER::setImportCacheNickname()
{
    // fresh empty target dir, so a stem-derived name is collision-free; reconciler still guards on-disk
    wxString stem = m_TargetProj.GetName();
 
    if( stem.IsEmpty() )
        stem = m_InputFile.GetName();
 
    m_properties[IMPORT_PROJ_PROPS::FP_CACHE_NICKNAME] = IMPORT_PROJ_PROPS::MakeCacheNickname( stem );
}
 
 
wxString IMPORT_PROJ_HELPER::joinSourceLibNicknames( const std::set<wxString>& aPaths ) const
{
    wxArrayString nicks;
 
    for( const wxString& path : aPaths )
    {
        wxString nick = wxFileName( path ).GetName();
 
        if( !nick.IsEmpty() )
            nicks.Add( nick );
    }
 
    return IMPORT_PROJ_PROPS::JoinList( nicks );
}
 
 
void IMPORT_PROJ_HELPER::addLocalLibraries( const std::set<wxString>& aNames, FRAME_T aFrameType )
{
    KIWAY_PLAYER* frame = m_frame->Kiway().Player( aFrameType, true );
 
    std::stringstream ss;
 
    // First line is the source project directory so the handler can distinguish
    // project-local libraries from external fixed-path references.
    ss << TO_UTF8( m_InputFile.GetPath() ) << '\n';
 
    for( const wxString& name : aNames )
    {
        wxFileName fname( name );
        fname.MakeAbsolute( m_InputFile.GetPath() );
        ss << TO_UTF8( fname.GetFullPath() ) << '\n';
    }
 
    std::string packet = ss.str();
    frame->Kiway().ExpressMail( aFrameType, MAIL_ADD_LOCAL_LIB, packet, m_frame );
}
 
 
void IMPORT_PROJ_HELPER::AltiumProjectHandler()
{
    wxFileConfig config( wxEmptyString, wxEmptyString, wxEmptyString, m_InputFile.GetFullPath(),
                         wxCONFIG_USE_NO_ESCAPE_CHARACTERS );
 
    wxString groupname;
    long groupid;
 
    std::set<wxString> sch_file;
    std::set<wxString> sch_libs;
    std::set<wxString> pcb_libs;
 
    wxString pcb_file;
    int      pcb_file_type = PCB_IO_MGR::ALTIUM_DESIGNER;
 
    auto matchPcbExt = []( const wxString& aExt ) -> int
    {
        if( !aExt.CmpNoCase( wxS( "PcbDoc" ) ) )
            return PCB_IO_MGR::ALTIUM_DESIGNER;
 
        if( !aExt.CmpNoCase( wxS( "CSPcbDoc" ) ) )
            return PCB_IO_MGR::ALTIUM_CIRCUIT_STUDIO;
 
        if( !aExt.CmpNoCase( wxS( "CMPcbDoc" ) ) )
            return PCB_IO_MGR::ALTIUM_CIRCUIT_MAKER;
 
        if( !aExt.CmpNoCase( wxS( "SWPcbDoc" ) ) )
            return PCB_IO_MGR::SOLIDWORKS_PCB;
 
        return -1;
    };
 
    for( bool more = config.GetFirstGroup( groupname, groupid ); more;
         more = config.GetNextGroup( groupname, groupid ) )
    {
        if( !groupname.StartsWith( wxS( "Document" ) ) )
            continue;
 
        wxString number = groupname.Mid( 8 );
        long docNumber;
 
        if( !number.ToLong( &docNumber ) )
            continue;
 
        wxString path = config.Read( groupname + wxS( "/DocumentPath" ), wxEmptyString );
 
        if( path.empty() )
            continue;
 
        wxFileName fname( path, wxPATH_WIN );
 
        if( !fname.IsAbsolute() )
            fname.MakeAbsolute( m_InputFile.GetPath() );
 
        int pcbType = matchPcbExt( fname.GetExt() );
 
        if( pcbType >= 0 && pcb_file.empty() )
        {
            pcb_file = fname.GetFullPath();
            pcb_file_type = pcbType;
        }
 
        if( !fname.GetExt().CmpNoCase( "SCHDOC" ) )
            sch_file.insert( fname.GetFullPath() );
 
        if( !fname.GetExt().CmpNoCase( "PCBLIB" ) )
            pcb_libs.insert( fname.GetFullPath() );
 
        if( !fname.GetExt().CmpNoCase( "SCHLIB" ) )
            sch_libs.insert( fname.GetFullPath() );
    }
 
    addLocalLibraries( sch_libs, FRAME_SCH );
    addLocalLibraries( pcb_libs, FRAME_PCB_EDITOR );
 
    // pass source fp libs to both imports so found footprints relink to source, not the cache
    m_properties[IMPORT_PROJ_PROPS::SOURCE_FP_LIBS] = joinSourceLibNicknames( pcb_libs );
 
    m_properties["project_file"] = m_InputFile.GetFullPath();
 
    int ii = 0;
 
    for( auto& path : sch_file )
    {
        std::string key = "sch" + std::to_string( ii++ );
        m_properties[key] = path.ToStdString();
    }
 
    if( !sch_file.empty() )
        doImport( "", FRAME_SCH, SCH_IO_MGR::SCH_ALTIUM );
 
    if( !pcb_file.empty() )
        doImport( pcb_file, FRAME_PCB_EDITOR, pcb_file_type );
}
 
 
void IMPORT_PROJ_HELPER::ImportPadsFiles()
{
    m_properties.clear();
 
    PADS_COMMON::RELATED_FILES related = PADS_COMMON::FindRelatedPadsFiles( m_InputFile.GetFullPath() );
 
    if( !related.HasPcb() && !related.HasSchematic() )
        return;
 
    std::list<SCOPED_FILE_REMOVER> copiedFiles;
 
    auto copyAndImport = [&]( const wxString& sourceFile, FRAME_T frameType, int fileType )
    {
        if( sourceFile.IsEmpty() )
            return;
 
        wxFileName srcFn( sourceFile );
        wxFileName targetFile( m_TargetProj.GetPath(), srcFn.GetName(), srcFn.GetExt() );
 
        if( !targetFile.FileExists() )
        {
            bool copied = wxCopyFile( srcFn.GetFullPath(), targetFile.GetFullPath(), false );
 
            if( copied )
                copiedFiles.emplace_back( targetFile.GetFullPath() );
        }
 
        if( targetFile.FileExists() )
            doImport( targetFile.GetFullPath(), frameType, fileType );
    };
 
    copyAndImport( related.schematicFile, FRAME_SCH, SCH_IO_MGR::SCH_PADS );
    copyAndImport( related.pcbFile, FRAME_PCB_EDITOR, PCB_IO_MGR::PADS );
}
 
 
void IMPORT_PROJ_HELPER::GedaProjectHandler()
{
    wxFileName prjFile = m_InputFile;
 
    if( prjFile.GetExt().CmpNoCase( "prj" ) != 0 )
        return;
 
    wxTextFile file;
 
    if( !file.Open( prjFile.GetFullPath() ) )
    {
        wxLogWarning( _( "Could not open gEDA / Lepton EDA project file '%s'." ), prjFile.GetFullPath() );
        return;
    }
 
    std::vector<wxFileName> schFiles;
    wxString                outputName;
    wxString                elementsDir;
 
    for( size_t i = 0; i < file.GetLineCount(); ++i )
    {
        wxString line = file.GetLine( i );
 
        line.Trim( true );
        line.Trim( false );
 
        if( line.IsEmpty() )
            continue;
 
        if( line.StartsWith( wxT( "#" ) ) || line.StartsWith( wxT( ";" ) ) )
            continue;
 
        int commentPos = line.Find( wxT( "#" ) );
 
        if( commentPos != wxNOT_FOUND )
        {
            line = line.Left( commentPos );
            line.Trim( true );
            line.Trim( false );
        }
 
        if( line.IsEmpty() )
            continue;
 
        wxStringTokenizer tok( line );
 
        if( !tok.HasMoreTokens() )
            continue;
 
        wxString keyword = tok.GetNextToken();
 
        if( keyword.CmpNoCase( "schematics" ) == 0 )
        {
            while( tok.HasMoreTokens() )
            {
                wxString  schToken = tok.GetNextToken();
                wxFileName schFile( schToken );
 
                if( !schFile.IsAbsolute() )
                    schFile.MakeAbsolute( prjFile.GetPath() );
 
                schFiles.push_back( schFile );
            }
        }
        else if( keyword.CmpNoCase( "output-name" ) == 0 )
        {
            wxString rest = line.Mid( keyword.length() );
            rest.Trim( true );
            rest.Trim( false );
            outputName = rest;
        }
        else if( keyword.CmpNoCase( "elements-dir" ) == 0 )
        {
            wxString rest = line.Mid( keyword.length() );
            rest.Trim( true );
            rest.Trim( false );
            elementsDir = rest;
        }
    }
 
    if( !elementsDir.IsEmpty() )
    {
        wxFileName elementsPath( elementsDir );
 
        if( !elementsPath.IsAbsolute() )
            elementsPath.MakeAbsolute( prjFile.GetPath() );
 
        m_properties["elements_dir"] = elementsPath.GetFullPath().ToStdString();
    }
 
    if( schFiles.empty() )
    {
        wxFileName candidate = prjFile;
        candidate.SetExt( wxS( "sch" ) );
 
        if( candidate.FileExists() )
            schFiles.push_back( candidate );
    }
 
    auto promptForMissingFile =
            [&]( const wxString& aTitle, const wxString& aWildcard, wxFileName& aFile ) -> bool
            {
                wxString defaultDir = aFile.GetPath();
 
                if( defaultDir.IsEmpty() )
                    defaultDir = prjFile.GetPath();
 
                wxFileDialog dlg( m_frame, aTitle, defaultDir, wxEmptyString, aWildcard,
                                  wxFD_OPEN | wxFD_FILE_MUST_EXIST );
 
                if( dlg.ShowModal() == wxID_OK )
                {
                    aFile.Assign( dlg.GetPath() );
                    return true;
                }
 
                aFile.Clear();
                return false;
            };
 
    std::vector<wxFileName> resolvedSchFiles;
    const wxString          schWildcard = _( "gEDA / Lepton EDA schematic files" ) + wxS( " (*.sch)|*.sch" );
 
    for( wxFileName schFile : schFiles )
    {
        if( !schFile.FileExists() )
        {
            if( !promptForMissingFile( _( "Locate gEDA / Lepton EDA Schematic" ), schWildcard, schFile ) )
                continue;
        }
 
        resolvedSchFiles.push_back( schFile );
    }
 
    if( schFiles.empty() && resolvedSchFiles.empty() )
    {
        wxFileName schFile;
 
        if( promptForMissingFile( _( "Locate gEDA / Lepton EDA Schematic" ), schWildcard, schFile ) )
            resolvedSchFiles.push_back( schFile );
    }
 
    if( resolvedSchFiles.size() > 1 )
    {
        // Pass additional schematic files as a semicolon-delimited property so the
        // importer can create sub-sheets for each additional page within a single
        // KiCad project hierarchy.
        wxString additionalFiles;
 
        for( size_t i = 1; i < resolvedSchFiles.size(); i++ )
        {
            if( !additionalFiles.IsEmpty() )
                additionalFiles += wxT( ";" );
 
            additionalFiles += resolvedSchFiles[i].GetFullPath();
        }
 
        m_properties["additional_schematics"] = additionalFiles.ToStdString();
    }
 
    // Auto-discover subdirectories containing .sym files and pass them as
    // additional search paths for the importer's symbol resolution.
    auto discoverSymDirs = [&]( const wxString& aBaseDir, wxString& aSymPaths )
    {
        wxDir dir( aBaseDir );
 
        if( !dir.IsOpened() )
            return;
 
        wxString subdir;
        bool     cont = dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS );
 
        while( cont )
        {
            wxString subdirPath = aBaseDir + wxFileName::GetPathSeparator() + subdir;
            wxDir    childDir( subdirPath );
 
            if( childDir.IsOpened() && childDir.HasFiles( wxT( "*.sym" ) ) )
            {
                if( !aSymPaths.IsEmpty() )
                    aSymPaths += wxT( "\n" );
 
                aSymPaths += subdirPath;
            }
 
            cont = dir.GetNext( &subdir );
        }
    };
 
    wxString symPaths;
    discoverSymDirs( prjFile.GetPath(), symPaths );
 
    if( !resolvedSchFiles.empty() )
    {
        wxString schDir = resolvedSchFiles[0].GetPath();
 
        if( schDir != prjFile.GetPath() )
            discoverSymDirs( schDir, symPaths );
    }
 
    if( !symPaths.IsEmpty() )
        m_properties["sym_search_paths"] = symPaths.ToStdString();
 
    if( !resolvedSchFiles.empty() )
        doImport( resolvedSchFiles[0].GetFullPath(), FRAME_SCH, SCH_IO_MGR::SCH_GEDA );
 
    wxFileName layoutDir( prjFile.GetPath(), wxEmptyString );
    layoutDir.RemoveLastDir();
    layoutDir.AppendDir( wxS( "layout" ) );
 
    wxFileName pcbFile;
 
    if( !outputName.IsEmpty() )
    {
        wxFileName candidate( layoutDir.GetPath(), outputName, wxS( "pcb" ) );
 
        if( candidate.FileExists() )
            pcbFile = candidate;
    }
 
    if( !pcbFile.FileExists() )
    {
        wxFileName candidate( prjFile.GetPath(), prjFile.GetName(), wxS( "pcb" ) );
 
        if( candidate.FileExists() )
            pcbFile = candidate;
    }
 
    if( !pcbFile.FileExists() )
    {
        wxFileName candidate( layoutDir.GetPath(), prjFile.GetName(), wxS( "pcb" ) );
 
        if( candidate.FileExists() )
            pcbFile = candidate;
    }
 
    const wxString pcbWildcard = _( "gEDA / Lepton EDA PCB files" ) + wxS( " (*.pcb)|*.pcb" );
 
    if( !pcbFile.FileExists() )
        promptForMissingFile( _( "Locate gEDA / Lepton EDA PCB" ), pcbWildcard, pcbFile );
 
    if( pcbFile.FileExists() )
        doImport( pcbFile.GetFullPath(), FRAME_PCB_EDITOR, PCB_IO_MGR::GEDA_PCB );
}
 
 
static wxFileName findSiblingByExt( const wxFileName& aBase, const wxString& aExt )
{
    wxDir dir( aBase.GetPath() );
 
    if( dir.IsOpened() )
    {
        wxString found;
 
        for( bool more = dir.GetFirst( &found, wxEmptyString, wxDIR_FILES ); more;
             more = dir.GetNext( &found ) )
        {
            wxFileName fn( aBase.GetPath(), found );
 
            if( fn.GetName().CmpNoCase( aBase.GetName() ) == 0 && fn.GetExt().CmpNoCase( aExt ) == 0 )
                return fn;
        }
    }
 
    return wxFileName();
}
 
 
void IMPORT_PROJ_HELPER::OrcadProjectHandler()
{
    m_properties.erase( IMPORT_PROJ_PROPS::NET_NAME_MAP );
 
    // Import selected OrCAD Capture schematic (.dsn) first
    ImportIndividualFile( SCHEMATIC_T, SCH_IO_MGR::SCH_ORCAD );
 
    // Only a successful schematic import replies with a net-name map, even an empty one.
    if( !m_properties.count( IMPORT_PROJ_PROPS::NET_NAME_MAP ) )
        return;
 
    // OrCAD designs pair w/ Cadence Allegro board; offer import, defaulting to
    // sibling board (matched case-insensitively) next to schematic
    wxFileName brdFile = findSiblingByExt( m_InputFile, wxS( "brd" ) );
    bool       haveSibling = brdFile.FileExists();
 
    wxString msg = haveSibling
                           ? wxString::Format( _( "Import the associated Allegro board '%s'?" ),
                                               brdFile.GetFullName() )
                           : _( "Import an associated Allegro board file?" );
 
    KIDIALOG dlg( m_frame, msg, _( "Import Allegro Board" ), wxOK | wxCANCEL | wxICON_QUESTION );
    dlg.SetOKCancelLabels( _( "OK" ), _( "Skip" ) );
 
    if( dlg.ShowModal() != wxID_OK )
        return;
 
    if( !haveSibling )
    {
        wxFileDialog fileDlg( m_frame, _( "Locate Allegro Board" ), m_InputFile.GetPath(),
                              wxEmptyString, FILEEXT::AllegroPcbFilesWildcard(),
                              wxFD_OPEN | wxFD_FILE_MUST_EXIST );
 
        if( fileDlg.ShowModal() != wxID_OK )
            return;
 
        brdFile.Assign( fileDlg.GetPath() );
    }
 
    // ExpressMail dispatches synchronously and loaded target project sets generated
    // board path, so import source board directly, no staging copy
    if( brdFile.FileExists() )
        doImport( brdFile.GetFullPath(), FRAME_PCB_EDITOR, PCB_IO_MGR::ALLEGRO );
}
 
 
void IMPORT_PROJ_HELPER::EasyPcProjectHandler()
{
    wxFileName schFile;
    wxFileName pcbFile;
    wxString   projectPcb;
 
    if( m_InputFile.GetExt().CmpNoCase( wxS( "prj" ) ) == 0 )
    {
        schFile = m_InputFile;
 
        try
        {
            std::unique_ptr<EASYPC::PROJECT_DOCUMENT> doc = EASYPC::LoadProject( m_InputFile.GetFullPath() );
            const EASYPC::SOURCE_PROJECT&             project = *doc->Project;
 
            if( !project.Boards.empty() )
            {
                projectPcb = project.Boards.front()->Name;
                pcbFile.Assign( EASYPC::ResolveProjectItem( m_InputFile.GetFullPath(), projectPcb ) );
            }
        }
        catch( const IO_ERROR& e )
        {
            DisplayErrorMessage( m_frame, _( "Cannot read the Easy-PC project." ), e.What() );
            return;
        }
    }
    else if( m_InputFile.GetExt().CmpNoCase( wxS( "pcb" ) ) == 0 )
    {
        pcbFile = m_InputFile;
        schFile = findSiblingByExt( m_InputFile, wxS( "sch" ) );
    }
    else
    {
        schFile = m_InputFile;
        pcbFile = findSiblingByExt( m_InputFile, wxS( "pcb" ) );
    }
 
    // Sources are imported in place: a project's sheets are found relative to the .prj
    if( schFile.IsOk() && schFile.FileExists() )
        doImport( schFile.GetFullPath(), FRAME_SCH, SCH_IO_MGR::SCH_EASYPC );
 
    if( pcbFile.IsOk() && pcbFile.FileExists() )
    {
        doImport( pcbFile.GetFullPath(), FRAME_PCB_EDITOR, PCB_IO_MGR::EASYPC );
    }
    else if( !projectPcb.IsEmpty() )
    {
        DisplayErrorMessage( m_frame, wxString::Format( _( "The board '%s' named by the Easy-PC project was not "
                                                           "found." ),
                                                        projectPcb ) );
    }
}
 
 
void IMPORT_PROJ_HELPER::ImportFiles( int aImportedSchFileType, int aImportedPcbFileType )
{
    m_properties.clear();
 
    // both imports must agree on the cache nickname up front
    setImportCacheNickname();
 
    int importedSchFileType = aImportedSchFileType;
    int importedPcbFileType = aImportedPcbFileType;
 
    if( importedSchFileType == SCH_IO_MGR::SCH_EASYEDAPRO || importedSchFileType == SCH_IO_MGR::SCH_EASYEDAPRO_V3
        || importedPcbFileType == PCB_IO_MGR::EASYEDAPRO || importedPcbFileType == PCB_IO_MGR::EASYEDAPRO_V3 )
    {
        bool isV3 = EASYEDAPRO::V3_DOC_PARSER::IsV3Archive( m_InputFile.GetFullPath() );
 
        importedSchFileType = isV3 ? SCH_IO_MGR::SCH_EASYEDAPRO_V3 : SCH_IO_MGR::SCH_EASYEDAPRO;
        importedPcbFileType = isV3 ? PCB_IO_MGR::EASYEDAPRO_V3 : PCB_IO_MGR::EASYEDAPRO;
 
        EasyEDAProProjectHandler( importedSchFileType, importedPcbFileType );
    }
    else if( importedSchFileType == SCH_IO_MGR::SCH_ALTIUM || importedPcbFileType == PCB_IO_MGR::ALTIUM_DESIGNER )
    {
        AltiumProjectHandler();
        return;
    }
    else if( aImportedSchFileType == SCH_IO_MGR::SCH_ORCAD )
    {
        OrcadProjectHandler();
        return;
    }
    else if( aImportedSchFileType == SCH_IO_MGR::SCH_EASYPC )
    {
        EasyPcProjectHandler();
        return;
    }
    else if( aImportedSchFileType == SCH_IO_MGR::SCH_GEDA )
    {
        if( m_InputFile.GetExt().CmpNoCase( "prj" ) == 0 )
        {
            GedaProjectHandler();
        }
        else if( m_InputFile.GetExt().CmpNoCase( "pcb" ) == 0 )
        {
            ImportIndividualFile( PCB_T, aImportedPcbFileType );
        }
        else
        {
            // When importing a bare .sch file, pass the original source directory
            // so the importer can find symbols in subdirectories relative to the
            // gEDA / Lepton EDA schematic, even though the file may be copied to a new location
            // for the KiCad project.
            wxString sourceDir = m_InputFile.GetPath();
            wxString symPaths = sourceDir;
 
            auto discoverSymDirs = [&]( const wxString& aBaseDir )
            {
                wxDir dir( aBaseDir );
 
                if( !dir.IsOpened() )
                    return;
 
                wxString subdir;
                bool     cont = dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS );
 
                while( cont )
                {
                    wxString subdirPath =
                            aBaseDir + wxFileName::GetPathSeparator() + subdir;
                    wxDir childDir( subdirPath );
 
                    if( childDir.IsOpened() && childDir.HasFiles( wxT( "*.sym" ) ) )
                        symPaths += wxT( "\n" ) + subdirPath;
 
                    cont = dir.GetNext( &subdir );
                }
            };
 
            discoverSymDirs( sourceDir );
            m_properties["sym_search_paths"] = symPaths.ToStdString();
 
            doImport( m_InputFile.GetFullPath(), FRAME_SCH, SCH_IO_MGR::SCH_GEDA );
            ImportIndividualFile( PCB_T, aImportedPcbFileType );
        }
 
        return;
    }
 
    ImportIndividualFile( SCHEMATIC_T, importedSchFileType );
    ImportIndividualFile( PCB_T, importedPcbFileType );
}