FILENAME_RESOLVER Class Reference

Provide an extensible class to resolve 3D model paths. More...

#include <filename_resolver.h>

Public Member Functions
	FILENAME_RESOLVER ()
bool	Set3DConfigDir (const wxString &aConfigDir)
	Set the user's configuration directory for 3D models. More...
bool	SetProject (PROJECT *aProject, bool *flgChanged=nullptr)
	Set the current KiCad project directory as the first entry in the model path list. More...
wxString	GetProjectDir (void)
void	SetProgramBase (PGM_BASE *aBase)
	Set a pointer to the application's PGM_BASE instance used to extract the local env vars. More...
bool	UpdatePathList (std::vector< SEARCH_PATH > &aPathList)
	Clear the current path list and substitutes the given path list and update the path configuration file on success. More...
wxString	ResolvePath (const wxString &aFileName)
	Determines the full path of the given file name. More...
wxString	ShortenPath (const wxString &aFullPathName)
	Produce a relative path based on the existing search directories or returns the same path if the path is not a superset of an existing search path. More...
const std::list< SEARCH_PATH > *	GetPaths (void)
	Return a pointer to the internal path list; the items in:load. More...
bool	SplitAlias (const wxString &aFileName, wxString &anAlias, wxString &aRelPath)
	Return true if the given name contains an alias and populates the string anAlias with the alias and aRelPath with the relative path. More...
bool	ValidateFileName (const wxString &aFileName, bool &hasAlias)
	Returns true if the given path is a valid aliased relative path. More...
bool	GetKicadPaths (std::list< wxString > &paths)
	Return a list of path environment variables local to KiCad. More...

Private Member Functions
bool	createPathList (void)
	Build the path list using available information such as KICAD6_3DMODEL_DIR and the 3d_path_list configuration file. More...
bool	addPath (const SEARCH_PATH &aPath)
	Check that a path is valid and adds it to the search list. More...
bool	readPathList (void)
	Read a list of path names from a configuration file. More...
bool	writePathList (void)
	Write the current path list to a configuration file. More...
void	checkEnvVarPath (const wxString &aPath)
	Check the ${ENV_VAR} component of a path and adds it to the resolver's path list if it is not yet in the list. More...

Private Attributes
wxString	m_configDir
std::list< SEARCH_PATH >	m_paths
int	m_errflags
PGM_BASE *	m_pgm
PROJECT *	m_project
wxString	m_curProjDir

Detailed Description

Provide an extensible class to resolve 3D model paths.

Initially the legacy behavior will be implemented and an incomplete path would be checked against the project directory or the KICAD6_3DMODEL_DIR environment variable. In the future a configurable set of search paths may be specified.

Definition at line 55 of file filename_resolver.h.

Constructor & Destructor Documentation

FILENAME_RESOLVER()

FILENAME_RESOLVER::FILENAME_RESOLVER

(

)

Definition at line 53 of file filename_resolver.cpp.

                                     :
        m_pgm( nullptr ),
        m_project( nullptr )
{
    m_errflags = 0;
}

References m_errflags.

Member Function Documentation

addPath()

bool FILENAME_RESOLVER::addPath ( const SEARCH_PATH &  aPath )

private

Check that a path is valid and adds it to the search list.

Parameters

aPath

is the alias set to be checked and added.

Returns

true if aPath is valid.

Definition at line 426 of file filename_resolver.cpp.

{
    if( aPath.m_Alias.empty() || aPath.m_Pathvar.empty() )
        return false;

    std::lock_guard<std::mutex> lock( mutex_resolver );

    SEARCH_PATH tpath = aPath;

    #ifdef _WIN32
    while( tpath.m_Pathvar.EndsWith( wxT( "\\" ) ) )
        tpath.m_Pathvar.erase( tpath.m_Pathvar.length() - 1 );
    #else
    while( tpath.m_Pathvar.EndsWith( wxT( "/" ) ) && tpath.m_Pathvar.length() > 1 )
        tpath.m_Pathvar.erase( tpath.m_Pathvar.length() - 1 );
    #endif

    wxFileName path( ExpandEnvVarSubstitutions( tpath.m_Pathvar, m_project ), "" );

    path.Normalize();

    if( !path.DirExists() )
    {
        // suppress the message if the missing pathvar is the
        // legacy KICAD6_3DMODEL_DIR variable
        if( aPath.m_Pathvar.compare( wxT( "${KICAD6_3DMODEL_DIR}" ) ) )
        {
            wxString msg = _( "The given path does not exist" );
            msg.append( wxT( "\n" ) );
            msg.append( tpath.m_Pathvar );
            wxMessageBox( msg, _( "3D model search path" ) );
        }

        tpath.m_Pathexp.clear();
    }
    else
    {
        tpath.m_Pathexp = path.GetFullPath();

#ifdef _WIN32
        while( tpath.m_Pathexp.EndsWith( wxT( "\\" ) ) )
        tpath.m_Pathexp.erase( tpath.m_Pathexp.length() - 1 );
#else
        while( tpath.m_Pathexp.EndsWith( wxT( "/" ) ) && tpath.m_Pathexp.length() > 1 )
            tpath.m_Pathexp.erase( tpath.m_Pathexp.length() - 1 );
#endif
    }

    wxString pname = path.GetPath();
    std::list< SEARCH_PATH >::iterator sPL = m_paths.begin();
    std::list< SEARCH_PATH >::iterator ePL = m_paths.end();

    while( sPL != ePL )
    {
        if( !tpath.m_Alias.Cmp( sPL->m_Alias ) )
        {
            wxString msg = _( "Alias: " );
            msg.append( tpath.m_Alias );
            msg.append( wxT( "\n" ) );
            msg.append( _( "This path:" ) + wxS( " " ) );
            msg.append( tpath.m_Pathvar );
            msg.append( wxT( "\n" ) );
            msg.append( _( "Existing path:" ) + wxS( " " ) );
            msg.append( sPL->m_Pathvar );
            wxMessageBox( msg, _( "Bad alias (duplicate name)" ) );

            return false;
        }

        ++sPL;
    }

    m_paths.push_back( tpath );
    return true;
}

