/// <summary>
/// Iterate thru all the filesysteminfo objects and add it to our zip file
/// </summary>
/// <param name="fileSystemInfosToZip">a collection of files/directores</param>
/// <param name="z">our existing ZipFile object</param>
private static void GetFilesToZip(FileSystemInfo[] fileSystemInfosToZip, ZipFile z)
{
//check whether the objects are null
if (fileSystemInfosToZip != null && z != null)
{
//iterate thru all the filesystem info objects
foreach (FileSystemInfo fi in fileSystemInfosToZip)
{
//check if it is a directory
if (fi is DirectoryInfo)
{
DirectoryInfo di = (DirectoryInfo)fi;
//add the directory
z.AddDirectory(di.FullName);
//drill thru the directory to get all
//the files and folders inside it.
GetFilesToZip(di.GetFileSystemInfos(), z);
}
else
{
//add it
z.Add(fi.FullName);
}
}
}
}
internal static bool ImportBook(FileSystemInfo file, IMLSection booksSection, string fileName, string ext)
{
if (ext != ".pdf" && ext != ".PDF" && ext != ".djvu" && ext != ".DJVU")
return false;
if (!Settings.EnableBooksImporter)
return false;
bool itemfound = false;
IMLItemList list = booksSection.SearchByLocation(file.FullName);
foreach (IMLItem item in list.Where(item => item.Location == file.FullName))
itemfound = true;
if (itemfound)
return true;
Application.DoEvents();
Debugger.LogMessageToFile("Importing book " + file.Name + "...");
Importer.ThisProgress.Progress(Importer.CurrentProgress, "Importing book " + file.Name + "...");
IMLItem Item;
Helpers.AddFileToSection(out Item, booksSection, fileName, file.FullName, file.FullName);
return true;
}
private static void CopyDirectory(string sourcePath, string destinationPath)
{
//-----------------------------------------------------------------------
System.IO.DirectoryInfo sourceDirectoryInfo = new System.IO.DirectoryInfo(sourcePath);
// If the destination folder don't exist then create it
if (!System.IO.Directory.Exists(destinationPath))
{
System.IO.Directory.CreateDirectory(destinationPath);
}
System.IO.FileSystemInfo fileSystemInfo = null;
foreach (FileSystemInfo fileSystemInfo_loopVariable in sourceDirectoryInfo.GetFileSystemInfos())
{
fileSystemInfo = fileSystemInfo_loopVariable;
string destinationFileName = System.IO.Path.Combine(destinationPath, fileSystemInfo.Name);
// Now check whether its a file or a folder and take action accordingly
if (fileSystemInfo is System.IO.FileInfo)
{
System.IO.File.Copy(fileSystemInfo.FullName, destinationFileName, true); Console.WriteLine(
FolderDifference(sourcePath, PluginFolder) + "\\" + fileSystemInfo);
}
else
{
// Recursively call the mothod to copy all the neste folders
CopyDirectory(fileSystemInfo.FullName, destinationFileName);
}
}
}
public IDirectoryTreeNode Create(FileSystemInfo root, FileSystemInfo location)
{
string relativePathFromRoot = root == null ? @".\" : PathExtensions.MakeRelativePath(root, location);
var directory = location as DirectoryInfo;
if (directory != null)
{
return new FolderDirectoryTreeNode(directory, relativePathFromRoot);
}
var file = location as FileInfo;
if (relevantFileDetector.IsFeatureFile(file))
{
Feature feature = featureParser.Parse(file.FullName);
if (feature != null)
{
return new FeatureDirectoryTreeNode(file, relativePathFromRoot, feature);
}
throw new InvalidOperationException("This feature file could not be read and will be excluded");
}
else if (relevantFileDetector.IsMarkdownFile(file))
{
XElement markdownContent = htmlMarkdownFormatter.Format(File.ReadAllText(file.FullName));
return new MarkdownTreeNode(file, relativePathFromRoot, markdownContent);
}
throw new InvalidOperationException("Cannot create an IItemNode-derived object for " + file.FullName);
}
internal static bool SkipAlreadyImportedFiles
(FileSystemInfo file, IEnumerable<string> filmLocations,
IEnumerable<string> tvshowsLocations, IEnumerable<string> musicLocations)
{
//TODO: Make existing item search faster by specifying the media type to be scanned.
Helpers.UpdateProgress("Importing Media Files...",
"Searching media library for existing file entry...", null);
if (SearchForExistingItemInMoviesSection(file, filmLocations))
return true;
if (SearchForExistingItemInTvShowsSection(file, tvshowsLocations))
return true;
// ReSharper disable ConvertIfStatementToReturnStatement
if (SearchForExistingItemInMusicSection(file, musicLocations))
// ReSharper restore ConvertIfStatementToReturnStatement
return true;
return false;
}
public FeatureDirectoryTreeNode(FileSystemInfo location, string relativePathFromRoot, Feature feature)
{
this.OriginalLocation = location;
this.OriginalLocationUrl = location.ToUri();
this.RelativePathFromRoot = relativePathFromRoot;
this.Feature = feature;
}
/// <summary>
/// 编译文件AssetBundle名字
/// </summary>
/// <param name="file">文件信息</param>
/// <param name="basePath">基础路径</param>
protected static void BuildFileBundleName(FileSystemInfo file , string basePath)
{
string extension = file.Extension;
string fullName = file.FullName.Standard();
string fileName = file.Name;
string baseFileName = fileName.Substring(0 , fileName.Length - extension.Length);
string assetName = fullName.Substring(basePath.Length);
assetName = assetName.Substring(0 , assetName.Length - fileName.Length).TrimEnd('/');
if(baseFileName + extension == ".DS_Store"){ return; }
int variantIndex = baseFileName.LastIndexOf(".");
string variantName = string.Empty;
if(variantIndex > 0){
variantName = baseFileName.Substring(variantIndex + 1);
}
AssetImporter assetImporter = AssetImporter.GetAtPath("Assets" + Env.ResourcesBuildPath + assetName + "/" + baseFileName + extension);
assetImporter.assetBundleName = assetName.TrimStart('/');
if(variantName != string.Empty){
assetImporter.assetBundleVariant = variantName;
}
}
private static bool SearchForExistingItemInMoviesSection(FileSystemInfo file, IEnumerable<string> filmLocations,
IMLSection section)
{
if (filmLocations == null)
return false;
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var movieFolder in Settings.FilmsFolders)
// ReSharper restore LoopCanBeConvertedToQuery
{
if (!file.FullName.Contains(movieFolder))
continue;
//if (filmLocations.Any(location => location == file.FullName))
// return true;
IMLItem item =
section.FindItemByExternalID
(file.FullName);
if (item != null)
return true;
}
return false;
}
internal static void AddFileToIgnoredExtensions
(FileSystemInfo file, IList<string> extensionsToIgnore,
string audioCodec, string fileName, bool isAudio,
bool isVideo, string videoCodec, string ext)
{
if (isVideo || isAudio)
return;
if ((ext == ".iso" || ext == ".ISO") || (ext == ".ifo" || ext == ".IFO") || (ext == ".pdf" || ext == ".PDF") ||
(ext == ".djvu" || ext == ".DJVU"))
return;
if (!Settings.EnableMediaDetection || !String.IsNullOrEmpty(videoCodec) || !String.IsNullOrEmpty(audioCodec))
return;
Debugger.LogMessageToFile("Thhe MediaInfo process detected that the file " + fileName +
" does not contain video nor audio. The file's extension " + ext +
" will be added to the ignored extensions list.");
extensionsToIgnore.Add(file.Extension);
}
private static string[] ToStringArray(FileSystemInfo obj,
IEnumerable<object> paths)
{
if (null == obj)
{
throw new ArgumentNullException("obj");
}
var args = new List<string>
{
obj.FullName
};
#if NET20
if (ObjectExtensionMethods.IsNotNull(paths))
#else
if (paths.IsNotNull())
#endif
{
var range = paths
#if NET20
.Where(x => ObjectExtensionMethods.IsNotNull(x))
#else
.Where(x => x.IsNotNull())
#endif
.Select(path => path.ToString().RemoveIllegalFileCharacters());
args.AddRange(range);
}
return args.ToArray();
}
/// <summary>
/// Deletes a file.
/// </summary>
/// <param name="file">The file to delete.</param>
public static void Delete(FileSystemInfo file)
{
if (File.Exists(file.FullName))
{
File.Delete(file.FullName);
}
}
public MarkdownTreeNode(FileSystemInfo location, string relativePathFromRoot, XElement markdownContent)
{
this.OriginalLocation = location;
this.OriginalLocationUrl = location.ToUri();
this.RelativePathFromRoot = relativePathFromRoot;
this.MarkdownContent = markdownContent;
}
/// <summary>
/// Add a File/Directory to the ZipFile
/// </summary>
/// <param name="z">ZipFile object</param>
/// <param name="fileSystemInfoToZip">the FileSystemInfo object to zip</param>
public static void Add(this ZipFile z, FileSystemInfo fileSystemInfoToZip)
{
Add(z, new FileSystemInfo[]
{
fileSystemInfoToZip
});
}
/// <summary>
/// Calculates the FileSystemInfo object's relative path to a DirectoryInfo object
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public static string RelativePathOfItem(this DirectoryInfo directory, FileSystemInfo item)
{
Mandate.That<ArgumentNullException>(item != null);
Mandate.That<ArgumentException>(item.FullName.Contains(directory.FullName));
return item.FullName.Replace(directory.FullName, String.Empty).TrimStart(Path.DirectorySeparatorChar);
}
internal void AddFileSystemItem(FileSystemInfo f)
{
//if it doesn't exist, don't proceed.
if (!f.Exists)
return;
AddCaseInsensitiveString(f.FullName);
AddDateTime(f.CreationTimeUtc);
AddDateTime(f.LastWriteTimeUtc);
//check if it is a file or folder
var fileInfo = f as FileInfo;
if (fileInfo != null)
{
AddInt(fileInfo.Length.GetHashCode());
}
var dirInfo = f as DirectoryInfo;
if (dirInfo != null)
{
foreach (var d in dirInfo.GetFiles())
{
AddFile(d);
}
foreach (var s in dirInfo.GetDirectories())
{
AddFolder(s);
}
}
}
public static void Format(FtpCommandContext context, FileSystemInfo fileInfo, StringBuilder output)
{
var isFile = fileInfo is FileInfo;
//Size
output.AppendFormat("size={0};", isFile ? ((FileInfo)fileInfo).Length : 0);
//Permission
output.AppendFormat("perm={0}{1};",
/* Can read */ isFile ? "r" : "el",
/* Can write */ isFile ? "adfw" : "fpcm");
//Type
output.AppendFormat("type={0};", isFile ? "file" : "dir");
//Create
output.AppendFormat("create={0};", FtpDateUtils.FormatFtpDate(fileInfo.CreationTimeUtc));
//Modify
output.AppendFormat("modify={0};", FtpDateUtils.FormatFtpDate(fileInfo.LastWriteTimeUtc));
//File name
output.Append(DELIM);
output.Append(fileInfo.Name);
output.Append(NEWLINE);
}
public static string MakeRelativePath(FileSystemInfo from, FileSystemInfo to)
{
if (from == null) throw new ArgumentNullException("from");
if (to == null) throw new ArgumentNullException("to");
return MakeRelativePath(from.FullName, to.FullName);
}
internal static bool VideoIsLocatedInAMovieFolder(FileSystemInfo file)
{
Application.DoEvents();
bool isFilm = false;
foreach (string filmsFolder
in Settings.FilmsFolders)
{
if (String.IsNullOrEmpty
(filmsFolder))
continue;
if (!file.FullName
.Contains
(filmsFolder))
continue;
Debugger.LogMessageToFile(
"This video file is contained" +
" in the specified films root directory" +
" and will be considered to be a film.");
isFilm = true;
}
Application.DoEvents();
return isFilm;
}
protected override Task<HttpResponseMessage> CreateItemGetResponse(FileSystemInfo info, string localFilePath)
{
// We don't support getting a file from the zip controller
// Conceivably, it could be a zip file containing just the one file, but that's rarely interesting
HttpResponseMessage notFoundResponse = Request.CreateResponse(HttpStatusCode.NotFound);
return Task.FromResult(notFoundResponse);
}
/// <summary>
/// This function launch the restore process, with the NpgsqlConnection parameters. Restore
/// will be done on the server and database pointed by the NpgsqlConnection
/// </summary>
/// <param name="connection">The NpgsqlConnection containg the database location
/// settings</param>
/// <param name="login">The login used to restore database</param>
/// <param name="password">The password associed to login</param>
/// <param name="backupFile">The backup file to restore</param>
/// <returns>Returns a Result that tells if operation succeeds</returns>
public Result Restore(
IDbConnection connection,
string login,
string password,
FileSystemInfo backupFile)
{
IPAddress connectionIpAddress = IPAddress.None;
if (connection != null)
{
// TODO fix connection.Host and connection.Port
if (IPAddress.TryParse(/*connection.Host*/ "127.0.0.1", out connectionIpAddress)
&& (connectionIpAddress != IPAddress.None))
{
return this.Restore(
connectionIpAddress,
5432, // (short)connection.Port,
connection.Database,
login,
password,
backupFile);
}
else
{
return Result.InvalidIpAddress;
}
}
return Result.InvalidNpgsqlConnection;
}
public SparkleMacWatcher(string path)
{
this.thread = new Thread (new ThreadStart (delegate {
DateTime timestamp;
DirectoryInfo parent = new DirectoryInfo (path);
this.last_changed = new DirectoryInfo (path);
while (true) {
timestamp = this.last_changed.LastWriteTime;
GetLastChange (parent);
if (DateTime.Compare (this.last_changed.LastWriteTime, timestamp) != 0) {
string relative_path = this.last_changed.FullName.Substring (path.Length + 1);
if (Changed != null)
Changed (relative_path);
}
Thread.Sleep (7500);
this.poll_count++;
}
}));
this.thread.Start ();
}
private static void DoTouch(FileSystemInfo fileSystemInfo, DateTime now)
{
FileAttributes fileAttributes = fileSystemInfo.Attributes;
try
{
fileSystemInfo.Attributes = FileAttributes.Normal;
fileSystemInfo.CreationTime = now;
fileSystemInfo.LastWriteTime = now;
fileSystemInfo.LastAccessTime = now;
}
catch (System.Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
//Restore Attributes in case anything happens
try
{
fileSystemInfo.Attributes = fileAttributes;
}
finally
{
}
}
}
private static int SearchInFile(FileSystemInfo file, string needle)
{
var byteBuffer = File.ReadAllBytes(file.FullName);
var enc = ReadBOM(byteBuffer);
if (!Equals(enc, Encoding.ASCII)) // if BOM is detected
{
var stringBuffer = enc.GetString(File.ReadAllBytes(file.FullName));
var offset = stringBuffer.IndexOf(needle, StringComparison.InvariantCulture);
return offset;
}
var encoList = new List<Encoding> // if not - search by all ways
{
Encoding.Default,
Encoding.ASCII,
Encoding.UTF8,
Encoding.Unicode,
Encoding.BigEndianUnicode
};
foreach (var enco in encoList)
{
var offset = enco.GetString(byteBuffer).IndexOf(needle, StringComparison.InvariantCulture);
if (offset == -1) continue;
return offset;
}
return -1;
}
public static unsafe HleIoDirent ConvertFileSystemInfoToHleIoDirent(FileSystemInfo FileSystemInfo)
{
var HleIoDirent = default(HleIoDirent);
var FileInfo = (FileSystemInfo as FileInfo);
var DirectoryInfo = (FileSystemInfo as DirectoryInfo);
{
if (DirectoryInfo != null)
{
HleIoDirent.Stat.Size = 0;
HleIoDirent.Stat.Mode = SceMode.Directory | (SceMode)Convert.ToInt32("777", 8);
HleIoDirent.Stat.Attributes = IOFileModes.Directory;
PointerUtils.StoreStringOnPtr(FileSystemInfo.Name, Encoding.UTF8, HleIoDirent.Name);
}
else
{
HleIoDirent.Stat.Size = FileInfo.Length;
HleIoDirent.Stat.Mode = SceMode.File | (SceMode)Convert.ToInt32("777", 8);
//HleIoDirent.Stat.Attributes = IOFileModes.File | IOFileModes.CanRead | IOFileModes.CanWrite | IOFileModes.CanExecute;
HleIoDirent.Stat.Attributes = IOFileModes.File;
PointerUtils.StoreStringOnPtr(FileSystemInfo.Name.ToUpper(), Encoding.UTF8, HleIoDirent.Name);
}
HleIoDirent.Stat.DeviceDependentData0 = 10;
}
return HleIoDirent;
}
public override string CheckOut(IPackageTree packageTree, FileSystemInfo destination)
{
SvnUpdateResult result = null;
using (var client = new SvnClient())
{
try
{
var svnOptions = new SvnCheckOutArgs();
if (UseRevision.HasValue)
svnOptions.Revision = new SvnRevision(UseRevision.Value);
client.CheckOut(new SvnUriTarget(new Uri(Url)), destination.FullName, svnOptions, out result);
}
catch (SvnRepositoryIOException sre)
{
HandleExceptions(sre);
}
catch (SvnObstructedUpdateException sue)
{
HandleExceptions(sue);
}
}
return result.Revision.ToString();
}
/// <summary>
/// Determines if the directory contains the other directory or file at any depth.
/// </summary>
public static bool Contains(this DirectoryInfo dir, FileSystemInfo other)
{
if (dir == null) throw new ArgumentNullException("dir");
if (other == null) throw new ArgumentNullException("other");
return other.FullName.StartsWith(dir.FullName, true, null);
}
public static string CreateRelativePathTo(this DirectoryInfo dir, FileSystemInfo file)
{
if (dir.FullName.EqualsIgnoreCase(file.FullName))
return ".";
if (file.FullName.StartsWith(dir.FullName, StringComparison.InvariantCultureIgnoreCase))
{
return file.FullName.ReplaceFirst(dir.FullName + "\\", "", StringComparison.InvariantCultureIgnoreCase);
}
else
{
DirectoryInfo dir2 = file as DirectoryInfo;
if (dir2 == null)
dir2 = ((FileInfo)file).Directory;
var dirPath = dir.GetPath();
var dir2Path = dir2.GetPath();
while (dirPath.Peek() == dir2Path.Peek())
{
dirPath.Pop();
dir2Path.Pop();
}
var final = dirPath.Peek().FullName;
foreach (var p in dirPath)
{
final = Path.Combine(final, "..");
}
foreach (var p in dir2Path)
{
final = Path.Combine(final, p.Name);
}
if (file is FileInfo)
final = Path.Combine(final, ((FileInfo)file).Name);
return final;
}
}
public FileGroupInfo(FileSystemInfo _main, FileGroupInfoType _type)
{
main = _main;
type = _type;
files = new List<FileSystemInfo>();
numbers = new Dictionary<FileSystemInfo, uint>();
}
public MovieFileViewModel(System.IO.FileSystemInfo sysFile)
{
if (SysTemConfiger.ExceptShowFile.Exists(l => l == sysFile.Extension))
{
return;
}
if (sysFile is FileInfo)
{
FileInfo file = sysFile as FileInfo;
this.FileName = sysFile.Name;
this.FilePath = sysFile.FullName;
this.IsFile = true;
this.Size = file.Length;
}
else
{
this.FileName = sysFile.Name;
this.FilePath = sysFile.FullName;
this.IsFile = false;
}
this.LastTime = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
RelayCommand = new RelayCommand(new Action <object>(ButtonClickFunc));
this.RefreshImage();
}
public Item(FileSystemInfo info)
{
Id = Guid.NewGuid().ToString();
Name = info.Name;
Created = info.CreationTime;
Modified = info.LastWriteTime;
LastAccess = info.LastAccessTime;
var fileInfo = info as FileInfo;
if (fileInfo != null)
{
m_isReadOnly = fileInfo.IsReadOnly;
Size = fileInfo.Length;
IsFile = true;
}
else
{
IsFile = false;
}
FileSecurity fs = File.GetAccessControl(info.FullName);
var sidOwning = fs.GetOwner(typeof(SecurityIdentifier));
var ntAccount = sidOwning.Translate(typeof(NTAccount));
Owner = ntAccount.Value;
// todo: it's not so important, but still put here something like read, write etc.
var sidRules = fs.GetAccessRules(true, true, typeof(SecurityIdentifier));
List<string> rulesList = new List<string>(sidRules.Count);
for (int i = 0; i < sidRules.Count; i++)
{
rulesList.Add(sidRules[i].IdentityReference.Value);
}
Rights = string.Join("; ", rulesList);
}
private static string EncodeItem(FileSystemInfo file)
{
var name = Path.GetFileNameWithoutExtension(file.Name);
var value = File.ReadAllText(file.FullName);
var item = new { Name = name, Value = value };
return Json.Encode(item);
}
static string GetDirFileString(int level, System.IO.FileSystemInfo dirfile)
{
//char l0 = '+'; Пробовал с символами псвдографики, без них понравилось больше
//char l1 = '\u251C';// ├
//char l2 = '\u2500';// ─
//char l02 = '\u2502';// │
//char l3 = '\u2514'; //└
string indent = level == 0 ? "" : " ";
char horizLine = Properties.Settings.Default.HorizLines ? '-' : ' ';
int mode = Properties.Settings.Default.ViewMode;
int maxFileNameLen = Const.GetMaxFileNameLen(mode);
string s = indent + dirfile.Name;
if (s.Length > maxFileNameLen)
{
s = s.Substring(0, maxFileNameLen - 3) + Str.tooLongString; //если длина строки больше ширины колонки
}
s = s.PadRight(maxFileNameLen, horizLine); //колонка 1
if (mode > 0)
{
string s1;
if (dirfile.GetType() == typeof(System.IO.FileInfo))
{
System.IO.FileInfo f = (System.IO.FileInfo)dirfile;
s1 = Str.GetSizeString(f.Length);
}
else
{
s1 = Str.directory;
}
s1 = s1.PadRight(Const.sizeStringLen); //колонка 2
s += s1;
}
if (mode > 1)
{
string s1 = Str.GetFileAttributesString(dirfile.Attributes);
s1 = s1.PadRight(Const.attrStringLen); //колонка 3
s += s1;
}
if (mode > 2)
{
string s1 = dirfile.CreationTime.ToString(Str.dateTimePatt);
s1 = s1.PadRight(Const.timeStringLen); //колонка 4
s += s1;
}
if (mode > 3)
{
string s1 = dirfile.LastAccessTime.ToString(Str.dateTimePatt);
s1 = s1.PadRight(Const.timeStringLen); //колонка 5
s += s1;
}
if (mode > 4)
{
string s1 = dirfile.LastWriteTime.ToString(Str.dateTimePatt);
s1 = s1.PadRight(Const.timeStringLen); //колонка 6
s += s1;
}
return(s);
}
private static void CopyFolder(string strSources, string strDest)
{
System.IO.DirectoryInfo directoryInfo = new System.IO.DirectoryInfo(strSources);
System.IO.FileSystemInfo[] fileSystemInfos = directoryInfo.GetFileSystemInfos();
for (int i = 0; i < fileSystemInfos.Length; i++)
{
System.IO.FileSystemInfo fileSystemInfo = fileSystemInfos[i];
string text = System.IO.Path.Combine(strDest, fileSystemInfo.Name);
if (fileSystemInfo is System.IO.FileInfo)
{
System.IO.File.Copy(fileSystemInfo.FullName, text, true);
}
else
{
System.IO.Directory.CreateDirectory(text);
FileUtils.CopyFolder(fileSystemInfo.FullName, text);
}
}
}
public static string SetAttributes(this System.IO.FileSystemInfo __file)
{
string attributes = "";
if (__file.Attributes.HasFlag(FileAttributes.ReadOnly))
{
attributes += "r";
}
else
{
attributes += "-";
}
if (__file.Attributes.HasFlag(FileAttributes.Archive))
{
attributes += "a";
}
else
{
attributes += "-";
}
if (__file.Attributes.HasFlag(FileAttributes.Hidden))
{
attributes += "h";
}
else
{
attributes += "-";
}
if (__file.Attributes.HasFlag(FileAttributes.System))
{
attributes += "s";
}
else
{
attributes += "-";
}
return(attributes);
}
//public void RemoveLayersfromTOC(string directory)
//{
// //IMxDocument mxMap = (IMxDocument)application.Document;
// //IMap pMap = mxMap.FocusMap;
// //IMapLayers pMapLayers = pMap;
// for (int i = 0; i <= ArcMap.Document.FocusMap.LayerCount - 1; i++)
// {
// ILayer player = ArcMap.Document.FocusMap.Layer[i];
// if (player is IGroupLayer)
// {
// RemoveLayersfromGroupLayer((IGroupLayer)player, directory);
// }
// else
// {
// IDataset pDS = player;
// try
// {
// if (LCase(directory) == LCase(pDS.Workspace.PathName))
// {
// pMap.DeleteLayer(player);
// }
// }
// }
// if (player != null)
// {
// System.Runtime.InteropServices.Marshal.ReleaseComObject(player);
// player = null;
// }
// }
// mxMap.UpdateContents();
// mxMap.ActiveView.Refresh();
// ESRI.ArcGIS.ArcMapUI.IContentsView pContentsView = mxMap.CurrentContentsView;
// pContentsView.Refresh(null);
// if (mxMap != null)
// {
// System.Runtime.InteropServices.Marshal.ReleaseComObject(mxMap);
// mxMap = null;
// }
// if (pContentsView != null)
// {
// System.Runtime.InteropServices.Marshal.ReleaseComObject(pContentsView);
// pContentsView = null;
// }
//}
//public void RemoveLayersfromGroupLayer(IGroupLayer pGroupLayer, string directory)
//{
// ILayer pLayer;
// List<ILayer> LayersToDelete = new List<ILayer>();
// ICompositeLayer pCompositeLayer = (ICompositeLayer)pGroupLayer;
// for (int i = 1; i <= pCompositeLayer.Count; i++)
// {
// pLayer = pCompositeLayer.Layer[i - 1];
// if (pLayer is IGroupLayer)
// {
// RemoveLayersfromGroupLayer(pLayer, directory);
// }
// else
// {
// try
// {
// IDataset pDS = (IDataset)pLayer;
// string LayerDirectoryname = pDS.Workspace.PathName.ToLower();
// if (LayerDirectoryname.EndsWith(IO.Path.DirectorySeparatorChar))
// {
// LayerDirectoryname = LayerDirectoryname.Substring(0, LayerDirectoryname.Length - 1);
// }
// if (LCase(directory) == LayerDirectoryname)
// {
// LayersToDelete.Add(pLayer);
// }
// }
// catch (Exception ex)
// {
// Debug.WriteLine(ex.Message);
// }
// }
// }
// foreach (ILayer pDeleteLayer in LayersToDelete)
// {
// pGroupLayer.Delete(pDeleteLayer);
// if (pDeleteLayer != null)
// {
// System.Runtime.InteropServices.Marshal.ReleaseComObject(pDeleteLayer);
// pDeleteLayer = null;
// }
// }
// if (pGroupLayer != null)
// {
// System.Runtime.InteropServices.Marshal.ReleaseComObject(pGroupLayer);
// pGroupLayer = null;
// }
//}
//public void RemoveGroupLayer(string sGroupLayerName)
//{
// IMap pMap = ArcMap.Document.FocusMap;
// UID pUID = new UID();
// pUID.Value = "{EDAD6644-1810-11D1-86AE-0000F8751720}";
// IEnumLayer pEnum = ArcMap.Document.FocusMap.Layers[pUID, true];
// ILayer pL = pEnum.Next();
// while (pL is ILayer)
// {
// if (string.Compare(sGroupLayerName, pL.Name, true) == 0)
// {
// pMap.DeleteLayer(pL);
// }
// pL = pEnum.Next();
// }
//}
public static IRasterLayer IsRasterLayerInGroupLayer(System.IO.FileSystemInfo rasterPath, IGroupLayer pGrpLyr)
{
ICompositeLayer compositeLayer = pGrpLyr as ICompositeLayer;
if (compositeLayer != null & compositeLayer.Count > 0)
{
for (int i = 0; i <= compositeLayer.Count - 1; i++)
{
if (compositeLayer.Layer[i] is IRasterLayer)
{
IRasterLayer pLayer = (IRasterLayer)compositeLayer.Layer[i];
if (string.Compare(pLayer.FilePath, rasterPath.FullName, true) == 0)
{
return(pLayer);
}
}
}
}
return(null);
}
public FileBindModel(System.IO.FileSystemInfo sysFile)
{
if (SysTemConfiger.ExceptShowFile.Exists(l => l == sysFile.Extension))
{
return;
}
if (sysFile is FileInfo)
{
this.FileName = sysFile.Name;
this.FilePath = sysFile.FullName;
this.IsFile = true;
}
else
{
this.FileName = sysFile.Name;
this.FilePath = sysFile.FullName;
this.IsFile = false;
}
this.LastTime = DateTime.Now;
}
public WrappedFileInfo(FSI fsi) => this.fsi = fsi;
private static ExclusiveLock CreateFileSystemLock(System.IO.FileSystemInfo fileSystemInfo)
{
Platform.CheckForNullReference(fileSystemInfo, "fileSystemInfo");
return(CreateFileSystemLock(fileSystemInfo.FullName));
}
public static string get_FullName(System.IO.FileSystemInfo aThis)
{
return("FullName not implemented yet in FileSystemInfo plug");
}
protected StorageItem(SysIO.FileSystemInfo item)
{
BaseStorageItem = item ?? throw new ArgumentNullException(nameof(item));
}
public void SetAttributes(string path, FileAttributes attributes)
{
// Validate that only flags from the attribute are being provided. This is an
// approximation for the validation done by the Win32 function.
const FileAttributes allValidFlags =
FileAttributes.Archive | FileAttributes.Compressed | FileAttributes.Device |
FileAttributes.Directory | FileAttributes.Encrypted | FileAttributes.Hidden |
FileAttributes.IntegrityStream | FileAttributes.Normal | FileAttributes.NoScrubData |
FileAttributes.NotContentIndexed | FileAttributes.Offline | FileAttributes.ReadOnly |
FileAttributes.ReparsePoint | FileAttributes.SparseFile | FileAttributes.System |
FileAttributes.Temporary;
if ((attributes & ~allValidFlags) != 0)
{
// Using constant string for argument to match historical throw
throw new ArgumentException(SR.Arg_InvalidFileAttrs, "Attributes");
}
EnsureStatInitialized(path);
if (!_exists)
{
FileSystemInfo.ThrowNotFound(path);
}
if (Interop.Sys.CanSetHiddenFlag)
{
if ((attributes & FileAttributes.Hidden) != 0)
{
if ((_fileStatus.UserFlags & (uint)Interop.Sys.UserFlags.UF_HIDDEN) == 0)
{
// If Hidden flag is set and cached file status does not have the flag set then set it
Interop.CheckIo(Interop.Sys.LChflags(path, (_fileStatus.UserFlags | (uint)Interop.Sys.UserFlags.UF_HIDDEN)), path, InitiallyDirectory);
}
}
else
{
if ((_fileStatus.UserFlags & (uint)Interop.Sys.UserFlags.UF_HIDDEN) == (uint)Interop.Sys.UserFlags.UF_HIDDEN)
{
// If Hidden flag is not set and cached file status does have the flag set then remove it
Interop.CheckIo(Interop.Sys.LChflags(path, (_fileStatus.UserFlags & ~(uint)Interop.Sys.UserFlags.UF_HIDDEN)), path, InitiallyDirectory);
}
}
}
// The only thing we can reasonably change is whether the file object is readonly by changing permissions.
int newMode = _fileStatus.Mode;
if ((attributes & FileAttributes.ReadOnly) != 0)
{
// Take away all write permissions from user/group/everyone
newMode &= ~(int)(Interop.Sys.Permissions.S_IWUSR | Interop.Sys.Permissions.S_IWGRP | Interop.Sys.Permissions.S_IWOTH);
}
else if ((newMode & (int)Interop.Sys.Permissions.S_IRUSR) != 0)
{
// Give write permission to the owner if the owner has read permission
newMode |= (int)Interop.Sys.Permissions.S_IWUSR;
}
// Change the permissions on the file
if (newMode != _fileStatus.Mode)
{
Interop.CheckIo(Interop.Sys.ChMod(path, newMode), path, InitiallyDirectory);
}
_fileStatusInitialized = -1;
}
public FileSystemEntry(FileSystemEntry parent, System.IO.FileSystemInfo systemFileInfo)
{
Parent = parent;
Name = systemFileInfo.Name;
this.systemFileInfo = systemFileInfo;
}
/// <summary>
/// constructor
/// </summary>
/// <param name="name"></param>
/// <param name="fi"></param>
/// <param name="img_idx"></param>
/// <param name="sel_img"></param>
public FileTreeNode(string key, string name, FileSystemInfo fi, int img_idx, int sel_img)
: base(key, name, img_idx, sel_img)
{
this.fi = fi;
InitializeRoot();
}
/// <summary>
/// constructor
/// </summary>
/// <param name="name"></param>
/// <param name="fi"></param>
public FileTreeNode(string key, string name, FileSystemInfo fi)
: base(key, name)
{
this.fi = fi;
InitializeRoot();
}
private unsafe void SetAccessOrWriteTimeCore(string path, DateTimeOffset time, bool isAccessTime, bool checkCreationTime, bool asDirectory)
{
// This api is used to set creation time on non OSX platforms, and as a fallback for OSX platforms.
// The reason why we use it to set 'creation time' is the below comment:
// Unix provides APIs to update the last access time (atime) and last modification time (mtime).
// There is no API to update the CreationTime.
// Some platforms (e.g. Linux) don't store a creation time. On those platforms, the creation time
// is synthesized as the oldest of last status change time (ctime) and last modification time (mtime).
// We update the LastWriteTime (mtime).
// This triggers a metadata change for FileSystemWatcher NotifyFilters.CreationTime.
// Updating the mtime, causes the ctime to be set to 'now'. So, on platforms that don't store a
// CreationTime, GetCreationTime will return the value that was previously set (when that value
// wasn't in the future).
// force a refresh so that we have an up-to-date times for values not being overwritten
InvalidateCaches();
EnsureCachesInitialized(path);
if (!EntryExists)
{
FileSystemInfo.ThrowNotFound(path);
}
// we use utimes()/utimensat() to set the accessTime and writeTime
Interop.Sys.TimeSpec *buf = stackalloc Interop.Sys.TimeSpec[2];
long seconds = time.ToUnixTimeSeconds();
long nanoseconds = UnixTimeSecondsToNanoseconds(time, seconds);
#if TARGET_BROWSER
buf[0].TvSec = seconds;
buf[0].TvNsec = nanoseconds;
buf[1].TvSec = seconds;
buf[1].TvNsec = nanoseconds;
#else
if (isAccessTime)
{
buf[0].TvSec = seconds;
buf[0].TvNsec = nanoseconds;
buf[1].TvSec = _fileCache.MTime;
buf[1].TvNsec = _fileCache.MTimeNsec;
}
else
{
buf[0].TvSec = _fileCache.ATime;
buf[0].TvNsec = _fileCache.ATimeNsec;
buf[1].TvSec = seconds;
buf[1].TvNsec = nanoseconds;
}
#endif
Interop.CheckIo(Interop.Sys.UTimensat(path, buf), path, asDirectory);
// On OSX-like platforms, when the modification time is less than the creation time (including
// when the modification time is already less than but access time is being set), the creation
// time is set to the modification time due to the api we're currently using; this is not
// desirable behaviour since it is inconsistent with windows behaviour and is not logical to
// the programmer (ie. we'd have to document it), so these api calls revert the creation time
// when it shouldn't be set (since we're setting modification time and access time here).
// checkCreationTime is only true on OSX-like platforms.
// allowFallbackToLastWriteTime is ignored on non OSX-like platforms.
bool updateCreationTime = checkCreationTime && (_fileCache.Flags & Interop.Sys.FileStatusFlags.HasBirthTime) != 0 &&
(buf[1].TvSec < _fileCache.BirthTime || (buf[1].TvSec == _fileCache.BirthTime && buf[1].TvNsec < _fileCache.BirthTimeNsec));
InvalidateCaches();
if (updateCreationTime)
{
Interop.Error error = SetCreationTimeCore(path, _fileCache.BirthTime, _fileCache.BirthTimeNsec);
if (error != Interop.Error.SUCCESS && error != Interop.Error.ENOTSUP)
{
Interop.CheckIo(error, path, asDirectory);
}
}
}
private static void ExtractBackup(FileSystemInfo file, string extractionDirectory)
{
ZipFile.ExtractToDirectory(file.FullName, extractionDirectory);
}
/// <summary>
/// Combines the screenshots into one contiguous screenshot
/// </summary>
/// <param name="files">The files (images) to combine</param>
/// <param name="e">For UX, an output progress message</param>
public static void CombineScreenshot(FileSystemInfo[] files, WaitWindowEventArgs e)
{
string screenshotLocation = Path.Combine(Constants.CacheLocation, "temp.png");
using (MagickImageCollection images = new MagickImageCollection())
{
// Add the first image
var orderedFiles = files.OrderBy(f => f.CreationTime);
foreach (FileSystemInfo file in orderedFiles)
{
MagickImage first = new MagickImage(file.FullName);
e.Window.Message = "Obtaining Snapshots... Please Wait";
images.Add(first);
}
using (MagickImage result = images.AppendVertically())
{
e.Window.Message = "Building Screenshot... Please Wait" + System.Environment.NewLine + "This can take a minute.";
try
{
result.Write(screenshotLocation);
} catch (MagickImageErrorException err)
{
Debug.WriteLine($"Error: {err}");
}
}
}
}
