public bool Exists(string path, FileSystemItem type = FileSystemItem.Both) { path = PreparePath(path); if (type != FileSystemItem.Directory && File.Exists(path)) return true; if (type != FileSystemItem.File && Directory.Exists(path)) return true; return false; }
public bool Delete(string path, FileSystemItem type = FileSystemItem.Both) { path = PreparePath(path); if (type != FileSystemItem.Directory && File.Exists(path)) { File.Delete(path); return true; } if (type != FileSystemItem.File && Directory.Exists(path)) { RecursiveDeleteDirectory(path); return true; } return false; }
public CacheItem GetCacheEntry(FileSystemItem item) { CacheComplexKey cacheKey; return(GetCacheEntry(item, out cacheKey)); }
public MatchedFileSystemItem(FileSystemItem fileSystemItem, MatchString matchedString) { Name = fileSystemItem.Name; FullPath = fileSystemItem.FullPath; MatchedItemName = matchedString; }
public override void CopyTo(FileSystemItem item) { var destinationPath = PrepareCopyTo(item); LongPathFile.Copy(Path, destinationPath, true); }
private bool IsCopy(FileSystemItem a, FileSystemItem b) { //TODO return(a.Name == b.Name); }
public FileSystemItem MoveTo(FileSystemItem item) { UnderlyingDirectory.MoveTo(item); return item; }
public FileSystemItem MoveTo(FileSystemItem item) { Contract.Requires(item != null); throw new System.NotImplementedException(); }
public FileSystemItem(FileSystemItem parent) { this.parent = parent; }
public FileSystemItem() { parent = null; }
private void TagList_LoadPath(FileSystemItem directory) { //Set currentDirectory = directory; selectedId = TagId.Null; //Build Directory Path directoryBox.Text = string.Empty; FileSystemItem parent = directory.Parent; while (parent != null) { directoryBox.Text = $@"{parent.Name}\" + directoryBox.Text; parent = parent.Parent; } directoryBox.Text += directory.Name; //Check if (directory.Parent != null) { TagList.Items.Add(new ListViewItem("...") { Tag = directory.Parent, ImageIndex = 0 }); } //Loop foreach (FileSystemItem item in directory.Children) { //Get Length float length = item.Length; string suffix = "B"; //Simplify String if (length > 1024) //Kibibyte { length /= 1024; suffix = "KiB"; } if (length > 1024) //Mebibyte { length /= 1024; suffix = "MiB"; } if (length > 1024) //Gibibyte { length /= 1024; suffix = "GiB"; } if (length > 1024) //Tebibyte { length /= 1024; suffix = "TiB"; } //Prepare string[] parts = new string[4]; parts[0] = item.Name; parts[1] = item.Type; parts[2] = item.Length > 0 ? $"{length:0} {suffix}" : string.Empty; parts[3] = item.ID != 0 ? item.ID.ToString() : string.Empty; //Create ListViewItem listItem = new ListViewItem(parts); listItem.ImageIndex = item.IsFolder ? 0 : 1; listItem.Tag = item; //Add TagList.Items.Add(listItem); } }
public FileSystemItem MoveTo(FileSystemItem item) { UnderlyingDirectory.MoveTo(item); return(item); }
public void CopyTo(FileSystemItem item) { UnderlyingDirectory.CopyTo(item); }
public abstract void CopyTo(FileSystemItem item);
/// <inheritdoc/> protected override IEnumerable <FileSystemItem> EnumerateItemsImpl(UPath path, SearchOption searchOption, SearchPredicate?searchPredicate) { // Internal method used to retrieve the list of search locations List <SearchLocation> GetSearchLocations(UPath basePath) { var locations = new List <SearchLocation>(); var matchedMount = false; foreach (var kvp in _mounts) { // Check if path partially matches a mount name var remainingPath = GetRemaining(basePath, kvp.Key); if (!remainingPath.IsNull && remainingPath != UPath.Root) { locations.Add(new SearchLocation(this, basePath, remainingPath)); continue; } if (!matchedMount) { // Check if path fully matches a mount name remainingPath = GetRemaining(kvp.Key, basePath); if (!remainingPath.IsNull) { matchedMount = true; // don't check other mounts, we don't want to merge them together if (kvp.Value.DirectoryExists(remainingPath)) { locations.Add(new SearchLocation(kvp.Value, kvp.Key, remainingPath)); } } } } if (!matchedMount && Fallback != null && Fallback.DirectoryExists(basePath)) { locations.Add(new SearchLocation(Fallback, UPath.Null, basePath)); } return(locations); } var directoryToVisit = new List <UPath> { path }; var entries = new HashSet <UPath>(); var sortedDirectories = new SortedSet <UPath>(); var first = true; while (directoryToVisit.Count > 0) { var pathToVisit = directoryToVisit[0]; directoryToVisit.RemoveAt(0); var dirIndex = 0; entries.Clear(); sortedDirectories.Clear(); var locations = GetSearchLocations(pathToVisit); // Only need to search within one filesystem, no need to sort or do other work if (locations.Count == 1 && locations[0].FileSystem != this && (!first || searchOption == SearchOption.AllDirectories)) { var last = locations[0]; foreach (var item in last.FileSystem.EnumerateItems(last.Path, searchOption, searchPredicate)) { var localItem = item; localItem.Path = CombinePrefix(last.Prefix, item.Path); if (entries.Add(localItem.Path)) { yield return(localItem); } } } else { for (var i = locations.Count - 1; i >= 0; i--) { var location = locations[i]; var fileSystem = location.FileSystem; var searchPath = location.Path; if (fileSystem == this) { // List a single part of a mount name, queue it to be visited if needed var mountPart = new UPath(searchPath.GetFirstDirectory(out _)).ToRelative(); var mountPath = location.Prefix / mountPart; var item = new FileSystemItem(this, mountPath, true); if (searchPredicate == null || searchPredicate(ref item)) { if (entries.Add(item.Path)) { yield return(item); } } if (searchOption == SearchOption.AllDirectories) { sortedDirectories.Add(mountPath); } } else { // List files in the mounted filesystems, merged and sorted into one list foreach (var item in fileSystem.EnumerateItems(searchPath, SearchOption.TopDirectoryOnly, searchPredicate)) { var publicName = CombinePrefix(location.Prefix, item.Path); if (entries.Add(publicName)) { var localItem = item; localItem.Path = publicName; yield return(localItem); if (searchOption == SearchOption.AllDirectories && item.IsDirectory) { sortedDirectories.Add(publicName); } } } } } } if (first) { if (locations.Count == 0 && path != UPath.Root) { throw NewDirectoryNotFoundException(path); } first = false; } // Enqueue directories and respect order foreach (var nextDir in sortedDirectories) { directoryToVisit.Insert(dirIndex++, nextDir); } } }
public override Stream ReadFile(FileManagerFile file) { FileSystemItem fileItem = FindFileItem(file); return(new MemoryStream(fileItem.Content.ToArray())); }
protected override Clue MakeClueImpl(FileSystemItem <DirectoryInfo> input, Guid accountId) { if (input == null) { throw new ArgumentNullException(nameof(input)); } var value = input.Item; var uriBuilder = new FileSystemInfoUriBuilder(); var clue = _factory.Create(EntityType.Files.Directory, uriBuilder.GetUri(value).AbsoluteUri, accountId); var data = clue.Data.EntityData; var uri = uriBuilder.GetUri(value); data.Name = value.Name; // + crawl.FileSystemInfo.Extension; data.DisplayName = value.Name; data.Uri = uri; data.Culture = CultureInfo.InvariantCulture; var attributes = value.Attributes; var isReadOnly = (attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly; var isHidden = (attributes & FileAttributes.Hidden) == FileAttributes.Hidden; var isArchive = (attributes & FileAttributes.Archive) == FileAttributes.Archive; var isSystem = (attributes & FileAttributes.System) == FileAttributes.System; var vocab = new DirectoryInfoVocabulary(); var securityVocab = new FileSecurityVocabulary(); data.Properties[vocab.IsReadOnly] = isReadOnly.ToString(); data.Properties[vocab.IsHidden] = isHidden.ToString(); data.Properties[vocab.IsArchive] = isArchive.ToString(); data.Properties[vocab.IsSystem] = isSystem.ToString(); data.Properties[securityVocab.OwnerSID] = input.Owner.PrintIfAvailable(v => v.Sid.ToString()); data.Properties[securityVocab.OwnerNTAccount] = input.Owner.PrintIfAvailable(v => v.Account?.ToString()); data.Properties[securityVocab.OwnerDisplayName] = input.Owner.PrintIfAvailable(v => v.Principal?.DisplayName); data.Properties[vocab.CreationTimeUtc] = value.CreationTimeUtc.ToString("o"); data.Properties[vocab.LastWriteTimeUtc] = value.LastWriteTimeUtc.ToString("o"); clue.ValidationRuleSuppressions.AddRange(new[] { RuleConstants.METADATA_002_Uri_MustBeSet }); try { if (IsDirectoryInfoEntry(input, value.FullName)) { _factory.CreateOutgoingEntityReference(clue, EntityType.Infrastructure.Host.Computer, EntityEdgeType.Parent, Environment.MachineName, p => p); } else if (value.Parent != null) { var parentUri = uriBuilder.GetUri(value.Parent); _factory.CreateOutgoingEntityReference(clue, EntityType.Files.Directory, EntityEdgeType.Parent, parentUri, p => p.AbsoluteUri, p => value.Parent.Name); } } catch (PathTooLongException) { } if (input.Owner != null && input.Owner.Sid != null) { _factory.CreateOutgoingEntityReference(clue, EntityType.Infrastructure.User, EntityEdgeType.OwnedBy, input.Owner, p => p.Sid.ToString(), p => p?.Principal?.DisplayName ?? p?.Principal?.Name ?? p?.Principal?.SamAccountName ?? p?.Account?.ToString()); } return(clue); }
public override DateTime GetLastWriteTime(FileManagerFile file) { FileSystemItem fileItem = FindFileItem(file); return(fileItem.LastWriteTime); }
public void Copy(string source, string dest, bool overwrite = false, FileSystemItem type = FileSystemItem.Both) { source = PreparePath(source); dest = PreparePath(dest); if (type != FileSystemItem.Directory && File.Exists(source)) { string destDir = Path.GetDirectoryName(dest); if (destDir == null) throw new ArgumentException("Invalid destination path: " + dest); if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir); File.Copy(source, dest, overwrite); } else if (type != FileSystemItem.File && Directory.Exists(source)) { DirectoryCopy(source, dest, overwrite); } else throw new FileNotFoundException("File not found", source); }
public override DateTime GetLastWriteTime(FileManagerFolder folder) { FileSystemItem folderItem = FindFolderItem(folder); return(folderItem.LastWriteTime); }
public void CopyTo(FileSystemItem item) { _backingFile.CopyTo(item); }
public override long GetLength(FileManagerFile file) { FileSystemItem fileItem = FindFileItem(file); return(fileItem.Content.Length); }
public override FileSystemItem MoveTo(FileSystemItem item) { LongPathFile.Move(Path, item.Path); return item; }
public override void CopyFile(FileManagerFile file, FileManagerFolder newParentFolder) { FileSystemItem fileItem = FindFileItem(file); CopyCore(fileItem, newParentFolder.RelativeName, false); }
private void FillItemInfo(FileSystemItem fileSystemItem) { var fileInfo = new FileInfo(fileSystemItem.Path); var fileAccessInfo = fileInfo.GetAccessControl(); var owner = fileAccessInfo.GetOwner(accouuntType).ToString(); var currentUser = $"{(string.IsNullOrEmpty(Environment.UserDomainName) ? string.Empty : $"{Environment.UserDomainName}\\" )}{Environment.UserName}";
protected void UpdateAndSubmitChangesCore(FileSystemItem item, Action <FileSystemItem> update) { update(item); Data.SaveChanges(); RefreshFolderCache(); }
public CacheItem RecognizeTitle(FileSystemItem item) { var cacheKey = GetCacheKey(item); CacheItem cacheItem = null; switch (item.TitleType) { case TitleType.Profile: var content = GetProfileData(item, cacheKey.Item); if (content == null && RecognizeInaccessibleProfile != null) { RecognizeInaccessibleProfile.Invoke(item); } cacheItem = SaveProfileCache(cacheKey, item, content); break; case TitleType.Game: if (item.Type == ItemType.File) { GetGameDataFromGpd(item); } else if (!GetGameData(item)) { if (_userSettingsProvider.UseUnity) { GetGameDataFromUnity(item); } } cacheItem = SaveGameCache(cacheKey, item); break; case TitleType.Content: cacheItem = _cacheManager.Set(cacheKey.Key, item); item.IsCached = true; break; case TitleType.DataFile: if (item.Type == ItemType.File) { try { var header = _fileManager.ReadFileContent(item.Path, StfsPackage.DefaultHeaderSizeVersion1 + 12); var svod = ModelFactory.GetModel <SvodPackage>(header); if (svod.IsValid) { item.Title = svod.DisplayName; if (svod.InstallerType == InstallerType.TitleUpdate) { var ver = svod.ReadValue <Version>(StfsPackage.DefaultHeaderSizeVersion1 + 8, 4, new BinaryDataAttribute(EndianType.BigEndian)); item.Title = string.Format("{0} (TU{1})", svod.DisplayName, ver.Build); } if (!svod.ThumbnailImage.All(b => b == 0)) { item.Thumbnail = svod.ThumbnailImage; } item.ContentType = svod.ContentType; item.RecognitionState = RecognitionState.Recognized; } cacheItem = SaveDataFileCache(cacheKey, item); } catch { item.IsLocked = true; item.LockMessage = Resx.InaccessibleFileErrorMessage; } item.IsCached = true; } break; } return(cacheItem); }
private string Write55_ItemCapability(FileSystemItem.ItemCapability v) { switch (v) { case FileSystemItem.ItemCapability.IsShellFolderShortcut: return "IsShellFolderShortcut"; case FileSystemItem.ItemCapability.HasShellFolderShortcut: return "HasShellFolderShortcut"; case FileSystemItem.ItemCapability.Deleted: return "Deleted"; case FileSystemItem.ItemCapability.None: return "None"; case FileSystemItem.ItemCapability.HasParent: return "HasParent"; case FileSystemItem.ItemCapability.HasExtender: return "HasExtender"; case FileSystemItem.ItemCapability.HasTarget: return "HasTarget"; case FileSystemItem.ItemCapability.HasSize: return "HasSize"; case FileSystemItem.ItemCapability.HasThumbnail: return "HasThumbnail"; case FileSystemItem.ItemCapability.IsParentReal: return "IsParentReal"; case FileSystemItem.ItemCapability.UseTargetIcon: return "UseTargetIcon"; case FileSystemItem.ItemCapability.GlobalFileChangedAssigned: return "GlobalFileChangedAssigned"; case FileSystemItem.ItemCapability.IsShellLink: return "IsShellLink"; case FileSystemItem.ItemCapability.IsUrlLink: return "IsUrlLink"; case FileSystemItem.ItemCapability.HasCreationTime: return "HasCreationTime"; case FileSystemItem.ItemCapability.HasLastWriteTime: return "HasLastWriteTime"; case FileSystemItem.ItemCapability.HasVolume: return "HasVolume"; case FileSystemItem.ItemCapability.QueryRemoveAssigned: return "QueryRemoveAssigned"; case FileSystemItem.ItemCapability.VolumeEventsAssigned: return "VolumeEventsAssigned"; case FileSystemItem.ItemCapability.HasLastAccessTime: return "HasLastAccessTime"; case FileSystemItem.ItemCapability.Unreadable: return "Unreadable"; case FileSystemItem.ItemCapability.GlobalFolderChangedAssigned: return "GlobalFolderChangedAssigned"; case FileSystemItem.ItemCapability.CheckNetworkShare: return "CheckNetworkShare"; case FileSystemItem.ItemCapability.DisableContentMap: return "DisableContentMap"; case FileSystemItem.ItemCapability.ItemRefreshNeeded: return "ItemRefreshNeeded"; case FileSystemItem.ItemCapability.HasShellItem: return "HasShellItem"; case FileSystemItem.ItemCapability.HasExtension: return "HasExtension"; case FileSystemItem.ItemCapability.IsElevated: return "IsElevated"; case FileSystemItem.ItemCapability.HasContentFolder: return "HasContentFolder"; } return XmlSerializationWriter.FromEnum((long) v, new string[] { "None", "HasParent", "HasExtender", "HasTarget", "HasSize", "HasThumbnail", "IsParentReal", "IsShellFolderShortcut", "HasShellFolderShortcut", "Deleted", "UseTargetIcon", "GlobalFileChangedAssigned", "IsShellLink", "IsUrlLink", "HasCreationTime", "HasLastWriteTime", "HasLastAccessTime", "Unreadable", "GlobalFolderChangedAssigned", "HasVolume", "QueryRemoveAssigned", "VolumeEventsAssigned", "CheckNetworkShare", "DisableContentMap", "ItemRefreshNeeded", "IsElevated", "HasContentFolder", "HasShellItem", "HasExtension" }, new long[] { 0L, 1L, 2L, 4L, 8L, 0x10L, 0x20L, 0x40L, 0x80L, 0x100L, 0x200L, 0x400L, 0x800L, 0x1000L, 0x2000L, 0x4000L, 0x8000L, 0x10000L, 0x20000L, 0x40000L, 0x80000L, 0x100000L, 0x200000L, 0x400000L, 0x800000L, 0x1000000L, 0x2000000L, 0x4000000L, 0x8000000L }, "Nomad.FileSystem.LocalFile.FileSystemItem.ItemCapability"); }
public CacheItem GetCacheEntry(FileSystemItem item, out CacheComplexKey cacheKey) { cacheKey = GetCacheKey(item); return(_cacheManager.Get(cacheKey)); }
private ImageSource getIcon(FileSystemItem item = null) { string header = "pack://application:,,,/Prime;component/Resources/"; string icon = "modern-files/file.png"; if (item == null) { icon = "empty.png"; } else if (item is Drive) { icon = "drive.png"; } else if (item is Directory || item is Jump) { //icon = "folder.png"; //icon = "folder-vi.png"; icon = "modern-files/folder.png"; } //icon = "dir32.png"; else { string ext = (item as File).Extension; switch (ext.ToLower()) { case "": icon = "empty.png"; break; case ".doc": case ".docx": case ".rtf": icon = "modern-files/doc.png"; break; /*case ".xls": * case ".xlsx": * icon = "excel.png"; * break; * case ".ppt": * case ".pptx": * icon = "slides.png"; * break;*/ case ".jar": case ".exe": case ".bat": case ".msi": case ".clickonce": case ".com": icon = "modern-files/exe.png"; break; case ".img": case ".bmp": case ".jpg": case ".jpeg": case ".png": case ".gif": case ".ico": icon = "modern-files/img.png"; break; case ".pdf": icon = "modern-files/doc.png"; break; /*case ".dll": * case ".lib": * case ".sys": * icon = "plugin.png"; * break; * case ".html": * case ".htm": * case ".url": * icon = "url.png"; * break;*/ case ".wma": case ".wav": case ".mp3": case ".ogg": icon = "modern-files/vid.png"; break; case ".zip": case ".rar": case ".gz": case ".tar": case ".7z": icon = "modern-files/zip.png"; break; case ".avi": case ".mkv": case ".mov": case ".wmv": case ".mp4": case ".mpeg": case ".mpg": case ".vob": icon = "modern-files/vid.png"; break; case ".php": case ".cs": case ".java": case ".js": case ".ini": case ".vb": case ".frm": case ".frx": case ".txt": case ".text": case ".py": case ".c": case ".h": case ".cpp": case ".vbs": case ".sql": case ".xml": case ".xhtml": case ".manifest": icon = "modern-files/code.png"; break; default: break; } } return(new BitmapImage(new Uri(header + icon, UriKind.Absolute))); }
public abstract FileSystemItem MoveTo(FileSystemItem item);
public async Task <ProjectModel> Post(ProjectModel model) { using (var db = new ScribsDbContext()) { var user = GetUser(db); int index = user.GetProjects().Count(); var project = new Project(user, model.Name, false); if (project.ExistsItem()) { throw new System.Exception("This project already exists"); } project.CreateItem(); project.Load(); project.Type = (Project.ProjectTypes)model.Type; project.Description = model.Description; project.Structure = model.Structure.Aggregate((a, b) => a + ";" + b); project.Index = 0; project.Key = Guid.NewGuid().ToString(); // Basic sheet templates var charTemplate = SheetTemplate.Factory.CreateInstance(db); charTemplate.User = user; charTemplate.ProjectKey = project.Key; charTemplate.Name = "Characters"; int i = 0; foreach (string label in new List <string> { "Name", "Description", "Personality", "Occupation", "Objective", "Habits", "Conflicts", "Relatives", "Notes" }) { var field = SheetTemplateField.Factory.CreateInstance(db); field.Index = i++; field.Label = label; field.SheetTemplate = charTemplate; charTemplate.SheetTemplateFields.Add(field); } var setTemplate = SheetTemplate.Factory.CreateInstance(db); setTemplate.User = user; setTemplate.ProjectKey = project.Key; setTemplate.Name = "Settings"; i = 0; foreach (string label in new List <string> { "Name", "Description", "Sights", "Sounds", "Smells", "Notes" }) { var field = SheetTemplateField.Factory.CreateInstance(db); field.Index = i++; field.Label = label; field.SheetTemplate = setTemplate; setTemplate.SheetTemplateFields.Add(field); } await db.SaveChangesAsync(); // Drafts var draftDirectory = FileSystemItem.Create(project, Directory.Type, ".Drafts", Guid.NewGuid().ToString(), 0) as Directory; FileSystemItem.Create(draftDirectory, File.Type, "Draft 1", Guid.NewGuid().ToString(), 0); // Structure generation var folders = model.Structure.Length > 1 ? model.Structure.Take(model.Structure.Length - 1) : new List <string> { "folder" }; var file = model.Structure.Length > 0 ? model.Structure.Last() : "file"; var directory = project as Directory; foreach (string folder in folders) { string directoryName = folder.Substring(0, 1).ToUpper() + folder.Substring(1, folder.Length - 1) + " 1"; directory = FileSystemItem.Create(directory, Directory.Type, directoryName, Guid.NewGuid().ToString(), 0) as Directory; } string fileName = file.Substring(0, 1).ToUpper() + file.Substring(1, file.Length - 1) + " 1"; FileSystemItem.Create(directory, File.Type, fileName, Guid.NewGuid().ToString(), 0); project.Save(); return(new ProjectModel { Name = model.Name, Discriminator = Discriminator.Directory, Key = project.Key }); } }
public FileSystemItem MoveTo(FileSystemItem newFileName) { LongPathDirectory.Move(Path, newFileName.Path); return(newFileName); }
private static FileSystemItem FindItem(List <FileSystemItem> items, string fullPath) { FileSystemItem item = items.FirstOrDefault(i => String.Equals(i.FullPath, fullPath, StringComparison.Ordinal)); return(item); }
protected bool IsDirectoryInfoEntry(FileSystemItem <DirectoryInfo> input, string name) { return(input._startingPoints.Any(p => new DirectoryInfo(p.EntryPoint).FullName.Equals(name, StringComparison.InvariantCultureIgnoreCase))); }
public void AddPicture(FileSystemItem aFile) { Console.WriteLine(Indent(aFile.Level) + aFile.Name); }
private void ProcessSuccess(OperationResult result) { FileSystemItem deselect = null; var queueItem = _queue.Peek(); switch (result.Result) { case TransferResult.Ok: if (queueItem.Operation == FileOperation.Copy) { _targetChanged = true; } if (queueItem.Operation == FileOperation.Copy && IsVerificationSupported && IsVerificationEnabled && queueItem.FileSystemItem.Type == ItemType.File) { queueItem.Operation = FileOperation.Verify; queueItem.Payload = result.TargetPath; } else if ((queueItem.Operation == FileOperation.Copy || queueItem.Operation == FileOperation.Verify) && UserAction == FileOperation.Move) { if (queueItem.FileSystemItem.Type == ItemType.Directory) { _queue.Dequeue(); _queue.Enqueue(new QueueItem(queueItem.FileSystemItem, FileOperation.Delete)); } else { queueItem.Operation = FileOperation.Delete; } } else { if (queueItem.Operation == FileOperation.Delete) { _sourceChanged = true; } if (UserAction != FileOperation.Delete) { _statistics.FilesTransferred++; } FilesTransferred++; deselect = queueItem.FileSystemItem; _queue.Dequeue(); } break; case TransferResult.Skipped: _queue.Dequeue(); break; case TransferResult.Aborted: if (queueItem.Operation == FileOperation.Copy) { _targetChanged = true; } if (IsPaused) { queueItem.CopyAction = CopyAction.Resume; } else { _queue.Dequeue(); } break; } _currentFileBytesTransferred = 0; if (deselect != null) { var vm = SourcePane.SelectedItems.FirstOrDefault(i => deselect.Path.StartsWith(i.Path)); if (vm != null && (vm.Type == ItemType.File || !_queue.Any(q => q.FileSystemItem.Path.StartsWith(vm.Path)))) { vm.IsSelected = false; } } if (IsPaused) { PauseMeters(); } else { ProcessQueueItem(); } }
public FileSystemItem MoveTo(FileSystemItem newFileName) { var currentLock = _lock; if (currentLock != null) throw new IOException("File is locked, please try again later."); CopyTo(newFileName); Delete(); return newFileName; }
public void CopyTo(FileSystemItem where) { VerifyExists(); var currentLock = _lock; if (currentLock != null && currentLock.Value != FileShare.Read && currentLock.Value != FileShare.ReadWrite) throw new IOException("Cannot copy file as someone opened it without shared read access"); if (where is InMemoryFile) { if (@where.Exists()) throw new IOException("File already exists"); ((InMemoryFile) where).CopyFromFile(this); } else if (where is InMemoryDirectory) ((InMemoryFile) ((InMemoryDirectory) where).GetFile(Name)).CopyFromFile(this); else throw new InvalidOperationException("The target type doesn't match the file system of the current file."); }
public virtual void CopyTo(FileSystemItem item) { var destinationPath = PrepareCopyTo(item); System.IO.File.Copy(Path.FullPath, destinationPath.FullPath, true); }
public virtual FileSystemItem MoveTo(FileSystemItem item) { System.IO.File.Move(Path.FullPath, item.Path.FullPath); return(item); }
public FileSystemItem MoveTo(FileSystemItem target) { return _backingFile.MoveTo(target); }