/*
This routine is platform-independent.
MMEX is a portable application which means ability to to run
without installation, for example, from USB flash drive.
If mmex finds mmexini.db3 in its folder, it assumes portable
mode and GetUserDir() in such case points to that folder.
FIXME: security issue - temp files will be created on host filesystem.
*/
const wxFileName mmex::GetUserDir(bool create)
{
static wxFileName fname;
if (!fname.IsOk())
{
fname = getSettingsPathPortable();
bool portable_file_ok = fname.IsFileWritable() && fname.IsFileReadable();
if (!portable_file_ok)
{
fname.AssignDir(wxStandardPaths::Get().GetUserDataDir());
if (create && !fname.DirExists())
{
portable_file_ok = fname.Mkdir(0700, wxPATH_MKDIR_FULL); // 0700 - octal, "111 000 000"
wxASSERT(portable_file_ok);
}
}
fname.SetFullName(wxGetEmptyString());
}
return fname;
}
wxDateTime GPCB_FPL_CACHE::GetLibModificationTime() const
{
if( !m_lib_path.DirExists() )
return wxDateTime::Now();
return m_lib_path.GetModificationTime();
}
void Path::CreateDirectoryPath(const wxFileName &path){
if(!path.IsDir() || path.DirExists())
return;
wxArrayString folders = path.GetDirs();
wxString workingpath;
//We need to do things differently with a unc path
if(path.GetFullPath().Left(2) == "\\\\")
workingpath = "\\\\?\\UNC\\" + path.GetVolume() + "\\";
else
workingpath = "\\\\?\\" + path.GetVolume() + wxFileName::GetVolumeSeparator() + wxFILE_SEP_PATH;
for(unsigned int i = 0; i < folders.GetCount(); i++){
workingpath = workingpath + folders.Item(i) + wxFILE_SEP_PATH;
#ifdef __WXMSW__
if(!wxDirExists(workingpath) && !CreateDirectory(workingpath.fn_str(), NULL)){
#else
if(!wxDirExists(workingpath) && !wxMkdir(workingpath)){
#endif
wxLogError(_("Could not create") + " " + workingpath);
}
}
}
wxFileName Path::Normalise(const wxFileName &filename){
wxString path = Path::Normalise(filename.GetFullPath());
return wxFileName(path);
}
bool
wxMSWFileSystemWatcher::AddTree(const wxFileName& path,
int events,
const wxString& filter)
{
if ( !filter.empty() )
{
// Use the inefficient generic version as we can only monitor
// everything under the given directory.
//
// Notice that it would probably be better to still monitor everything
// natively and filter out the changes we're not interested in.
return wxFileSystemWatcherBase::AddTree(path, events, filter);
}
if ( !path.DirExists() )
{
wxLogError(_("Can't monitor non-existent directory \"%s\" for changes."),
path.GetFullPath());
return false;
}
return DoAdd(path, events, wxFSWPath_Tree);
}
bool AmeJobMan::makeDirs(wxFileName f){
wxFileName p = f.GetPath();
if(f.DirExists())
return true;
if(!p.DirExists() && !makeDirs(p))
return false;
return f.Mkdir();
}
// static helpers
static const wxFileName& GetWatchDir()
{
static wxFileName dir;
if (dir.DirExists())
return dir;
wxString tmp = wxStandardPaths::Get().GetTempDir();
dir.AssignDir(tmp);
// XXX look for more unique name? there is no function to generate
// unique filename, the file always get created...
dir.AppendDir("fswatcher_test");
CPPUNIT_ASSERT(!dir.DirExists());
CPPUNIT_ASSERT(dir.Mkdir());
return dir;
}
bool wxFileSystemWatcherBase::AddTree(const wxFileName& path, int events,
const wxString& filespec)
{
if (!path.DirExists())
return false;
// OPT could be optimised if we stored information about relationships
// between paths
class AddTraverser : public wxDirTraverser
{
public:
AddTraverser(wxFileSystemWatcherBase* watcher, int events,
const wxString& filespec) :
m_watcher(watcher), m_events(events), m_filespec(filespec)
{
}
virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
{
// There is no need to watch individual files as we watch the
// parent directory which will notify us about any changes in them.
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
if ( m_watcher->AddAny(wxFileName::DirName(dirname),
m_events, wxFSWPath_Tree, m_filespec) )
{
wxLogTrace(wxTRACE_FSWATCHER,
"--- AddTree adding directory '%s' ---", dirname);
}
return wxDIR_CONTINUE;
}
private:
wxFileSystemWatcherBase* m_watcher;
int m_events;
wxString m_filespec;
};
wxDir dir(path.GetFullPath());
// Prevent asserts or infinite loops in trees containing symlinks
int flags = wxDIR_DIRS;
if ( !path.ShouldFollowLink() )
{
flags |= wxDIR_NO_FOLLOW;
}
AddTraverser traverser(this, events, filespec);
dir.Traverse(traverser, filespec, flags);
// Add the path itself explicitly as Traverse() doesn't return it.
AddAny(path.GetPathWithSep(), events, wxFSWPath_Tree, filespec);
return true;
}
//sets IsPresent if the file is valid, and derived properties (filename, formatted, size, etc)
bool EnumerateMemoryCard( McdSlotItem& dest, const wxFileName& filename, const wxDirName basePath )
{
dest.IsFormatted = false;
dest.IsPresent = false;
dest.IsPSX = false;
dest.Type = MemoryCardType::MemoryCard_None;
const wxString fullpath( filename.GetFullPath() );
//DevCon.WriteLn( fullpath );
if ( filename.FileExists() ) {
// might be a memory card file
wxFFile mcdFile( fullpath );
if ( !mcdFile.IsOpened() ) { return false; } // wx should log the error for us.
wxFileOffset length = mcdFile.Length();
if( length < (1024*528) && length != 0x20000 )
{
Console.Warning( "... MemoryCard appears to be truncated. Ignoring." );
return false;
}
dest.SizeInMB = (uint)( length / ( 1024 * 528 * 2 ) );
if ( length == 0x20000 ) {
dest.IsPSX = true; // PSX memcard;
dest.SizeInMB = 1; // MegaBIT
}
dest.Type = MemoryCardType::MemoryCard_File;
dest.IsFormatted = IsMcdFormatted( mcdFile );
filename.GetTimes( NULL, &dest.DateModified, &dest.DateCreated );
} else if ( filename.DirExists() ) {
// might be a memory card folder
wxFileName superBlockFileName( fullpath, L"_pcsx2_superblock" );
if ( !superBlockFileName.FileExists() ) { return false; }
wxFFile mcdFile( superBlockFileName.GetFullPath() );
if ( !mcdFile.IsOpened() ) { return false; }
dest.SizeInMB = 0;
dest.Type = MemoryCardType::MemoryCard_Folder;
dest.IsFormatted = IsMcdFormatted( mcdFile );
superBlockFileName.GetTimes( NULL, &dest.DateModified, &dest.DateCreated );
} else {
// is neither
return false;
}
dest.IsPresent = true;
dest.Filename = filename;
if( filename.GetFullPath() == (basePath+filename.GetFullName()).GetFullPath() )
dest.Filename = filename.GetFullName();
return true;
}
void KICAD_MANAGER_FRAME::CreateNewProject( const wxFileName& aProjectFileName )
{
wxCHECK_RET( aProjectFileName.DirExists() && aProjectFileName.IsDirWritable(),
"Project folder must exist and be writable to create a new project." );
// Init project filename. This clears all elements from the project object.
SetProjectFileName( aProjectFileName.GetFullPath() );
// Copy kicad.pro file from template folder.
if( !aProjectFileName.FileExists() )
{
wxString srcFileName = sys_search().FindValidPath( "kicad.pro" );
// Create a minimal project (.pro) file if the template project file could not be copied.
if( !wxFileName::FileExists( srcFileName )
|| !wxCopyFile( srcFileName, aProjectFileName.GetFullPath() ) )
{
Prj().ConfigSave( PgmTop().SysSearch(), GeneralGroupName, s_KicadManagerParams );
}
}
// Ensure a "stub" for a schematic root sheet and a board exist.
// It will avoid messages from the schematic editor or the board editor to create a new file
// And forces the user to create main files under the right name for the project manager
wxFileName fn( aProjectFileName.GetFullPath() );
fn.SetExt( SchematicFileExtension );
// If a <project>.sch file does not exist, create a "stub" file ( minimal schematic file )
if( !fn.FileExists() )
{
wxFile file( fn.GetFullPath(), wxFile::write );
if( file.IsOpened() )
file.Write( wxT( "EESchema Schematic File Version 2\n"
"EELAYER 25 0\nEELAYER END\n$EndSCHEMATC\n" ) );
// wxFile dtor will close the file
}
// If a <project>.kicad_pcb or <project>.brd file does not exist,
// create a .kicad_pcb "stub" file
fn.SetExt( KiCadPcbFileExtension );
wxFileName leg_fn( fn );
leg_fn.SetExt( LegacyPcbFileExtension );
if( !fn.FileExists() && !leg_fn.FileExists() )
{
wxFile file( fn.GetFullPath(), wxFile::write );
if( file.IsOpened() )
file.Write( wxT( "(kicad_pcb (version 4) (host kicad \"dummy file\") )\n" ) );
// wxFile dtor will close the file
}
}
bool Converter::MakeSureDirExists(wxFileName& path) {
wxFileName parent(path);
parent.RemoveLastDir();
if (parent.GetDirCount() > 0 && !parent.DirExists()) {
if (!MakeSureDirExists(parent)) {
return false;
}
}
if (!path.DirExists()) {
return path.Mkdir();
}
return true;
}
int wxExGetIconID(const wxFileName& filename)
{
if (filename.FileExists(filename.GetFullPath()) ||
filename.DirExists(filename.GetFullPath()))
{
if (filename.DirExists(filename.GetFullPath()))
{
return wxFileIconsTable::folder;
}
else if (!filename.GetExt().empty())
{
return wxTheFileIconsTable->GetIconID(filename.GetExt());
}
else
{
return wxFileIconsTable::file;
}
}
else
{
return wxFileIconsTable::computer;
}
}
void sg_treediff_cache::NotifyExplorerToRefreshPath(SG_context * pCtx, wxFileName path, bool bSpecific)
{
SG_string * pstrFullPath = NULL;
wxString fullName = path.GetFullName();
SG_ERR_CHECK( SG_STRING__ALLOC__SZ(pCtx, &pstrFullPath, path.GetFullPath().ToUTF8()) );
//Use %s to handle getting a path that has a %s in it.
//SG_ERR_CHECK( SG_UTF8__INTERN_FROM_OS_BUFFER(pCtx, pstrFullPath, path.GetFullPath().ToStdWstring()) );
//SG_log__report_verbose(pCtx, "FS_CHANGE(%s): %s", (const char *)ExplainAction(dwAction), SG_string__sz(pstrFullPath));
{
clearCache(pCtx);
if (!m_bIsWin7) //if we're running on XP or Vista
{
wxCriticalSectionLocker lock(m_notify_critical_section);
m_bHaveGottenNewFileChanges = true;
//For some reason, on XP and Vista, we need to notify for every folder up to the root.
if (path.FileExists() || path.DirExists())
{
if (m_aPathsToNotify.Index(path.GetFullPath()) == wxNOT_FOUND)
m_aPathsToNotify.Add(path.GetFullPath());
}
wxFileName currentDir = wxFileName::DirName(path.GetPath(wxPATH_GET_VOLUME));
wxFileName topDir = GetTopDir();
//currentDir = topDir;
while (topDir.GetDirCount() < currentDir.GetDirCount())
{
if (m_aPathsToNotify.Index(currentDir.GetFullPath()) == wxNOT_FOUND)
m_aPathsToNotify.Add(currentDir.GetFullPath());
currentDir.RemoveLastDir();
}
}
else
{
wxCriticalSectionLocker lock(m_notify_critical_section);
m_bHaveGottenNewFileChanges = true;
//On Win 7, just notifying for the top of the working folder
//will cause a recursive refresh down the tree.
if (m_aPathsToNotify.Index(GetTopDir().GetFullPath()) == wxNOT_FOUND)
m_aPathsToNotify.Add(GetTopDir().GetFullPath());
if (bSpecific)
m_aPathsToNotify.Add(path.GetFullPath());
}
}
fail:
return;
}
bool wxFileSystemWatcherBase::AddTree(const wxFileName& path, int events,
const wxString& filter)
{
if (!path.DirExists())
return false;
// OPT could be optimised if we stored information about relationships
// between paths
class AddTraverser : public wxDirTraverser
{
public:
AddTraverser(wxFileSystemWatcherBase* watcher, int events) :
m_watcher(watcher), m_events(events)
{
}
// CHECK we choose which files to delegate to Add(), maybe we should pass
// all of them to Add() and let it choose? this is useful when adding a
// file to a dir that is already watched, then not only should we know
// about that, but Add() should also behave well then
virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
{
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
wxLogTrace(wxTRACE_FSWATCHER, "--- AddTree adding '%s' ---",
dirname);
// we add as much as possible and ignore errors
m_watcher->Add(wxFileName(dirname), m_events);
return wxDIR_CONTINUE;
}
private:
wxFileSystemWatcherBase* m_watcher;
int m_events;
wxString m_filter;
};
wxDir dir(path.GetFullPath());
AddTraverser traverser(this, events);
dir.Traverse(traverser, filter);
return true;
}
bool GPCB_FPL_CACHE::IsModified( const wxString& aLibPath, const wxString& aFootprintName ) const
{
// The library is modified if the library path got deleted or changed.
if( !m_lib_path.DirExists() || !IsPath( aLibPath ) )
return true;
// If no footprint was specified, check every file modification time against the time
// it was loaded.
if( aFootprintName.IsEmpty() )
{
for( MODULE_CITER it = m_modules.begin(); it != m_modules.end(); ++it )
{
wxFileName fn = m_lib_path;
fn.SetName( it->second->GetFileName().GetName() );
fn.SetExt( KiCadFootprintFileExtension );
if( !fn.FileExists() )
{
wxLogTrace( traceFootprintLibrary,
wxT( "Footprint cache file '%s' does not exist." ),
fn.GetFullPath().GetData() );
return true;
}
if( it->second->IsModified() )
{
wxLogTrace( traceFootprintLibrary,
wxT( "Footprint cache file '%s' has been modified." ),
fn.GetFullPath().GetData() );
return true;
}
}
}
else
{
MODULE_CITER it = m_modules.find( TO_UTF8( aFootprintName ) );
if( it == m_modules.end() || it->second->IsModified() )
return true;
}
return false;
}
bool wxFileSystemWatcherBase::Add(const wxFileName& path, int events)
{
wxFSWPathType type = wxFSWPath_None;
if ( path.FileExists() )
{
type = wxFSWPath_File;
}
else if ( path.DirExists() )
{
type = wxFSWPath_Dir;
}
else
{
wxLogError(_("Can't monitor non-existent path \"%s\" for changes."),
path.GetFullPath());
return false;
}
return AddAny(path, events, type);
}
bool wxFileSystemWatcherBase::Add(const wxFileName& path, int events)
{
// args validation & consistency checks
if (!path.FileExists() && !path.DirExists())
return false;
wxString canonical = GetCanonicalPath(path);
if (canonical.IsEmpty())
return false;
wxCHECK_MSG(m_watches.find(canonical) == m_watches.end(), false,
wxString::Format("Path '%s' is already watched", canonical));
// adding a path in a platform specific way
wxFSWatchInfo watch(canonical, events);
if ( !m_service->Add(watch) )
return false;
// on success, add path to our 'watch-list'
wxFSWatchInfoMap::value_type val(canonical, watch);
return m_watches.insert(val).second;
}
bool wxFileSystemWatcherBase::Add(const wxFileName& path, int events)
{
wxFSWPathType type = wxFSWPath_None;
if ( path.FileExists() )
{
type = wxFSWPath_File;
}
else if ( path.DirExists() )
{
type = wxFSWPath_Dir;
}
else
{
// Don't overreact to being passed a non-existent item. It may have
// only just been deleted, in which case doing nothing is correct
wxLogTrace(wxTRACE_FSWATCHER,
"Can't monitor non-existent path \"%s\" for changes.",
path.GetFullPath());
return false;
}
return AddAny(path, events, type);
}
bool wxFileSystemWatcherBase::RemoveTree(const wxFileName& path)
{
if (!path.DirExists())
return false;
// OPT could be optimised if we stored information about relationships
// between paths
class RemoveTraverser : public wxDirTraverser
{
public:
RemoveTraverser(wxFileSystemWatcherBase* watcher) :
m_watcher(watcher)
{
}
virtual wxDirTraverseResult OnFile(const wxString& filename)
{
m_watcher->Remove(wxFileName(filename));
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
m_watcher->RemoveTree(wxFileName(dirname));
return wxDIR_CONTINUE;
}
private:
wxFileSystemWatcherBase* m_watcher;
};
wxDir dir(path.GetFullPath());
RemoveTraverser traverser(this);
dir.Traverse(traverser);
return true;
}
bool IsValidInstance(wxFileName rootDir)
{
return rootDir.DirExists() && wxFileExists(Path::Combine(rootDir, cfgFileName));
}
bool wxFsEventsFileSystemWatcher::AddTree(const wxFileName& path, int events,
const wxString& filespec)
{
if (!path.DirExists())
{
return false;
}
wxString canonical = GetCanonicalPath(path);
if ( canonical.empty() )
{
return false;
}
CFRunLoopRef cfLoop = CFRunLoopGetCurrent();
wxASSERT_MSG(
cfLoop,
"there must be a current event loop; this file watcher needs it."
);
if ( ! cfLoop )
{
return false;
}
if ( m_streams.find(canonical) != m_streams.end() )
{
// How to take into account filespec
// if client adds a watch for /home/*.cpp
// and then on another call wants to add a
// call to /home/*.h
// Ideally we should not create another watch
// however we would need to keep both filespecs
// around, which we don't do now.
return false;
}
// Will need to pass the desired event flags
// and filespec to our callback via the context
// we make sure to give the context a cleanup
// callback.
FSEventStreamContext ctx;
wxFSEventWatcherContext* watcherContext = new wxFSEventWatcherContext(
this, events, filespec.Clone()
);
ctx.version = 0;
ctx.info = watcherContext;
ctx.retain = NULL;
ctx.release = &wxDeleteContext;
ctx.copyDescription = NULL;
CFTimeInterval latency = 0.2;
wxMacUniCharBuffer pathChars(path.GetPath());
CFStringRef pathRef = CFStringCreateWithCharacters(
kCFAllocatorDefault,
pathChars.GetBuffer(),
pathChars.GetChars()
);
CFArrayRef pathRefs = CFArrayCreate(
kCFAllocatorDefault, (const void**)&pathRef, 1, NULL
);
FSEventStreamCreateFlags flags = kFSEventStreamCreateFlagWatchRoot
| kFSEventStreamCreateFlagFileEvents;
FSEventStreamRef stream = FSEventStreamCreate(
kCFAllocatorDefault,
&wxFSEventCallback,
&ctx,
pathRefs, kFSEventStreamEventIdSinceNow,
latency, flags);
bool started = false;
if ( stream )
{
FSEventStreamScheduleWithRunLoop(stream, cfLoop, kCFRunLoopDefaultMode);
started = FSEventStreamStart(stream);
if ( started )
{
m_streams[canonical] = stream;
}
}
// cleanup the paths, as we own the pointers
CFRelease(pathRef);
CFRelease(pathRefs);
wxASSERT_MSG(stream, "could not create FS stream");
return started;
}
bool removeDirs(wxFileName f){
if(f.DirExists() && f.Rmdir())
return removeDirs(f.GetPath());
return true;
}
bool wxFileSystemWatcherBase::RemoveTree(const wxFileName& path)
{
if (!path.DirExists())
return false;
// OPT could be optimised if we stored information about relationships
// between paths
class RemoveTraverser : public wxDirTraverser
{
public:
RemoveTraverser(wxFileSystemWatcherBase* watcher,
const wxString& filespec) :
m_watcher(watcher), m_filespec(filespec)
{
}
virtual wxDirTraverseResult OnFile(const wxString& WXUNUSED(filename))
{
// We never watch the individual files when watching the tree, so
// nothing to do here.
return wxDIR_CONTINUE;
}
virtual wxDirTraverseResult OnDir(const wxString& dirname)
{
m_watcher->Remove(wxFileName::DirName(dirname));
return wxDIR_CONTINUE;
}
private:
wxFileSystemWatcherBase* m_watcher;
wxString m_filespec;
};
// If AddTree() used a filespec, we must use the same one
wxString canonical = GetCanonicalPath(path);
wxFSWatchInfoMap::iterator it = m_watches.find(canonical);
wxCHECK_MSG( it != m_watches.end(), false,
wxString::Format("Path '%s' is not watched", canonical) );
wxFSWatchInfo watch = it->second;
const wxString filespec = watch.GetFilespec();
#if defined(__WINDOWS__)
// When there's no filespec, the wxMSW AddTree() would have set a watch
// on only the passed 'path'. We must therefore remove only this
if (filespec.empty())
{
return Remove(path);
}
// Otherwise fall through to the generic implementation
#endif // __WINDOWS__
wxDir dir(path.GetFullPath());
// AddTree() might have used the wxDIR_NO_FOLLOW to prevent asserts or
// infinite loops in trees containing symlinks. We need to do the same
// or we'll try to remove unwatched items. Let's hope the caller used
// the same ShouldFollowLink() setting as in AddTree()...
int flags = wxDIR_DIRS;
if ( !path.ShouldFollowLink() )
{
flags |= wxDIR_NO_FOLLOW;
}
RemoveTraverser traverser(this, filespec);
dir.Traverse(traverser, filespec, flags);
// As in AddTree() above, handle the path itself explicitly.
Remove(path);
return true;
}