References _, ExpandEnvVarSubstitutions(), SEARCH_PATH::m_Alias, SEARCH_PATH::m_Pathexp, m_paths, SEARCH_PATH::m_Pathvar, m_project, and mutex_resolver.

Referenced by readPathList(), and UpdatePathList().

checkEnvVarPath()

void FILENAME_RESOLVER::checkEnvVarPath ( const wxString &  aPath )

private

Check the ${ENV_VAR} component of a path and adds it to the resolver's path list if it is not yet in the list.

Definition at line 674 of file filename_resolver.cpp.

{
    bool useParen = false;

    if( aPath.StartsWith( "$(" ) )
        useParen = true;
    else if( !aPath.StartsWith( "${" ) )
        return;

    size_t pEnd;

    if( useParen )
        pEnd = aPath.find( ")" );
    else
        pEnd = aPath.find( "}" );

    if( pEnd == wxString::npos )
        return;

    wxString envar = aPath.substr( 0, pEnd + 1 );

    // check if the alias exists; if not then add it to the end of the
    // env var section of the path list
    auto sPL = m_paths.begin();
    auto ePL = m_paths.end();

    while( sPL != ePL )
    {
        if( sPL->m_Alias == envar )
            return;

        if( !sPL->m_Alias.StartsWith( "${" ) )
            break;

        ++sPL;
    }

    SEARCH_PATH lpath;
    lpath.m_Alias = envar;
    lpath.m_Pathvar = lpath.m_Alias;
    wxFileName tmpFN( ExpandEnvVarSubstitutions( lpath.m_Alias, m_project ), "" );

    wxUniChar psep = tmpFN.GetPathSeparator();
    tmpFN.Normalize();

    if( !tmpFN.DirExists() )
        return;

    lpath.m_Pathexp = tmpFN.GetFullPath();

    if( !lpath.m_Pathexp.empty() && psep == *lpath.m_Pathexp.rbegin() )
        lpath.m_Pathexp.erase( --lpath.m_Pathexp.end() );

    if( lpath.m_Pathexp.empty() )
        return;

    m_paths.insert( sPL, lpath );
}

References ExpandEnvVarSubstitutions(), SEARCH_PATH::m_Alias, SEARCH_PATH::m_Pathexp, m_paths, SEARCH_PATH::m_Pathvar, and m_project.

Referenced by ResolvePath().

createPathList()

bool FILENAME_RESOLVER::createPathList ( void  )

private

Build the path list using available information such as KICAD6_3DMODEL_DIR and the 3d_path_list configuration file.

Warning

Invalid paths are silently discarded and removed from the configuration file.

Returns

true if at least one valid path was found.

Definition at line 158 of file filename_resolver.cpp.

