private async Task ExportSettings()
{
FileSavePicker filePicker = new FileSavePicker();
filePicker.FileTypeChoices.Add("Zip File", new[] { ".zip" });
filePicker.SuggestedFileName = $"Files_{App.AppVersion}";
StorageFile file = await filePicker.PickSaveFileAsync();
if (file != null)
{
try
{
var zipFolder = await ZipStorageFolder.FromStorageFileAsync(file);
if (zipFolder == null)
{
return;
}
var localFolderPath = ApplicationData.Current.LocalFolder.Path;
// Export user settings
var userSettings = await zipFolder.CreateFileAsync(Constants.LocalSettings.UserSettingsFileName, CreationCollisionOption.ReplaceExisting);
string exportSettings = (string)UserSettingsService.ExportSettings();
await userSettings.WriteTextAsync(exportSettings);
// Export bundles
var bundles = await zipFolder.CreateFileAsync(Constants.LocalSettings.BundlesSettingsFileName, CreationCollisionOption.ReplaceExisting);
string exportBundles = (string)BundlesSettingsService.ExportSettings();
await bundles.WriteTextAsync(exportBundles);
// Export pinned items
var pinnedItems = await BaseStorageFile.GetFileFromPathAsync(Path.Combine(localFolderPath, Constants.LocalSettings.SettingsFolderName, App.SidebarPinnedController.JsonFileName));
await pinnedItems.CopyAsync(zipFolder, pinnedItems.Name, NameCollisionOption.ReplaceExisting);
// Export terminals config
var terminals = await BaseStorageFile.GetFileFromPathAsync(Path.Combine(localFolderPath, Constants.LocalSettings.SettingsFolderName, App.TerminalController.JsonFileName));
await terminals.CopyAsync(zipFolder, terminals.Name, NameCollisionOption.ReplaceExisting);
// Export file tags list and DB
var fileTagsList = await zipFolder.CreateFileAsync(Constants.LocalSettings.FileTagSettingsFileName, CreationCollisionOption.ReplaceExisting);
string exportTags = (string)FileTagsSettingsService.ExportSettings();
await fileTagsList.WriteTextAsync(exportTags);
var fileTagsDB = await zipFolder.CreateFileAsync(Path.GetFileName(FileTagsHelper.FileTagsDbPath), CreationCollisionOption.ReplaceExisting);
string exportTagsDB = FileTagsHelper.DbInstance.Export();
await fileTagsDB.WriteTextAsync(exportTagsDB);
}
catch (Exception ex)
{
App.Logger.Warn(ex, "Error exporting settings");
}
}
}
public static IAsyncOperation <BaseStorageFolder> GetFolderFromPathAsync(string path)
{
return(AsyncInfo.Run(async(cancellationToken) =>
{
BaseStorageFolder folder = null;
folder ??= await ZipStorageFolder.FromPathAsync(path);
folder ??= await FtpStorageFolder.FromPathAsync(path);
folder ??= await SystemStorageFolder.FromPathAsync(path);
return folder;
}));
}
public virtual async Task DragOver(DragEventArgs e)
{
var deferral = e.GetDeferral();
if (associatedInstance.InstanceViewModel.IsPageTypeSearchResults)
{
e.AcceptedOperation = DataPackageOperation.None;
deferral.Complete();
return;
}
itemManipulationModel.ClearSelection();
if (Filesystem.FilesystemHelpers.HasDraggedStorageItems(e.DataView))
{
e.Handled = true;
var handledByFtp = await Filesystem.FilesystemHelpers.CheckDragNeedsFulltrust(e.DataView);
var draggedItems = await Filesystem.FilesystemHelpers.GetDraggedStorageItems(e.DataView);
var pwd = associatedInstance.FilesystemViewModel.WorkingDirectory.TrimPath();
var folderName = (Path.IsPathRooted(pwd) && Path.GetPathRoot(pwd) == pwd) ? Path.GetPathRoot(pwd) : Path.GetFileName(pwd);
// As long as one file doesn't already belong to this folder
if (associatedInstance.InstanceViewModel.IsPageTypeSearchResults || (draggedItems.Any() && draggedItems.AreItemsAlreadyInFolder(associatedInstance.FilesystemViewModel.WorkingDirectory)))
{
e.AcceptedOperation = DataPackageOperation.None;
}
else if (handledByFtp)
{
if (pwd.StartsWith(CommonPaths.RecycleBinPath, StringComparison.Ordinal))
{
e.AcceptedOperation = DataPackageOperation.None;
}
else
{
e.DragUIOverride.IsCaptionVisible = true;
e.DragUIOverride.Caption = string.Format("CopyToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Copy;
}
}
else if (!draggedItems.Any())
{
e.AcceptedOperation = DataPackageOperation.None;
}
else
{
e.DragUIOverride.IsCaptionVisible = true;
if (pwd.StartsWith(CommonPaths.RecycleBinPath, StringComparison.Ordinal))
{
e.DragUIOverride.Caption = string.Format("MoveToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Move;
}
else if (e.Modifiers.HasFlag(DragDropModifiers.Alt) || e.Modifiers.HasFlag(DragDropModifiers.Control | DragDropModifiers.Shift))
{
e.DragUIOverride.Caption = string.Format("LinkToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Link;
}
else if (e.Modifiers.HasFlag(DragDropModifiers.Control))
{
e.DragUIOverride.Caption = string.Format("CopyToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Copy;
}
else if (e.Modifiers.HasFlag(DragDropModifiers.Shift))
{
e.DragUIOverride.Caption = string.Format("MoveToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Move;
}
else if (draggedItems.Any(x => x.Item is ZipStorageFile || x.Item is ZipStorageFolder) ||
ZipStorageFolder.IsZipPath(pwd))
{
e.DragUIOverride.Caption = string.Format("CopyToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Copy;
}
else if (draggedItems.AreItemsInSameDrive(associatedInstance.FilesystemViewModel.WorkingDirectory))
{
e.DragUIOverride.Caption = string.Format("MoveToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Move;
}
else
{
e.DragUIOverride.Caption = string.Format("CopyToFolderCaptionText".GetLocalized(), folderName);
e.AcceptedOperation = DataPackageOperation.Copy;
}
}
}
deferral.Complete();
}
private async Task ImportSettings()
{
FileOpenPicker filePicker = new FileOpenPicker();
filePicker.FileTypeFilter.Add(".zip");
StorageFile file = await filePicker.PickSingleFileAsync();
if (file != null)
{
try
{
var zipFolder = await ZipStorageFolder.FromStorageFileAsync(file);
if (zipFolder == null)
{
return;
}
var localFolderPath = ApplicationData.Current.LocalFolder.Path;
var settingsFolder = await StorageFolder.GetFolderFromPathAsync(Path.Combine(localFolderPath, Constants.LocalSettings.SettingsFolderName));
// Import user settings
var userSettingsFile = await zipFolder.GetFileAsync(Constants.LocalSettings.UserSettingsFileName);
string importSettings = await userSettingsFile.ReadTextAsync();
UserSettingsService.ImportSettings(importSettings);
// Import bundles
var bundles = await zipFolder.GetFileAsync(Constants.LocalSettings.BundlesSettingsFileName);
string importBundles = await bundles.ReadTextAsync();
BundlesSettingsService.ImportSettings(importBundles);
// Import pinned items
var pinnedItems = await zipFolder.GetFileAsync(App.SidebarPinnedController.JsonFileName);
await pinnedItems.CopyAsync(settingsFolder, pinnedItems.Name, NameCollisionOption.ReplaceExisting);
await App.SidebarPinnedController.ReloadAsync();
// Import terminals config
var terminals = await zipFolder.GetFileAsync(App.TerminalController.JsonFileName);
await terminals.CopyAsync(settingsFolder, terminals.Name, NameCollisionOption.ReplaceExisting);
// Import file tags list and DB
var fileTagsList = await zipFolder.GetFileAsync(Constants.LocalSettings.FileTagSettingsFileName);
string importTags = await fileTagsList.ReadTextAsync();
FileTagsSettingsService.ImportSettings(importTags);
var fileTagsDB = await zipFolder.GetFileAsync(Path.GetFileName(FileTagsHelper.FileTagsDbPath));
string importTagsDB = await fileTagsDB.ReadTextAsync();
FileTagsHelper.DbInstance.Import(importTagsDB);
// Import layout preferences and DB
var layoutPrefsDB = await zipFolder.GetFileAsync(Path.GetFileName(FolderSettingsViewModel.LayoutSettingsDbPath));
string importPrefsDB = await layoutPrefsDB.ReadTextAsync();
FolderSettingsViewModel.DbInstance.Import(importPrefsDB);
}
catch (Exception ex)
{
App.Logger.Warn(ex, "Error importing settings");
UIHelpers.CloseAllDialogs();
await DialogDisplayHelper.ShowDialogAsync("SettingsImportErrorTitle".GetLocalized(), "SettingsImportErrorDescription".GetLocalized());
}
}
}
public static async Task <ListedItem> GetFile(
WIN32_FIND_DATA findData,
string pathRoot,
string dateReturnFormat,
NamedPipeAsAppServiceConnection connection,
CancellationToken cancellationToken
)
{
var itemPath = Path.Combine(pathRoot, findData.cFileName);
var itemName = findData.cFileName;
DateTime itemModifiedDate, itemCreatedDate, itemLastAccessDate;
try
{
FileTimeToSystemTime(ref findData.ftLastWriteTime, out SYSTEMTIME systemModifiedDateOutput);
itemModifiedDate = systemModifiedDateOutput.ToDateTime();
FileTimeToSystemTime(ref findData.ftCreationTime, out SYSTEMTIME systemCreatedDateOutput);
itemCreatedDate = systemCreatedDateOutput.ToDateTime();
FileTimeToSystemTime(ref findData.ftLastAccessTime, out SYSTEMTIME systemLastAccessOutput);
itemLastAccessDate = systemLastAccessOutput.ToDateTime();
}
catch (ArgumentException)
{
// Invalid date means invalid findData, do not add to list
return(null);
}
long itemSizeBytes = findData.GetSize();
var itemSize = itemSizeBytes.ToSizeString();
string itemType = "ItemTypeFile".GetLocalized();
string itemFileExtension = null;
if (findData.cFileName.Contains('.'))
{
itemFileExtension = Path.GetExtension(itemPath);
itemType = itemFileExtension.Trim('.') + " " + itemType;
}
bool itemThumbnailImgVis = false;
bool itemEmptyImgVis = true;
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
bool isHidden = ((FileAttributes)findData.dwFileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden;
double opacity = isHidden ? Constants.UI.DimItemOpacity : 1;
// https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/c8e77b37-3909-4fe6-a4ea-2b9d423b1ee4
bool isReparsePoint = ((FileAttributes)findData.dwFileAttributes & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint;
bool isSymlink = isReparsePoint && findData.dwReserved0 == NativeFileOperationsHelper.IO_REPARSE_TAG_SYMLINK;
if (isSymlink)
{
var targetPath = NativeFileOperationsHelper.ParseSymLink(itemPath);
return(new ShortcutItem(null, dateReturnFormat)
{
PrimaryItemAttribute = StorageItemTypes.File,
FileExtension = itemFileExtension,
IsHiddenItem = isHidden,
Opacity = opacity,
FileImage = null,
LoadFileIcon = itemThumbnailImgVis,
LoadWebShortcutGlyph = false,
ItemNameRaw = itemName,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = "ShortcutFileType".GetLocalized(),
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes,
TargetPath = targetPath,
IsSymLink = true
});
}
else if (findData.cFileName.EndsWith(".lnk", StringComparison.Ordinal) || findData.cFileName.EndsWith(".url", StringComparison.Ordinal))
{
if (connection != null)
{
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "ParseLink" },
{ "filepath", itemPath }
});
// If the request was canceled return now
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
if (status == AppServiceResponseStatus.Success && response.ContainsKey("ShortcutInfo"))
{
var isUrl = findData.cFileName.EndsWith(".url", StringComparison.OrdinalIgnoreCase);
var shInfo = JsonConvert.DeserializeObject <ShellLinkItem>((string)response["ShortcutInfo"]);
if (shInfo == null)
{
return(null);
}
return(new ShortcutItem(null, dateReturnFormat)
{
PrimaryItemAttribute = shInfo.IsFolder ? StorageItemTypes.Folder : StorageItemTypes.File,
FileExtension = itemFileExtension,
IsHiddenItem = isHidden,
Opacity = opacity,
FileImage = null,
LoadFileIcon = !shInfo.IsFolder && itemThumbnailImgVis,
LoadWebShortcutGlyph = !shInfo.IsFolder && isUrl && itemEmptyImgVis,
ItemNameRaw = itemName,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = isUrl ? "ShortcutWebLinkFileType".GetLocalized() : "ShortcutFileType".GetLocalized(),
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes,
TargetPath = shInfo.TargetPath,
Arguments = shInfo.Arguments,
WorkingDirectory = shInfo.WorkingDirectory,
RunAsAdmin = shInfo.RunAsAdmin,
IsUrl = isUrl,
});
}
}
}
else if (App.LibraryManager.TryGetLibrary(itemPath, out LibraryLocationItem library))
{
return(new LibraryItem(library)
{
ItemDateModifiedReal = itemModifiedDate,
ItemDateCreatedReal = itemCreatedDate,
});
}
else
{
if (".zip".Equals(itemFileExtension, StringComparison.OrdinalIgnoreCase) && await ZipStorageFolder.CheckDefaultZipApp(itemPath))
{
return(new ZipItem(null, dateReturnFormat)
{
PrimaryItemAttribute = StorageItemTypes.Folder, // Treat zip files as folders
FileExtension = itemFileExtension,
FileImage = null,
LoadFileIcon = itemThumbnailImgVis,
ItemNameRaw = itemName,
IsHiddenItem = isHidden,
Opacity = opacity,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = itemType,
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes
});
}
else
{
return(new ListedItem(null, dateReturnFormat)
{
PrimaryItemAttribute = StorageItemTypes.File,
FileExtension = itemFileExtension,
FileImage = null,
LoadFileIcon = itemThumbnailImgVis,
ItemNameRaw = itemName,
IsHiddenItem = isHidden,
Opacity = opacity,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = itemType,
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes
});
}
}
return(null);
}
public static async Task ExtractArchive(BaseStorageFile archive, BaseStorageFolder destinationFolder, IProgress <float> progressDelegate, CancellationToken cancellationToken)
{
ZipFile zipFile = await Filesystem.FilesystemTasks.Wrap(async() => new ZipFile(await archive.OpenStreamForReadAsync()));
if (zipFile == null)
{
return;
}
using (zipFile)
{
zipFile.IsStreamOwner = true;
List <ZipEntry> directoryEntries = new List <ZipEntry>();
List <ZipEntry> fileEntries = new List <ZipEntry>();
foreach (ZipEntry entry in zipFile)
{
if (entry.IsFile)
{
fileEntries.Add(entry);
}
else
{
directoryEntries.Add(entry);
}
}
if (cancellationToken.IsCancellationRequested) // Check if cancelled
{
return;
}
var wnt = new WindowsNameTransform(destinationFolder.Path);
var zipEncoding = ZipStorageFolder.DetectFileEncoding(zipFile);
var directories = new List <string>();
try
{
directories.AddRange(directoryEntries.Select((entry) => wnt.TransformDirectory(ZipStorageFolder.DecodeEntryName(entry, zipEncoding))));
directories.AddRange(fileEntries.Select((entry) => Path.GetDirectoryName(wnt.TransformFile(ZipStorageFolder.DecodeEntryName(entry, zipEncoding)))));
}
catch (InvalidNameException ex)
{
App.Logger.Warn(ex, $"Error transforming zip names into: {destinationFolder.Path}\n" +
$"Directories: {string.Join(", ", directoryEntries.Select(x => x.Name))}\n" +
$"Files: {string.Join(", ", fileEntries.Select(x => x.Name))}");
return;
}
foreach (var dir in directories.Distinct().OrderBy(x => x.Length))
{
if (!NativeFileOperationsHelper.CreateDirectoryFromApp(dir, IntPtr.Zero))
{
var dirName = destinationFolder.Path;
foreach (var component in dir.Substring(destinationFolder.Path.Length).Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries))
{
dirName = Path.Combine(dirName, component);
NativeFileOperationsHelper.CreateDirectoryFromApp(dirName, IntPtr.Zero);
}
}
if (cancellationToken.IsCancellationRequested) // Check if canceled
{
return;
}
}
if (cancellationToken.IsCancellationRequested) // Check if canceled
{
return;
}
// Fill files
byte[] buffer = new byte[4096];
int entriesAmount = fileEntries.Count;
int entriesFinished = 0;
foreach (var entry in fileEntries)
{
if (cancellationToken.IsCancellationRequested) // Check if canceled
{
return;
}
if (entry.IsCrypted)
{
App.Logger.Info($"Skipped encrypted zip entry: {entry.Name}");
continue; // TODO: support password protected archives
}
string filePath = wnt.TransformFile(ZipStorageFolder.DecodeEntryName(entry, zipEncoding));
var hFile = NativeFileOperationsHelper.CreateFileForWrite(filePath);
if (hFile.IsInvalid)
{
return; // TODO: handle error
}
// We don't close hFile because FileStream.Dispose() already does that
using (FileStream destinationStream = new FileStream(hFile, FileAccess.Write))
{
int currentBlockSize = 0;
using (Stream entryStream = zipFile.GetInputStream(entry))
{
while ((currentBlockSize = await entryStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
await destinationStream.WriteAsync(buffer, 0, currentBlockSize);
if (cancellationToken.IsCancellationRequested) // Check if cancelled
{
return;
}
}
}
}
entriesFinished++;
float percentage = (float)((float)entriesFinished / (float)entriesAmount) * 100.0f;
progressDelegate?.Report(percentage);
}
}
}
public static async Task <ListedItem> GetFile(
WIN32_FIND_DATA findData,
string pathRoot,
string dateReturnFormat,
NamedPipeAsAppServiceConnection connection,
CancellationToken cancellationToken
)
{
IUserSettingsService userSettingsService = Ioc.Default.GetService <IUserSettingsService>();
var itemPath = Path.Combine(pathRoot, findData.cFileName);
string itemName;
if (userSettingsService.PreferencesSettingsService.ShowFileExtensions && !findData.cFileName.EndsWith(".lnk") && !findData.cFileName.EndsWith(".url"))
{
itemName = findData.cFileName; // never show extension for shortcuts
}
else
{
if (findData.cFileName.StartsWith("."))
{
itemName = findData.cFileName; // Always show full name for dotfiles.
}
else
{
itemName = Path.GetFileNameWithoutExtension(itemPath);
}
}
DateTime itemModifiedDate, itemCreatedDate, itemLastAccessDate;
try
{
FileTimeToSystemTime(ref findData.ftLastWriteTime, out SYSTEMTIME systemModifiedDateOutput);
itemModifiedDate = new DateTime(
systemModifiedDateOutput.Year, systemModifiedDateOutput.Month, systemModifiedDateOutput.Day,
systemModifiedDateOutput.Hour, systemModifiedDateOutput.Minute, systemModifiedDateOutput.Second, systemModifiedDateOutput.Milliseconds,
DateTimeKind.Utc);
FileTimeToSystemTime(ref findData.ftCreationTime, out SYSTEMTIME systemCreatedDateOutput);
itemCreatedDate = new DateTime(
systemCreatedDateOutput.Year, systemCreatedDateOutput.Month, systemCreatedDateOutput.Day,
systemCreatedDateOutput.Hour, systemCreatedDateOutput.Minute, systemCreatedDateOutput.Second, systemCreatedDateOutput.Milliseconds,
DateTimeKind.Utc);
FileTimeToSystemTime(ref findData.ftLastAccessTime, out SYSTEMTIME systemLastAccessOutput);
itemLastAccessDate = new DateTime(
systemLastAccessOutput.Year, systemLastAccessOutput.Month, systemLastAccessOutput.Day,
systemLastAccessOutput.Hour, systemLastAccessOutput.Minute, systemLastAccessOutput.Second, systemLastAccessOutput.Milliseconds,
DateTimeKind.Utc);
}
catch (ArgumentException)
{
// Invalid date means invalid findData, do not add to list
return(null);
}
long itemSizeBytes = findData.GetSize();
var itemSize = ByteSize.FromBytes(itemSizeBytes).ToBinaryString().ConvertSizeAbbreviation();
string itemType = "ItemTypeFile".GetLocalized();
string itemFileExtension = null;
if (findData.cFileName.Contains('.'))
{
itemFileExtension = Path.GetExtension(itemPath);
itemType = itemFileExtension.Trim('.') + " " + itemType;
}
bool itemThumbnailImgVis = false;
bool itemEmptyImgVis = true;
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
if (findData.cFileName.EndsWith(".lnk") || findData.cFileName.EndsWith(".url"))
{
if (connection != null)
{
var(status, response) = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "ParseLink" },
{ "filepath", itemPath }
});
// If the request was canceled return now
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
if (status == AppServiceResponseStatus.Success &&
response.ContainsKey("TargetPath"))
{
var isUrl = findData.cFileName.EndsWith(".url");
string target = (string)response["TargetPath"];
bool isHidden = (((FileAttributes)findData.dwFileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden);
double opacity = 1;
if (isHidden)
{
opacity = Constants.UI.DimItemOpacity;
}
return(new ShortcutItem(null, dateReturnFormat)
{
PrimaryItemAttribute = (bool)response["IsFolder"] ? StorageItemTypes.Folder : StorageItemTypes.File,
FileExtension = itemFileExtension,
IsHiddenItem = isHidden,
Opacity = opacity,
FileImage = null,
LoadFileIcon = !(bool)response["IsFolder"] && itemThumbnailImgVis,
LoadWebShortcutGlyph = !(bool)response["IsFolder"] && isUrl && itemEmptyImgVis,
ItemName = itemName,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = isUrl ? "ShortcutWebLinkFileType".GetLocalized() : "ShortcutFileType".GetLocalized(),
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes,
TargetPath = target,
Arguments = (string)response["Arguments"],
WorkingDirectory = (string)response["WorkingDirectory"],
RunAsAdmin = (bool)response["RunAsAdmin"],
IsUrl = isUrl,
});
}
}
}
else if (App.LibraryManager.TryGetLibrary(itemPath, out LibraryLocationItem library))
{
return(new LibraryItem(library)
{
ItemDateModifiedReal = itemModifiedDate,
ItemDateCreatedReal = itemCreatedDate,
});
}
else
{
bool isHidden = (((FileAttributes)findData.dwFileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden);
double opacity = 1;
if (isHidden)
{
opacity = Constants.UI.DimItemOpacity;
}
if (".zip".Equals(itemFileExtension, StringComparison.OrdinalIgnoreCase) && await ZipStorageFolder.CheckDefaultZipApp(itemPath))
{
return(new ZipItem(null, dateReturnFormat)
{
PrimaryItemAttribute = StorageItemTypes.Folder, // Treat zip files as folders
FileExtension = itemFileExtension,
FileImage = null,
LoadFileIcon = itemThumbnailImgVis,
ItemName = itemName,
IsHiddenItem = isHidden,
Opacity = opacity,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = itemType,
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes
});
}
else
{
return(new ListedItem(null, dateReturnFormat)
{
PrimaryItemAttribute = StorageItemTypes.File,
FileExtension = itemFileExtension,
FileImage = null,
LoadFileIcon = itemThumbnailImgVis,
ItemName = itemName,
IsHiddenItem = isHidden,
Opacity = opacity,
ItemDateModifiedReal = itemModifiedDate,
ItemDateAccessedReal = itemLastAccessDate,
ItemDateCreatedReal = itemCreatedDate,
ItemType = itemType,
ItemPath = itemPath,
FileSize = itemSize,
FileSizeBytes = itemSizeBytes
});
}
}
return(null);
}