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 () const
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 (const 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...
bool	WritePathList (const wxString &aDir, const wxString &aFilename, bool aResolvePaths)
	Write the current path list to a config file. 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 () const
	Return a pointer to the internal path list; the items in:load. More...
bool	SplitAlias (const wxString &aFileName, wxString &anAlias, wxString &aRelPath) const
	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) const
	Returns true if the given path is a valid aliased relative path. More...
bool	GetKicadPaths (std::list< wxString > &paths) const
	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...
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 54 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 406 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 ), wxEmptyString );

 path.Normalize();

 if( !path.DirExists() )
 {
 if( aPath.m_Pathvar == wxT( "${KICAD6_3DMODEL_DIR}" )
 || aPath.m_Pathvar == wxT( "${KIPRJMOD}" ) || aPath.m_Pathvar == wxT( "$(KIPRJMOD)" )
 || aPath.m_Pathvar == wxT( "${KISYS3DMOD}" ) || aPath.m_Pathvar == wxT( "$(KISYS3DMOD)" ) )
 {
 // suppress the message if the missing pathvar is a system variable
 }
 else
 {
 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
 }

 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 == 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, mutex_resolver, and path.

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 676 of file filename_resolver.cpp.

{
 bool useParen = false;

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

 size_t pEnd;

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

 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( wxT( "${" ) ) )
 break;

 ++sPL;
 }

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

 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 159 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 = wxT( "${KIPRJMOD}" );
 lpath.m_Pathvar = wxT( "${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, wxEmptyString );
 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, wxT( " * [3D model] search paths:\n" ) );
 std::list< SEARCH_PATH >::const_iterator sPL = m_paths.begin();

 while( sPL != m_paths.end() )
 {
 wxLogTrace( MASK_3D_RESOLVER, wxT( " + %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

)

const

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 1049 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( wxT( "KICAD_PTEMPLATES" ) )
 || mS->first == wxString( wxT( "KICAD6_FOOTPRINT_DIR" ) ) )
 {
 ++mS;
 continue;
 }

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

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

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

 ++mS;
 }

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

 return true;
}

References PGM_BASE::GetLocalEnvVariables(), and m_pgm.

Referenced by createPathList().

GetPaths()

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

(

)

const

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 827 of file filename_resolver.cpp.

{
 return &m_paths;
}

References m_paths.

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

GetProjectDir()

wxString FILENAME_RESOLVER::GetProjectDir

(

)

const

Definition at line 140 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 486 of file filename_resolver.cpp.