{
    if( !m_paths.empty() )
        return true;

    wxString kmod;

    // add an entry for the default search path; at this point
    // we cannot set a sensible default so we use an empty string.
    // the user may change this later with a call to SetProjectDir()

    SEARCH_PATH lpath;
    lpath.m_Alias = "${KIPRJMOD}";
    lpath.m_Pathvar = "${KIPRJMOD}";
    lpath.m_Pathexp = m_curProjDir;
    m_paths.push_back( lpath );
    wxFileName fndummy;
    wxUniChar psep = fndummy.GetPathSeparator();
    std::list< wxString > epaths;

    if( GetKicadPaths( epaths ) )
    {
        for( const wxString& curr_path : epaths )
        {
            wxString pathVal = ExpandEnvVarSubstitutions( curr_path, m_project );

            if( pathVal.empty() )
            {
                lpath.m_Pathexp.clear();
            }
            else
            {
                fndummy.Assign( pathVal, "" );
                fndummy.Normalize();
                lpath.m_Pathexp = fndummy.GetFullPath();
            }

            lpath.m_Alias =  curr_path;
            lpath.m_Pathvar = curr_path;

            if( !lpath.m_Pathexp.empty() && psep == *lpath.m_Pathexp.rbegin() )
                lpath.m_Pathexp.erase( --lpath.m_Pathexp.end() );

            m_paths.push_back( lpath );
        }
    }

    if( !m_configDir.empty() )
        readPathList();

    if( m_paths.empty() )
        return false;

#ifdef DEBUG
    wxLogTrace( MASK_3D_RESOLVER, " * [3D model] search paths:\n" );
    std::list< SEARCH_PATH >::const_iterator sPL = m_paths.begin();

    while( sPL != m_paths.end() )
    {
        wxLogTrace( MASK_3D_RESOLVER, "   + %s : '%s'\n", (*sPL).m_Alias.GetData(),
            (*sPL).m_Pathexp.GetData() );
        ++sPL;
    }
#endif

    return true;
}

References ExpandEnvVarSubstitutions(), GetKicadPaths(), SEARCH_PATH::m_Alias, m_configDir, m_curProjDir, SEARCH_PATH::m_Pathexp, m_paths, SEARCH_PATH::m_Pathvar, m_project, MASK_3D_RESOLVER, and readPathList().

Referenced by ResolvePath(), Set3DConfigDir(), SetProgramBase(), and ShortenPath().

GetKicadPaths()

bool FILENAME_RESOLVER::GetKicadPaths

(

std::list< wxString > &

paths

)

Return a list of path environment variables local to KiCad.

This list always includes KICAD6_3DMODEL_DIR even if it is not defined locally.

Definition at line 1008 of file filename_resolver.cpp.

{
    paths.clear();

    if( !m_pgm )
        return false;

    bool hasKisys3D = false;


    // iterate over the list of internally defined ENV VARs
    // and add them to the paths list
    ENV_VAR_MAP_CITER mS = m_pgm->GetLocalEnvVariables().begin();
    ENV_VAR_MAP_CITER mE = m_pgm->GetLocalEnvVariables().end();

    while( mS != mE )
    {
        // filter out URLs, template directories, and known system paths
        if( mS->first == wxString( "KICAD_PTEMPLATES" )
            || mS->first == wxString( "KICAD6_FOOTPRINT_DIR" ) )
        {
            ++mS;
            continue;
        }

        if( wxString::npos != mS->second.GetValue().find( wxString( "://" ) ) )
        {
            ++mS;
            continue;
        }

        wxString tmp( "${" );
        tmp.Append( mS->first );
        tmp.Append( "}" );
        paths.push_back( tmp );

        if( tmp == "${KICAD6_3DMODEL_DIR}" )
            hasKisys3D = true;

        ++mS;
    }

    if( !hasKisys3D )
        paths.emplace_back("${KICAD6_3DMODEL_DIR}" );

    return true;
}

References PGM_BASE::GetLocalEnvVariables(), and m_pgm.

Referenced by createPathList().

GetPaths()

const std::list< SEARCH_PATH > * FILENAME_RESOLVER::GetPaths

(

void

)

Return a pointer to the internal path list; the items in:load.

The list can be used to set up the list of search paths available to a 3D file browser.

Returns

pointer to the internal path list.

Definition at line 825 of file filename_resolver.cpp.

{
    return &m_paths;
}

References m_paths.

Referenced by DIALOG_CONFIGURE_PATHS::TransferDataToWindow(), and DLG_SELECT_3DMODEL::updateDirChoiceList().

GetProjectDir()

wxString FILENAME_RESOLVER::GetProjectDir

(

void

)

Definition at line 139 of file filename_resolver.cpp.

{
    return m_curProjDir;
}

References m_curProjDir.

readPathList()

bool FILENAME_RESOLVER::readPathList ( void  )

private

Read a list of path names from a configuration file.

Returns

true if a file was found and contained at least one valid path.

Definition at line 503 of file filename_resolver.cpp.

