public abstract void SetSelectedItemOnUi(ListedItem selectedItem);
private async void Properties_Loaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
// Collect AppWindow-specific info
propWindow = Interaction.AppWindows[this.UIContext];
if (App.CurrentInstance.ContentPage.IsItemSelected)
{
var selectedItem = App.CurrentInstance.ContentPage.SelectedItem;
IStorageItem selectedStorageItem = null;
if (selectedItem.PrimaryItemAttribute == StorageItemTypes.File)
{
selectedStorageItem = await StorageFile.GetFileFromPathAsync(selectedItem.ItemPath);
var hashAlgTypeName = HashAlgorithmNames.Md5;
// get file hash
ItemProperties.ItemMD5Hash = await App.CurrentInstance.InteractionOperations.GetHashForFile(selectedItem, hashAlgTypeName);
ItemProperties.ItemMD5HashVisibility = Visibility.Visible;
}
else if (selectedItem.PrimaryItemAttribute == StorageItemTypes.Folder)
{
selectedStorageItem = await StorageFolder.GetFolderFromPathAsync(selectedItem.ItemPath);
ItemProperties.ItemMD5HashVisibility = Visibility.Collapsed;
}
ItemProperties.ItemName = selectedItem.ItemName;
ItemProperties.ItemType = selectedItem.ItemType;
ItemProperties.ItemPath = selectedItem.ItemPath;
ItemProperties.ItemSize = selectedItem.FileSize;
ItemProperties.LoadFileIcon = selectedItem.LoadFileIcon;
ItemProperties.LoadFolderGlyph = selectedItem.LoadFolderGlyph;
ItemProperties.LoadUnknownTypeGlyph = selectedItem.LoadUnknownTypeGlyph;
ItemProperties.ItemModifiedTimestamp = selectedItem.ItemDateModified;
ItemProperties.ItemCreatedTimestamp = ListedItem.GetFriendlyDate(selectedStorageItem.DateCreated);
if (!App.CurrentInstance.ContentPage.SelectedItem.LoadFolderGlyph)
{
var thumbnail = await(await StorageFile.GetFileFromPathAsync(App.CurrentInstance.ContentPage.SelectedItem.ItemPath)).GetThumbnailAsync(Windows.Storage.FileProperties.ThumbnailMode.SingleItem, 80, Windows.Storage.FileProperties.ThumbnailOptions.ResizeThumbnail);
var bitmap = new BitmapImage();
await bitmap.SetSourceAsync(thumbnail);
ItemProperties.FileIconSource = bitmap;
}
}
else
{
var parentDirectory = App.CurrentInstance.ViewModel.CurrentFolder;
var parentDirectoryStorageItem = await StorageFolder.GetFolderFromPathAsync(parentDirectory.ItemPath);
ItemProperties.ItemName = parentDirectory.ItemName;
ItemProperties.ItemType = parentDirectory.ItemType;
ItemProperties.ItemPath = parentDirectory.ItemPath;
ItemProperties.ItemSize = parentDirectory.FileSize;
ItemProperties.LoadFileIcon = false;
ItemProperties.LoadFolderGlyph = true;
ItemProperties.LoadUnknownTypeGlyph = false;
ItemProperties.ItemModifiedTimestamp = parentDirectory.ItemDateModified;
ItemProperties.ItemCreatedTimestamp = ListedItem.GetFriendlyDate(parentDirectoryStorageItem.DateCreated);
}
}
public override void SetItemOpacity(ListedItem item)
{
item.IsDimmed = true;
}
protected async void Item_DragOver(object sender, DragEventArgs e)
{
var deferral = e.GetDeferral();
ListedItem item = GetItemFromElement(sender);
if (item is null && sender is GridViewItem gvi)
{
item = gvi.Content as ListedItem;
}
SetSelectedItemOnUi(item);
if (dragOverItem != item)
{
dragOverItem = item;
dragOverTimer.Stop();
dragOverTimer.Debounce(() =>
{
if (dragOverItem != null && !InstanceViewModel.IsPageTypeSearchResults)
{
dragOverItem = null;
dragOverTimer.Stop();
ParentShellPageInstance.InteractionOperations.OpenItem_Click(null, null);
}
}, TimeSpan.FromMilliseconds(1000), false);
}
if (e.DataView.Contains(StandardDataFormats.StorageItems))
{
IReadOnlyList <IStorageItem> draggedItems;
try
{
draggedItems = await e.DataView.GetStorageItemsAsync();
}
catch (Exception ex) when((uint)ex.HResult == 0x80040064)
{
e.AcceptedOperation = DataPackageOperation.None;
deferral.Complete();
return;
}
e.Handled = true;
e.DragUIOverride.IsCaptionVisible = true;
if (InstanceViewModel.IsPageTypeSearchResults || draggedItems.AreItemsAlreadyInFolder(item.ItemPath) || draggedItems.Any(draggedItem => draggedItem.Path == item.ItemPath))
{
e.AcceptedOperation = DataPackageOperation.None;
}
// Items from the same drive as this folder are dragged into this folder, so we move the items instead of copy
else if (draggedItems.AreItemsInSameDrive(item.ItemPath))
{
e.DragUIOverride.Caption = string.Format("MoveToFolderCaptionText".GetLocalized(), item.ItemName);
e.AcceptedOperation = DataPackageOperation.Move;
}
else
{
e.DragUIOverride.Caption = string.Format("CopyToFolderCaptionText".GetLocalized(), item.ItemName);
e.AcceptedOperation = DataPackageOperation.Copy;
}
}
deferral.Complete();
}
private void ItemManipulationModel_RemoveSelectedItemInvoked(object sender, ListedItem e)
{
FileList?.SelectedItems.Remove(e);
}
public abstract void ScrollIntoView(ListedItem item);
public virtual void SetSelectedItemOnUi(ListedItem selectedItem)
{
ClearSelection();
AddSelectedItem(selectedItem);
}
public async Task <bool> RenameFileItem(ListedItem item, string oldName, string newName)
{
if (oldName == newName)
{
return(true);
}
if (!string.IsNullOrWhiteSpace(newName))
{
try
{
if (item.PrimaryItemAttribute == StorageItemTypes.Folder)
{
var folder = await StorageFolder.GetFolderFromPathAsync(item.ItemPath);
await folder.RenameAsync(newName, NameCollisionOption.FailIfExists);
}
else
{
var file = await StorageFile.GetFileFromPathAsync(item.ItemPath);
await file.RenameAsync(newName, NameCollisionOption.FailIfExists);
}
}
catch (Exception)
{
var ItemAlreadyExistsDialog = new ContentDialog()
{
Title = ResourceController.GetTranslation("ItemAlreadyExistsDialogTitle"),
Content = ResourceController.GetTranslation("ItemAlreadyExistsDialogContent"),
PrimaryButtonText = ResourceController.GetTranslation("ItemAlreadyExistsDialogPrimaryButtonText"),
SecondaryButtonText = ResourceController.GetTranslation("ItemAlreadyExistsDialogSecondaryButtonText")
};
ContentDialogResult result = await ItemAlreadyExistsDialog.ShowAsync();
if (result == ContentDialogResult.Primary)
{
if (item.PrimaryItemAttribute == StorageItemTypes.Folder)
{
var folder = await StorageFolder.GetFolderFromPathAsync(item.ItemPath);
await folder.RenameAsync(newName, NameCollisionOption.GenerateUniqueName);
}
else
{
var file = await StorageFile.GetFileFromPathAsync(item.ItemPath);
await file.RenameAsync(newName, NameCollisionOption.GenerateUniqueName);
}
}
else if (result == ContentDialogResult.Secondary)
{
if (item.PrimaryItemAttribute == StorageItemTypes.Folder)
{
var folder = await StorageFolder.GetFolderFromPathAsync(item.ItemPath);
await folder.RenameAsync(newName, NameCollisionOption.ReplaceExisting);
}
else
{
var file = await StorageFile.GetFileFromPathAsync(item.ItemPath);
await file.RenameAsync(newName, NameCollisionOption.ReplaceExisting);
}
}
}
}
CurrentInstance.NavigationToolbar.CanGoForward = false;
return(true);
}
public async Task PasteItems(DataPackageView packageView, string destinationPath, DataPackageOperation acceptedOperation)
{
itemsToPaste = await packageView.GetStorageItemsAsync();
HashSet <IStorageItem> pastedItems = new HashSet <IStorageItem>();
itemsPasted = 0;
if (itemsToPaste.Count > 3)
{
(App.CurrentInstance as ModernShellPage).UpdateProgressFlyout(InteractionOperationType.PasteItems, itemsPasted, itemsToPaste.Count);
}
foreach (IStorageItem item in itemsToPaste)
{
if (item.IsOfType(StorageItemTypes.Folder))
{
if (destinationPath.IsSubPathOf(item.Path))
{
ImpossibleActionResponseTypes responseType = ImpossibleActionResponseTypes.Abort;
Binding themeBind = new Binding();
themeBind.Source = ThemeHelper.RootTheme;
ContentDialog dialog = new ContentDialog()
{
Title = ResourceController.GetTranslation("ErrorDialogThisActionCannotBeDone"),
Content = ResourceController.GetTranslation("ErrorDialogTheDestinationFolder") + " (" + destinationPath.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries).Last() + ") " + ResourceController.GetTranslation("ErrorDialogIsASubfolder") + " (" + item.Name + ")",
PrimaryButtonText = ResourceController.GetTranslation("ErrorDialogSkip"),
CloseButtonText = ResourceController.GetTranslation("ErrorDialogCancel"),
PrimaryButtonCommand = new RelayCommand(() => { responseType = ImpossibleActionResponseTypes.Skip; }),
CloseButtonCommand = new RelayCommand(() => { responseType = ImpossibleActionResponseTypes.Abort; })
};
BindingOperations.SetBinding(dialog, FrameworkElement.RequestedThemeProperty, themeBind);
await dialog.ShowAsync();
if (responseType == ImpossibleActionResponseTypes.Skip)
{
continue;
}
else if (responseType == ImpossibleActionResponseTypes.Abort)
{
return;
}
}
else
{
StorageFolder pastedFolder = await CloneDirectoryAsync(item.Path, destinationPath, item.Name, false);
pastedItems.Add(pastedFolder);
if (destinationPath == CurrentInstance.ViewModel.WorkingDirectory)
{
CurrentInstance.ViewModel.AddFolder(pastedFolder.Path);
}
}
}
else if (item.IsOfType(StorageItemTypes.File))
{
if (itemsToPaste.Count > 3)
{
(App.CurrentInstance as ModernShellPage).UpdateProgressFlyout(InteractionOperationType.PasteItems, ++itemsPasted, itemsToPaste.Count);
}
StorageFile clipboardFile = await StorageFile.GetFileFromPathAsync(item.Path);
StorageFile pastedFile = await clipboardFile.CopyAsync(await StorageFolder.GetFolderFromPathAsync(destinationPath), item.Name, NameCollisionOption.GenerateUniqueName);
pastedItems.Add(pastedFile);
if (destinationPath == CurrentInstance.ViewModel.WorkingDirectory)
{
CurrentInstance.ViewModel.AddFile(pastedFile.Path);
}
}
}
if (acceptedOperation == DataPackageOperation.Move)
{
foreach (IStorageItem item in itemsToPaste)
{
if (item.IsOfType(StorageItemTypes.File))
{
StorageFile file = await StorageFile.GetFileFromPathAsync(item.Path);
await file.DeleteAsync();
}
else if (item.IsOfType(StorageItemTypes.Folder))
{
StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(item.Path);
await folder.DeleteAsync();
}
ListedItem listedItem = CurrentInstance.ViewModel.FilesAndFolders.FirstOrDefault(listedItem => listedItem.ItemPath.Equals(item.Path, StringComparison.OrdinalIgnoreCase));
if (listedItem != null)
{
CurrentInstance.ViewModel.RemoveFileOrFolder(listedItem);
}
}
}
if (destinationPath == CurrentInstance.ViewModel.WorkingDirectory)
{
List <string> pastedItemPaths = pastedItems.Select(item => item.Path).ToList();
List <ListedItem> copiedItems = CurrentInstance.ViewModel.FilesAndFolders.Where(listedItem => pastedItemPaths.Contains(listedItem.ItemPath)).ToList();
CurrentInstance.ContentPage.SetSelectedItemsOnUi(copiedItems);
CurrentInstance.ContentPage.FocusSelectedItems();
}
packageView.ReportOperationCompleted(acceptedOperation);
}
private void ItemManipulationModel_ScrollIntoViewInvoked(object sender, ListedItem e)
{
FileList.ScrollIntoView(e);
}
public ShortcutPreviewViewModel(ListedItem item) : base(item)
{
}
public override void ScrollIntoView(ListedItem item)
{
AllView.ScrollIntoView(item, null);
}
public ImagePreviewViewModel(ListedItem item) : base(item)
{
}
public abstract void SetItemOpacity(ListedItem item);
public FolderProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, ListedItem item, IShellPage instance)
{
ViewModel = viewModel;
TokenSource = tokenSource;
Dispatcher = coreDispatcher;
Item = item;
AppInstance = instance;
GetBaseProperties();
ViewModel.PropertyChanged += ViewModel_PropertyChanged;
}
public override void SetItemOpacity(ListedItem item)
{
item.Opacity = 0.4;
}
public async override void GetSpecialProperties()
{
ViewModel.IsHidden = NativeFileOperationsHelper.HasFileAttribute(
Item.ItemPath, System.IO.FileAttributes.Hidden);
var fileIconInfo = await AppInstance.FilesystemViewModel.LoadIconOverlayAsync(Item.ItemPath, 80);
if (fileIconInfo.Icon != null && fileIconInfo.IsCustom)
{
ViewModel.FileIconSource = fileIconInfo.Icon;
}
if (Item.IsShortcutItem)
{
ViewModel.ItemSizeVisibility = Visibility.Visible;
ViewModel.ItemSize = $"{ByteSize.FromBytes(Item.FileSizeBytes).ToBinaryString().ConvertSizeAbbreviation()} ({ByteSize.FromBytes(Item.FileSizeBytes).Bytes:#,##0} {"ItemSizeBytes".GetLocalized()})";
ViewModel.ItemCreatedTimestamp = Item.ItemDateCreated;
ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
if (Item.IsLinkItem || string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))
{
// Can't show any other property
return;
}
}
StorageFolder storageFolder;
try
{
storageFolder = await AppInstance.FilesystemViewModel.GetFolderFromPathAsync((Item as ShortcutItem)?.TargetPath ?? Item.ItemPath);
}
catch (Exception ex)
{
NLog.LogManager.GetCurrentClassLogger().Error(ex, ex.Message);
// Could not access folder, can't show any other property
return;
}
if (storageFolder != null)
{
ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
string returnformat = Enum.Parse <TimeStyle>(localSettings.Values[Constants.LocalSettings.DateTimeFormat].ToString()) == TimeStyle.Application ? "D" : "g";
ViewModel.ItemCreatedTimestamp = ListedItem.GetFriendlyDateFromFormat(storageFolder.DateCreated, returnformat);
GetOtherProperties(storageFolder.Properties);
GetFolderSize(storageFolder, TokenSource.Token);
}
else if (Item.ItemPath.Equals(App.AppSettings.RecycleBinPath, StringComparison.OrdinalIgnoreCase))
{
// GetFolderFromPathAsync cannot access recyclebin folder
if (AppInstance.FilesystemViewModel.Connection != null)
{
var value = new ValueSet();
value.Add("Arguments", "RecycleBin");
value.Add("action", "Query");
// Send request to fulltrust process to get recyclebin properties
var response = await AppInstance.FilesystemViewModel.Connection.SendMessageAsync(value);
if (response.Status == Windows.ApplicationModel.AppService.AppServiceResponseStatus.Success)
{
if (response.Message.TryGetValue("BinSize", out var binSize))
{
ViewModel.ItemSizeBytes = (long)binSize;
ViewModel.ItemSize = ByteSize.FromBytes((long)binSize).ToString();
ViewModel.ItemSizeVisibility = Visibility.Visible;
}
else
{
ViewModel.ItemSizeVisibility = Visibility.Collapsed;
}
if (response.Message.TryGetValue("NumItems", out var numItems))
{
ViewModel.FilesCount = (int)(long)numItems;
SetItemsCountString();
ViewModel.FilesAndFoldersCountVisibility = Visibility.Visible;
}
else
{
ViewModel.FilesAndFoldersCountVisibility = Visibility.Collapsed;
}
ViewModel.ItemCreatedTimestampVisibiity = Visibility.Collapsed;
ViewModel.ItemAccessedTimestampVisibility = Visibility.Collapsed;
ViewModel.ItemModifiedTimestampVisibility = Visibility.Collapsed;
ViewModel.ItemFileOwnerVisibility = Visibility.Collapsed;
ViewModel.LastSeparatorVisibility = Visibility.Collapsed;
}
}
}
}
/// <summary>
/// Set a single file or folder to hidden or unhidden an refresh the
/// view after setting the flag
/// </summary>
/// <param name="item"></param>
/// <param name="isHidden"></param>
public static void SetHiddenAttributeItem(ListedItem item, bool isHidden, ItemManipulationModel itemManipulationModel)
{
item.IsHiddenItem = isHidden;
itemManipulationModel.RefreshItemsOpacity();
}
protected abstract void AddSelectedItem(ListedItem item);
public FileProperties(SelectedItemsPropertiesViewModel viewModel, CancellationTokenSource tokenSource, CoreDispatcher coreDispatcher, ProgressBar progressBar, ListedItem item)
{
ViewModel = viewModel;
TokenSource = tokenSource;
ProgressBar = progressBar;
Dispatcher = coreDispatcher;
Item = item;
GetBaseProperties();
ViewModel.PropertyChanged += ViewModel_PropertyChanged;
}
public virtual void SetItemOpacity(ListedItem item)
{
item.Opacity = 0.4;
}
public override async void GetSpecialProperties()
{
ViewModel.ItemSizeVisibility = Visibility.Visible;
ViewModel.ItemSize = ByteSize.FromBytes(Item.FileSizeBytes).ToBinaryString().ConvertSizeAbbreviation()
+ " (" + ByteSize.FromBytes(Item.FileSizeBytes).Bytes.ToString("#,##0") + " " + ResourceController.GetTranslation("ItemSizeBytes") + ")";
if (Item.IsShortcutItem)
{
ViewModel.ItemCreatedTimestamp = Item.ItemDateCreated;
ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
ViewModel.LoadLinkIcon = Item.IsLinkItem;
if (Item.IsLinkItem || string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))
{
// Can't show any other property
return;
}
}
StorageFile file = null;
try
{
file = await ItemViewModel.GetFileFromPathAsync((Item as ShortcutItem)?.TargetPath ?? Item.ItemPath);
}
catch (Exception ex)
{
NLog.LogManager.GetCurrentClassLogger().Error(ex, ex.Message);
// Could not access file, can't show any other property
return;
}
using (var Thumbnail = await file.GetThumbnailAsync(ThumbnailMode.SingleItem, 80, ThumbnailOptions.UseCurrentScale))
{
BitmapImage icon = new BitmapImage();
if (Thumbnail != null)
{
ViewModel.FileIconSource = icon;
await icon.SetSourceAsync(Thumbnail);
ViewModel.LoadUnknownTypeGlyph = false;
ViewModel.LoadFileIcon = true;
}
}
if (Item.IsShortcutItem)
{
// Can't show any other property
return;
}
ApplicationDataContainer localSettings = ApplicationData.Current.LocalSettings;
string returnformat = Enum.Parse <TimeStyle>(localSettings.Values[LocalSettings.DateTimeFormat].ToString()) == TimeStyle.Application ? "D" : "g";
ViewModel.ItemCreatedTimestamp = ListedItem.GetFriendlyDateFromFormat(file.DateCreated, returnformat);
GetOtherProperties(file.Properties);
// Get file MD5 hash
var hashAlgTypeName = HashAlgorithmNames.Md5;
ViewModel.ItemMD5HashProgressVisibility = Visibility.Visible;
ViewModel.ItemMD5HashVisibility = Visibility.Visible;
try
{
ViewModel.ItemMD5Hash = await App.CurrentInstance.InteractionOperations
.GetHashForFile(Item, hashAlgTypeName, TokenSource.Token, ProgressBar);
}
catch (Exception ex)
{
NLog.LogManager.GetCurrentClassLogger().Error(ex, ex.Message);
ViewModel.ItemMD5HashCalcError = true;
}
}
private void ItemManipulationModel_AddSelectedItemInvoked(object sender, ListedItem e)
{
FileList?.SelectedItems.Add(e);
}
public ArchivePreviewViewModel(ListedItem item) : base(item)
{
}
protected override void AddSelectedItem(ListedItem item)
{
FileList.SelectedItems.Add(item);
}
public override async Task <bool> SaveChangesAsync(ListedItem item)
{
if (BaseProperties is DriveProperties driveProps)
{
var drive = driveProps.Drive;
ViewModel.ItemName = ItemFileName.Text; // Make sure ItemName is updated
if (!string.IsNullOrWhiteSpace(ViewModel.ItemName) && ViewModel.OriginalItemName != ViewModel.ItemName)
{
var remDrive = new System.Text.RegularExpressions.Regex(@"\s*\(\w:\)$");
ViewModel.ItemName = remDrive.Replace(ViewModel.ItemName, ""); // Remove "(C:)" from the new label
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null && AppInstance.FilesystemViewModel != null)
{
_ = await connection.SendMessageForResponseAsync(new ValueSet()
{
{ "Arguments", "SetVolumeLabel" },
{ "drivename", drive.Path },
{ "newlabel", ViewModel.ItemName }
});
_ = CoreApplication.MainView.DispatcherQueue.EnqueueAsync(async() =>
{
await drive.UpdateLabelAsync();
await AppInstance.FilesystemViewModel?.SetWorkingDirectoryAsync(drive.Path);
});
return(true);
}
}
}
else if (BaseProperties is LibraryProperties libProps)
{
var library = libProps.Library;
ViewModel.ItemName = ItemFileName.Text; // Make sure ItemName is updated
var newName = ViewModel.ItemName;
if (!string.IsNullOrWhiteSpace(newName) && ViewModel.OriginalItemName != newName)
{
if (AppInstance.FilesystemViewModel != null && App.LibraryManager.CanCreateLibrary(newName).result)
{
var libraryPath = library.ItemPath;
var renamed = await AppInstance.FilesystemHelpers.RenameAsync(new StorageFileWithPath(null, libraryPath), newName, Windows.Storage.NameCollisionOption.FailIfExists, false);
if (renamed == Enums.ReturnResult.Success)
{
var newPath = Path.Combine(Path.GetDirectoryName(libraryPath), $"{newName}{ShellLibraryItem.EXTENSION}");
_ = CoreApplication.MainView.DispatcherQueue.EnqueueAsync(async() =>
{
await AppInstance.FilesystemViewModel?.SetWorkingDirectoryAsync(newPath);
});
return(true);
}
}
}
}
else
{
ViewModel.ItemName = ItemFileName.Text; // Make sure ItemName is updated
if (!string.IsNullOrWhiteSpace(ViewModel.ItemName) && ViewModel.OriginalItemName != ViewModel.ItemName)
{
return(await CoreApplication.MainView.DispatcherQueue.EnqueueAsync(() => UIFilesystemHelpers.RenameFileItemAsync(item,
ViewModel.OriginalItemName,
ViewModel.ItemName,
AppInstance)));
}
// Handle the hidden attribute
if (BaseProperties is CombinedProperties combinedProps)
{
// Handle each file independently
if (AppInstance?.SlimContentPage?.ItemManipulationModel != null) // null on homepage
{
foreach (var fileOrFolder in combinedProps.List)
{
await CoreApplication.MainView.DispatcherQueue.EnqueueAsync(() => UIFilesystemHelpers.SetHiddenAttributeItem(fileOrFolder, ViewModel.IsHidden, AppInstance.SlimContentPage.ItemManipulationModel));
}
}
return(true);
}
else
{
// Handle the visibility attribute for a single file
if (AppInstance?.SlimContentPage?.ItemManipulationModel != null) // null on homepage
{
await CoreApplication.MainView.DispatcherQueue.EnqueueAsync(() => UIFilesystemHelpers.SetHiddenAttributeItem(item, ViewModel.IsHidden, AppInstance.SlimContentPage.ItemManipulationModel));
}
return(true);
}
}
return(false);
}
public override void ScrollIntoView(ListedItem item)
{
FileList.ScrollIntoView(item);
}
/// <summary>
/// Set a single file or folder to hidden or unhidden an refresh the
/// view after setting the flag
/// </summary>
/// <param name="item"></param>
/// <param name="isHidden"></param>
public static void SetHiddenAttributeItem(ListedItem item, bool isHidden, IBaseLayout slimContentPage)
{
item.IsHiddenItem = isHidden;
slimContentPage.ResetItemOpacity();
}
public override void SetSelectedItemOnUi(ListedItem item)
{
ClearSelection();
FileList.SelectedItems.Add(item);
}
public override void SetItemOpacity(ListedItem item)
{
AllView.Columns[0].GetCellContent(item).Opacity = 0.4;
}