{
 if( m_configDir.empty() )
 {
 std::ostringstream ostr;
 ostr << __FILE__ << ": " << __FUNCTION__ << ": " << __LINE__ << "\n";
 wxString errmsg = wxT( "3D configuration directory is unknown" );
 ostr << wxT( " * " ) << errmsg.ToUTF8();
 wxLogTrace( MASK_3D_RESOLVER, wxT( "%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 = wxT( "no 3D configuration file" );
 ostr << " * " << errmsg.ToUTF8() << " '";
 ostr << cfgname.ToUTF8() << "'";
 wxLogTrace( MASK_3D_RESOLVER, wxT( "%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 = wxT( "Could not open configuration file" );
 ostr << " * " << errmsg.ToUTF8() << " '" << cfgname.ToUTF8() << "'";
 wxLogTrace( MASK_3D_RESOLVER, wxT( "%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;

 // Don't add KICAD6_3DMODEL_DIR, one of its legacy equivalents, or KIPRJMOD from a
 // config file. They're system variables are are defined at runtime.
 if( al.m_Alias == wxT( "${KICAD6_3DMODEL_DIR}" )
 || al.m_Alias == wxT( "${KIPRJMOD}" ) || al.m_Alias == wxT( "$(KIPRJMOD)" )
 || al.m_Alias == wxT( "${KISYS3DMOD}" ) || al.m_Alias == wxT( "$(KISYS3DMOD)" ) )
 {
 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( m_configDir, RESOLVER_CONFIG, false );

 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 242 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 preferably be performed via 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 );

 // 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( wxT( "${" ) ) || aFileName.StartsWith( wxT( "$(" ) ) )
 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( wxT( "${" ) ) || aFileName.StartsWith( wxT( "$(" ) ) )
 {
 if( !( m_errflags & ERRFLG_ENVPATH ) )
 {
 m_errflags |= ERRFLG_ENVPATH;
 wxString errmsg = wxT( "[3D File Resolver] No such path; ensure the environment var is defined" );
 errmsg.append( wxT( "\n" ) );
 errmsg.append( tname );
 errmsg.append( wxT( "\n" ) );
 wxLogTrace( tracePathsAndFiles, errmsg );
 }

 return wxEmptyString;
 }

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

 // check the path relative to the current project directory;
 // NB: 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( !m_paths.begin()->m_Pathexp.empty() && !tname.StartsWith( wxT( ":" ) ) )
 {
 tmpFN.Assign( m_paths.begin()->m_Pathexp, wxEmptyString );
 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( wxT( ":" ) ) )
 {
 wxFileName fpath;
 wxString fullPath( wxT( "${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;
 }

 }

 // 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} is not set or is incorrect.
 m_errflags |= ERRFLG_RELPATH;
 wxString errmsg = wxT( "[3D File Resolver] No such path" );
 errmsg.append( wxT( "\n" ) );
 errmsg.append( tname );
 errmsg.append( wxT( "\n" ) );
 wxLogTrace( tracePathsAndFiles, errmsg );
 }

 return wxEmptyString;
 }

 for( const SEARCH_PATH& path : m_paths )
 {
 // ${ENV_VAR} paths have already been checked; skip them
 if( path.m_Alias.StartsWith( wxT( "${" ) ) || path.m_Alias.StartsWith( wxT( "$(" ) ) )
 continue;

 if( path.m_Alias == alias && !path.m_Pathexp.empty() )
 {
 wxFileName fpath( wxFileName::DirName( path.m_Pathexp ) );
 wxString fullPath = fpath.GetPathWithSep() + relpath;

 fullPath = ExpandEnvVarSubstitutions( fullPath, m_project );

 if( wxFileName::FileExists( fullPath ) )
 {
 tname = fullPath;

 wxFileName tmp( fullPath );

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

 return tname;
 }
 }
 }

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

 return wxEmptyString;
}

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

Referenced by EXPORTER_PCB_VRML::ExportVrmlFootprint(), idf_export_footprint(), S3D_CACHE::load(), and PANEL_FP_PROPERTIES_3D_MODEL::validateModelExists().

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 62 of file filename_resolver.cpp.

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

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

 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 146 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 81 of file filename_resolver.cpp.

{
 m_project = aProject;

 if( !aProject )
 return false;

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

 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 = wxT( "${KIPRJMOD}" );
 al.m_Pathvar = wxT( "${KIPRJMOD}" );
 al.m_Pathexp = m_curProjDir;
 m_paths.push_back( al );

 if( flgChanged )
 *flgChanged = true;
 }
 else
 {
 if( m_paths.front().m_Pathexp != 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, wxT( "%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 736 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( wxT( "${" ) ) || sL->m_Alias.StartsWith( wxT( "$(" ) ) )
 {
 wxString tpath = ExpandEnvVarSubstitutions( sL->m_Alias, m_project );

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

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

 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( wxT( "${" ) ) || sL->m_Alias.StartsWith( wxT( "$(" ) ) )
 {
 // old style ENV_VAR
 tname = sL->m_Alias;
 tname.Append( wxT( "/" ) );
 tname.append( fname );
 }
 else
 {
 // new style alias
 tname = wxT( ":" );
 tname.append( sL->m_Alias );
 tname.append( wxT( ":" ) );
 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 DIALOG_SELECT_3DMODEL::TransferDataFromWindow().

SplitAlias()

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

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 833 of file filename_resolver.cpp.

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

 size_t searchStart = 0;

 if( aFileName.StartsWith( wxT( ":" ) ) )
 searchStart = 1;

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

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

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

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

 return true;
}

Referenced by PANEL_FP_PROPERTIES_3D_MODEL::OnAdd3DModel(), PANEL_FP_PROPERTIES_3D_MODEL::ReloadModelsFromFootprint(), and ResolvePath().

UpdatePathList()

bool FILENAME_RESOLVER::UpdatePathList

(

const 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 228 of file filename_resolver.cpp.

{
 wxUniChar envMarker( '$' );

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

 for( const SEARCH_PATH& path : aPathList )
 addPath( path );

 return WritePathList( m_configDir, RESOLVER_CONFIG, false );
}

References addPath(), m_configDir, m_paths, path, RESOLVER_CONFIG, and WritePathList().

Referenced by DIALOG_CONFIGURE_PATHS::TransferDataFromWindow().

ValidateFileName()

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

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 954 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;
 wxString lpath;
 size_t aliasStart = aFileName.StartsWith( ':' ) ? 1 : 0;
 size_t aliasEnd = aFileName.find( ':', aliasStart );

 // 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( aliasEnd != wxString::npos )
 {
 size_t pos1 = filename.find( wxT( ":\\" ) );

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

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

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

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

 lpath = filename.substr( aliasStart, aliasEnd );

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

 hasAlias = true;
 lpath = aFileName.substr( aliasEnd + 1 );
 }
 else
 {
 lpath = aFileName;

 // in the case of ${ENV_VAR}|$(ENV_VAR)/path, strip the
 // environment string before testing
 aliasEnd = wxString::npos;

 if( aFileName.StartsWith( wxT( "${" ) ) )
 aliasEnd = aFileName.find( '}' );
 else if( aFileName.StartsWith( wxT( "$(" ) ) )
 aliasEnd = aFileName.find( ')' );

 if( aliasEnd != wxString::npos )
 lpath = aFileName.substr( aliasEnd + 1 );

 }

 // Test for forbidden chars in filenames. Should be wxFileName::GetForbiddenChars()
 // On MSW, the list returned by wxFileName::GetForbiddenChars() contains separators
 // '\'and '/' used here because lpath can be a full path.
 // So remove separators
 wxString lpath_no_sep = lpath;
#ifdef __WINDOWS__
 lpath_no_sep.Replace( wxT( "/" ), wxT( " " ) );
 lpath_no_sep.Replace( wxT( "\\" ), wxT( " " ) );

 // A disk identifier is allowed, and therefore remove its separator
 if( lpath_no_sep.Length() > 1 && lpath_no_sep[1] == ':' )
 lpath_no_sep[1] = ' ';
#endif

 if( wxString::npos != lpath_no_sep.find_first_of( wxFileName::GetForbiddenChars() ) )
 return false;

 return true;
}

Referenced by PANEL_FP_PROPERTIES_3D_MODEL::On3DModelCellChanged(), and PANEL_FP_PROPERTIES_3D_MODEL::validateModelExists().

WritePathList()

bool FILENAME_RESOLVER::WritePathList	(	const wxString &	aDir,
		const wxString &	aFilename,
		bool	aResolvePaths
	)

Write the current path list to a config file.

Parameters

aResolvePaths

indicates whether env vars should also be written out or not

Definition at line 594 of file filename_resolver.cpp.

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

 return false;
 }

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

 if( !aResolvePaths )
 {
 // skip all ${ENV_VAR} alias names

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

 wxFileName cfgpath( aDir, aFilename );
 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, wxT( "%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 << "\",";

 if( aResolvePaths )
 tstr = ExpandEnvVarSubstitutions( sPL->m_Pathvar, m_project ).ToUTF8();
 else
 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, ExpandEnvVarSubstitutions(), m_paths, m_project, and MASK_3D_RESOLVER.

Referenced by DIALOG_EXPORT_STEP::onExportButton(), readPathList(), and UpdatePathList().

Member Data Documentation

m_configDir

wxString FILENAME_RESOLVER::m_configDir

private

Definition at line 177 of file filename_resolver.h.

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

m_curProjDir

wxString FILENAME_RESOLVER::m_curProjDir

private

Definition at line 182 of file filename_resolver.h.

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

m_errflags

int FILENAME_RESOLVER::m_errflags

private

Definition at line 179 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 178 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 180 of file filename_resolver.h.

Referenced by GetKicadPaths(), and SetProgramBase().

m_project

PROJECT* FILENAME_RESOLVER::m_project

private

Definition at line 181 of file filename_resolver.h.

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

---

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

• filename_resolver.h
• filename_resolver.cpp