{
    if( m_configDir.empty() )
    {
        std::ostringstream ostr;
        ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
        wxString errmsg = "3D configuration directory is unknown";
        ostr << " * " << errmsg.ToUTF8();
        wxLogTrace( MASK_3D_RESOLVER, "%s\n", ostr.str().c_str() );
        return false;
    }

    wxFileName cfgpath( m_configDir, RESOLVER_CONFIG );
    cfgpath.Normalize();
    wxString cfgname = cfgpath.GetFullPath();

    size_t nitems = m_paths.size();

    std::ifstream cfgFile;
    std::string   cfgLine;

    if( !wxFileName::Exists( cfgname ) )
    {
        std::ostringstream ostr;
        ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
        wxString errmsg = "no 3D configuration file";
        ostr << " * " << errmsg.ToUTF8() << " '";
        ostr << cfgname.ToUTF8() << "'";
        wxLogTrace( MASK_3D_RESOLVER, "%s\n", ostr.str().c_str() );
        return false;
    }

    cfgFile.open( cfgname.ToUTF8() );

    if( !cfgFile.is_open() )
    {
        std::ostringstream ostr;
        ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
        wxString errmsg = "Could not open configuration file";
        ostr << " * " << errmsg.ToUTF8() << " '" << cfgname.ToUTF8() << "'";
        wxLogTrace( MASK_3D_RESOLVER, "%s\n", ostr.str().c_str() );
        return false;
    }

    int lineno = 0;
    SEARCH_PATH al;
    size_t idx;
    int vnum = 0;           // version number

    while( cfgFile.good() )
    {
        cfgLine.clear();
        std::getline( cfgFile, cfgLine );
        ++lineno;

        if( cfgLine.empty() )
        {
            if( cfgFile.eof() )
                break;

            continue;
        }

        if( 1 == lineno && cfgLine.compare( 0, 2, "#V" ) == 0 )
        {
            // extract the version number and parse accordingly
            if( cfgLine.size() > 2 )
            {
                std::istringstream istr;
                istr.str( cfgLine.substr( 2 ) );
                istr >> vnum;
            }

            continue;
        }

        idx = 0;

        if( !getHollerith( cfgLine, idx, al.m_Alias ) )
            continue;

        // never add on KICAD6_3DMODEL_DIR from a config file
        if( !al.m_Alias.Cmp( wxT( "KICAD6_3DMODEL_DIR" ) ) )
            continue;

        if( !getHollerith( cfgLine, idx, al.m_Pathvar ) )
            continue;

        if( !getHollerith( cfgLine, idx, al.m_Description ) )
            continue;

        addPath( al );
    }

    cfgFile.close();

    if( vnum < CFGFILE_VERSION )
        writePathList();

    return( m_paths.size() != nitems );
}

References addPath(), CFGFILE_VERSION, getHollerith(), SEARCH_PATH::m_Alias, m_configDir, SEARCH_PATH::m_Description, m_paths, SEARCH_PATH::m_Pathvar, MASK_3D_RESOLVER, RESOLVER_CONFIG, and writePathList().

Referenced by createPathList().

ResolvePath()

wxString FILENAME_RESOLVER::ResolvePath

(

const wxString &

aFileName

)

Determines the full path of the given file name.

In the future remote files may be supported, in which case it is best to require a full URI in which case ResolvePath should check that the URI conforms to RFC-2396 and related documents and copies aFileName into aResolvedName if the URI is valid.

Definition at line 243 of file filename_resolver.cpp.

{
    std::lock_guard<std::mutex> lock( mutex_resolver );

    if( aFileName.empty() )
        return wxEmptyString;

    if( m_paths.empty() )
        createPathList();

    // first attempt to use the name as specified:
    wxString tname = aFileName;

    #ifdef _WIN32
    // translate from KiCad's internal UNIX-like path to MSWin paths
    tname.Replace( wxT( "/" ), wxT( "\\" ) );
    #endif

    // Note: variable expansion must be performed using a threadsafe
    // wrapper for the getenv() system call. If we allow the
    // wxFileName::Normalize() routine to perform expansion then
    // we will have a race condition since wxWidgets does not assure
    // a threadsafe wrapper for getenv().
    tname = ExpandEnvVarSubstitutions( tname, m_project );

    wxFileName tmpFN( tname );

    // in the case of absolute filenames we don't store a map item
    if( !aFileName.StartsWith( "${" ) && !aFileName.StartsWith( "$(" )
        && !aFileName.StartsWith( ":" ) && tmpFN.IsAbsolute() )
    {
        tmpFN.Normalize();

        if( tmpFN.FileExists() )
            return tmpFN.GetFullPath();

        return wxEmptyString;
    }

    // this case covers full paths, leading expanded vars, and paths
    // relative to the current working directory (which is not necessarily
    // the current project directory)
    if( tmpFN.FileExists() )
    {
        tmpFN.Normalize();
        tname = tmpFN.GetFullPath();

        // special case: if a path begins with ${ENV_VAR} but is not in the
        // resolver's path list then add it.
        if( aFileName.StartsWith( "${" ) || aFileName.StartsWith( "$(" ) )
            checkEnvVarPath( aFileName );

        return tname;
    }

    // if a path begins with ${ENV_VAR}/$(ENV_VAR) and is not resolved then the
    // file either does not exist or the ENV_VAR is not defined
    if( aFileName.StartsWith( "${" ) || aFileName.StartsWith( "$(" ) )
    {
        if( !( m_errflags & ERRFLG_ENVPATH ) )
        {
            m_errflags |= ERRFLG_ENVPATH;
            wxString errmsg = "[3D File Resolver] No such path; ensure the environment var is defined";
            errmsg.append( "\n" );
            errmsg.append( tname );
            errmsg.append( "\n" );
            wxLogTrace( tracePathsAndFiles, errmsg );
        }

        return wxEmptyString;
    }

    // at this point aFileName is:
    // a. an aliased shortened name or
    // b. cannot be determined

    std::list< SEARCH_PATH >::const_iterator sPL = m_paths.begin();
    std::list< SEARCH_PATH >::const_iterator ePL = m_paths.end();

    // check the path relative to the current project directory;
    // note: this is not necessarily the same as the current working
    // directory, which has already been checked. This case accounts
    // for partial paths which do not contain ${KIPRJMOD}.
    // This check is performed before checking the path relative to
    // ${KICAD6_3DMODEL_DIR} so that users can potentially override a model
    // within ${KICAD6_3DMODEL_DIR}
    if( !sPL->m_Pathexp.empty() && !tname.StartsWith( ":" ) )
    {
        tmpFN.Assign( sPL->m_Pathexp, "" );
        wxString fullPath = tmpFN.GetPathWithSep() + tname;

        fullPath = ExpandEnvVarSubstitutions( fullPath, m_project );

        if( wxFileName::FileExists( fullPath ) )
        {
            tmpFN.Assign( fullPath );
            tmpFN.Normalize();
            tname = tmpFN.GetFullPath();
            return tname;
        }

    }

    // check the partial path relative to ${KICAD6_3DMODEL_DIR} (legacy behavior)
    if( !tname.StartsWith( ":" ) )
    {
        wxFileName fpath;
        wxString fullPath( "${KICAD6_3DMODEL_DIR}" );
        fullPath.Append( fpath.GetPathSeparator() );
        fullPath.Append( tname );
        fullPath = ExpandEnvVarSubstitutions( fullPath, m_project );
        fpath.Assign( fullPath );

        if( fpath.Normalize() && fpath.FileExists() )
        {
            tname = fpath.GetFullPath();
            return tname;
        }

    }

    // ${ENV_VAR} paths have already been checked; skip them
    while( sPL != ePL && ( sPL->m_Alias.StartsWith( "${" ) || sPL->m_Alias.StartsWith( "$(" ) ) )
        ++sPL;

    // at this point the filename must contain an alias or else it is invalid
    wxString alias;         // the alias portion of the short filename
    wxString relpath;       // the path relative to the alias

    if( !SplitAlias( tname, alias, relpath ) )
    {
        if( !( m_errflags & ERRFLG_RELPATH ) )
        {
            // this can happen if the file was intended to be relative to
            // ${KICAD6_3DMODEL_DIR} but ${KICAD6_3DMODEL_DIR} not set or incorrect.
            m_errflags |= ERRFLG_RELPATH;
            wxString errmsg = "[3D File Resolver] No such path";
            errmsg.append( "\n" );
            errmsg.append( tname );
            errmsg.append( "\n" );
            wxLogTrace( tracePathsAndFiles, errmsg );
        }

        return wxEmptyString;
    }

    while( sPL != ePL )
    {
        if( !sPL->m_Alias.Cmp( alias ) && !sPL->m_Pathexp.empty() )
        {
            wxFileName fpath( wxFileName::DirName( sPL->m_Pathexp ) );
            wxString fullPath = fpath.GetPathWithSep() + relpath;

            fullPath = ExpandEnvVarSubstitutions( fullPath, m_project );

            if( wxFileName::FileExists( fullPath ) )
            {
                wxFileName tmp( fullPath );

                if( tmp.Normalize() )
                    tname = tmp.GetFullPath();

                return tname;
            }
        }

        ++sPL;
    }

    if( !( m_errflags & ERRFLG_ALIAS ) )
    {
        m_errflags |= ERRFLG_ALIAS;
        wxString errmsg = "[3D File Resolver] No such path; ensure the path alias is defined";
        errmsg.append( "\n" );
        errmsg.append( tname.substr( 1 ) );
        errmsg.append( "\n" );
        wxLogTrace( tracePathsAndFiles, errmsg );
    }

    return wxEmptyString;
}

References checkEnvVarPath(), createPathList(), ERRFLG_ALIAS, ERRFLG_ENVPATH, ERRFLG_RELPATH, ExpandEnvVarSubstitutions(), m_errflags, m_paths, m_project, mutex_resolver, SplitAlias(), and tracePathsAndFiles.

Referenced by export_vrml_footprint(), idf_export_footprint(), and S3D_CACHE::load().

Set3DConfigDir()

bool FILENAME_RESOLVER::Set3DConfigDir

(

const wxString &

aConfigDir

)

Set the user's configuration directory for 3D models.

Parameters

aConfigDir

Returns

true if the call succeeds (directory exists).

Definition at line 61 of file filename_resolver.cpp.

{
    if( aConfigDir.empty() )
        return false;

    wxFileName cfgdir( ExpandEnvVarSubstitutions( aConfigDir, m_project ), "" );

    cfgdir.Normalize();

    if( !cfgdir.DirExists() )
        return false;

    m_configDir = cfgdir.GetPath();
    createPathList();

    return true;
}

References createPathList(), ExpandEnvVarSubstitutions(), m_configDir, and m_project.

Referenced by S3D_CACHE::Set3DConfigDir().

SetProgramBase()

void FILENAME_RESOLVER::SetProgramBase

(

PGM_BASE *

aBase

)

Set a pointer to the application's PGM_BASE instance used to extract the local env vars.

Definition at line 145 of file filename_resolver.cpp.

{
    m_pgm = aBase;

    if( !m_pgm || m_paths.empty() )
        return;

    // recreate the path list
    m_paths.clear();
    createPathList();
}

References createPathList(), m_paths, and m_pgm.

Referenced by S3D_CACHE::SetProgramBase().

SetProject()

bool FILENAME_RESOLVER::SetProject	(	PROJECT *	aProject,
		bool *	flgChanged = nullptr
	)

Set the current KiCad project directory as the first entry in the model path list.

Parameters

[in]	aProjDir	current project directory
[out]	flgChanged	optional, set to true if directory was changed

Return values

true	success
false	failure

Definition at line 80 of file filename_resolver.cpp.

{
    m_project = aProject;

    if( !aProject )
        return false;

    wxFileName projdir( ExpandEnvVarSubstitutions( aProject->GetProjectPath(), aProject ), "" );

    projdir.Normalize();

    if( !projdir.DirExists() )
        return false;

    m_curProjDir = projdir.GetPath();

    if( flgChanged )
        *flgChanged = false;

    if( m_paths.empty() )
    {
        SEARCH_PATH al;
        al.m_Alias = "${KIPRJMOD}";
        al.m_Pathvar = "${KIPRJMOD}";
        al.m_Pathexp = m_curProjDir;
        m_paths.push_back( al );

        if( flgChanged )
            *flgChanged = true;
    }
    else
    {
        if( m_paths.front().m_Pathexp.Cmp( m_curProjDir ) )
        {
            m_paths.front().m_Pathexp = m_curProjDir;

            if( flgChanged )
                *flgChanged = true;
        }
        else
        {
            return true;
        }
    }

#ifdef DEBUG
    {
        std::ostringstream ostr;
        ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
        ostr << " * [INFO] changed project dir to ";
        ostr << m_paths.front().m_Pathexp.ToUTF8();
        wxLogTrace( MASK_3D_RESOLVER, "%s\n", ostr.str().c_str() );
    }
#endif

    return true;
}

References ExpandEnvVarSubstitutions(), PROJECT::GetProjectPath(), SEARCH_PATH::m_Alias, m_curProjDir, SEARCH_PATH::m_Pathexp, m_paths, SEARCH_PATH::m_Pathvar, m_project, and MASK_3D_RESOLVER.

Referenced by S3D_CACHE::SetProject().

ShortenPath()

wxString FILENAME_RESOLVER::ShortenPath

(

const wxString &

aFullPathName

)

Produce a relative path based on the existing search directories or returns the same path if the path is not a superset of an existing search path.

Parameters

aFullPathName

is an absolute path to shorten.

Returns

the shortened path or aFullPathName.

Definition at line 734 of file filename_resolver.cpp.

{
    wxString fname = aFullPathName;

    if( m_paths.empty() )
        createPathList();

    std::lock_guard<std::mutex> lock( mutex_resolver );

    std::list< SEARCH_PATH >::const_iterator sL = m_paths.begin();
    size_t idx;

    while( sL != m_paths.end() )
    {
        // undefined paths do not participate in the
        // file name shortening procedure
        if( sL->m_Pathexp.empty() )
        {
            ++sL;
            continue;
        }

        wxFileName fpath;

        // in the case of aliases, ensure that we use the most recent definition
        if( sL->m_Alias.StartsWith( "${" ) || sL->m_Alias.StartsWith( "$(" ) )
        {
            wxString tpath = ExpandEnvVarSubstitutions( sL->m_Alias, m_project );

            if( tpath.empty() )
            {
                ++sL;
                continue;
            }

            fpath.Assign( tpath, wxT( "" ) );
        }
        else
        {
            fpath.Assign( sL->m_Pathexp, wxT( "" ) );
        }

        wxString fps = fpath.GetPathWithSep();
        wxString tname;

        idx = fname.find( fps );

        if( idx == 0 )
        {
            fname = fname.substr( fps.size() );

            #ifdef _WIN32
            // ensure only the '/' separator is used in the internal name
            fname.Replace( wxT( "\\" ), wxT( "/" ) );
            #endif

            if( sL->m_Alias.StartsWith( "${" ) || sL->m_Alias.StartsWith( "$(" ) )
            {
                // old style ENV_VAR
                tname = sL->m_Alias;
                tname.Append( "/" );
                tname.append( fname );
            }
            else
            {
                // new style alias
                tname = ":";
                tname.append( sL->m_Alias );
                tname.append( ":" );
                tname.append( fname );
            }

            return tname;
        }

        ++sL;
    }

#ifdef _WIN32
    // it is strange to convert an MSWin full path to use the
    // UNIX separator but this is done for consistency and can
    // be helpful even when transferring project files from
    // MSWin to *NIX.
    fname.Replace( wxT( "\\" ), wxT( "/" ) );
#endif

    return fname;
}

References createPathList(), ExpandEnvVarSubstitutions(), m_paths, m_project, and mutex_resolver.

Referenced by DLG_SELECT_3DMODEL::TransferDataFromWindow().

SplitAlias()

bool FILENAME_RESOLVER::SplitAlias	(	const wxString &	aFileName,
		wxString &	anAlias,
		wxString &	aRelPath
	)

Return true if the given name contains an alias and populates the string anAlias with the alias and aRelPath with the relative path.

Definition at line 831 of file filename_resolver.cpp.

{
    anAlias.clear();
    aRelPath.clear();

    if( !aFileName.StartsWith( wxT( ":" ) ) )
        return false;

    size_t tagpos = aFileName.find( wxT( ":" ), 1 );

    if( wxString::npos ==  tagpos || 1 == tagpos )
        return false;

    if( tagpos + 1 >= aFileName.length() )
        return false;

    anAlias = aFileName.substr( 1, tagpos - 1 );
    aRelPath = aFileName.substr( tagpos + 1 );

    return true;
}

Referenced by DIALOG_FOOTPRINT_FP_EDITOR::OnAdd3DModel(), DIALOG_FOOTPRINT_PROPERTIES::OnAdd3DModel(), ResolvePath(), DIALOG_FOOTPRINT_FP_EDITOR::TransferDataToWindow(), and DIALOG_FOOTPRINT_PROPERTIES::TransferDataToWindow().

UpdatePathList()

bool FILENAME_RESOLVER::UpdatePathList

(

std::vector< SEARCH_PATH > &

aPathList

)

Clear the current path list and substitutes the given path list and update the path configuration file on success.

Definition at line 227 of file filename_resolver.cpp.

{
    wxUniChar envMarker( '$' );

    while( !m_paths.empty() && envMarker != *m_paths.back().m_Alias.rbegin() )
        m_paths.pop_back();

    size_t nI = aPathList.size();

    for( size_t i = 0; i < nI; ++i )
        addPath( aPathList[i] );

    return writePathList();
}

References addPath(), m_paths, and writePathList().

Referenced by DIALOG_CONFIGURE_PATHS::TransferDataFromWindow().

ValidateFileName()

bool FILENAME_RESOLVER::ValidateFileName	(	const wxString &	aFileName,
		bool &	hasAlias
	)

Returns true if the given path is a valid aliased relative path.

If the path contains an alias then hasAlias is set true.

Definition at line 950 of file filename_resolver.cpp.

{
    // Rules:
    // 1. The generic form of an aliased 3D relative path is:
    //    ALIAS:relative/path
    // 2. ALIAS is a UTF string excluding wxT( "{}[]()%~<>\"='`;:.,&?/\\|$" )
    // 3. The relative path must be a valid relative path for the platform
    hasAlias = false;

    if( aFileName.empty() )
        return false;

    wxString filename = aFileName;
    size_t pos0 = aFileName.find( ':' );

    // ensure that the file separators suit the current platform
    #ifdef __WINDOWS__
    filename.Replace( wxT( "/" ), wxT( "\\" ) );

    // if we see the :\ pattern then it must be a drive designator
    if( pos0 != wxString::npos )
    {
        size_t pos1 = filename.find( wxT( ":\\" ) );

        if( pos1 != wxString::npos && ( pos1 != pos0 || pos1 != 1 ) )
            return false;

        // if we have a drive designator then we have no alias
        if( pos1 != wxString::npos )
            pos0 = wxString::npos;
    }
    #else
    filename.Replace( wxT( "\\" ), wxT( "/" ) );
    #endif

    // names may not end with ':'
    if( pos0 == aFileName.length() -1 )
        return false;

    if( pos0 != wxString::npos )
    {
        // ensure the alias component is not empty
        if( pos0 == 0 )
            return false;

        wxString lpath = filename.substr( 0, pos0 );

        // check the alias for restricted characters
        if( wxString::npos != lpath.find_first_of( wxT( "{}[]()%~<>\"='`;:.,&?/\\|$" ) ) )
            return false;

        hasAlias = true;
    }

    return true;
}

Referenced by DIALOG_FOOTPRINT_FP_EDITOR::On3DModelCellChanged(), and DIALOG_FOOTPRINT_PROPERTIES::On3DModelCellChanged().

writePathList()

bool FILENAME_RESOLVER::writePathList ( void  )

private

Write the current path list to a configuration file.

Returns

true if the path list was not empty and was successfully written to the configuration file.

Definition at line 606 of file filename_resolver.cpp.

{
    if( m_configDir.empty() )
    {
        std::ostringstream ostr;
        ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
        wxString errmsg = _( "3D configuration directory is unknown" );
        ostr << " * " << errmsg.ToUTF8();
        wxLogTrace( MASK_3D_RESOLVER, "%s\n", ostr.str().c_str() );
        wxMessageBox( errmsg, _( "Write 3D search path list" ) );

        return false;
    }

    // skip all ${ENV_VAR} alias names
    std::list< SEARCH_PATH >::const_iterator sPL = m_paths.begin();

    while( sPL != m_paths.end() &&
           ( sPL->m_Alias.StartsWith( "${" ) || sPL->m_Alias.StartsWith( "$(" ) ) )
        ++sPL;

    wxFileName cfgpath( m_configDir, RESOLVER_CONFIG );
    wxString cfgname = cfgpath.GetFullPath();
    std::ofstream cfgFile;

    cfgFile.open( cfgname.ToUTF8(), std::ios_base::trunc );

    if( !cfgFile.is_open() )
    {
        std::ostringstream ostr;
        ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
        wxString errmsg = _( "Could not open configuration file" );
        ostr << " * " << errmsg.ToUTF8() << " '" << cfgname.ToUTF8() << "'";
        wxLogTrace( MASK_3D_RESOLVER, "%s\n", ostr.str().c_str() );
        wxMessageBox( errmsg, _( "Write 3D search path list" ) );

        return false;
    }

    cfgFile << "#V" << CFGFILE_VERSION << "\n";
    std::string tstr;

    while( sPL != m_paths.end() )
    {
        tstr = sPL->m_Alias.ToUTF8();
        cfgFile << "\"" << tstr.size() << ":" << tstr << "\",";
        tstr = sPL->m_Pathvar.ToUTF8();
        cfgFile << "\"" << tstr.size() << ":" << tstr << "\",";
        tstr = sPL->m_Description.ToUTF8();
        cfgFile << "\"" << tstr.size() << ":" << tstr << "\"\n";
        ++sPL;
    }

    bool bad = cfgFile.bad();
    cfgFile.close();

    if( bad )
    {
        wxMessageBox( _( "Problems writing configuration file" ),
                      _( "Write 3D search path list" ) );

        return false;
    }

    return true;
}

References _, CFGFILE_VERSION, m_configDir, m_paths, MASK_3D_RESOLVER, and RESOLVER_CONFIG.

Referenced by readPathList(), and UpdatePathList().

Member Data Documentation

m_configDir

wxString FILENAME_RESOLVER::m_configDir

private

Definition at line 179 of file filename_resolver.h.

Referenced by createPathList(), readPathList(), Set3DConfigDir(), and writePathList().

m_curProjDir

wxString FILENAME_RESOLVER::m_curProjDir

private

Definition at line 184 of file filename_resolver.h.

Referenced by createPathList(), GetProjectDir(), and SetProject().

m_errflags

int FILENAME_RESOLVER::m_errflags

private

Definition at line 181 of file filename_resolver.h.

Referenced by FILENAME_RESOLVER(), and ResolvePath().

m_paths

std::list<SEARCH_PATH> FILENAME_RESOLVER::m_paths

private

Definition at line 180 of file filename_resolver.h.

Referenced by addPath(), checkEnvVarPath(), createPathList(), GetPaths(), readPathList(), ResolvePath(), SetProgramBase(), SetProject(), ShortenPath(), UpdatePathList(), and writePathList().

m_pgm

PGM_BASE* FILENAME_RESOLVER::m_pgm

private

Definition at line 182 of file filename_resolver.h.

Referenced by GetKicadPaths(), and SetProgramBase().

m_project

PROJECT* FILENAME_RESOLVER::m_project

private

Definition at line 183 of file filename_resolver.h.

Referenced by addPath(), checkEnvVarPath(), createPathList(), ResolvePath(), Set3DConfigDir(), SetProject(), and ShortenPath().

---

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

• filename_resolver.h
• filename_resolver.cpp