Feature: Added "Size on disk" property to the Properties window (#12777)

manfromarce · web-flow · commit e1f43ccda2f3 · 2023-07-10T10:10:42.000-04:00
diff --git a/src/Files.App/Data/Models/SelectedItemsPropertiesViewModel.cs b/src/Files.App/Data/Models/SelectedItemsPropertiesViewModel.cs
@@ -147,6 +147,13 @@ public string ItemSize
 			set => SetProperty(ref itemSize, value);
 		}
 
+		private string itemSizeOnDisk;
+		public string ItemSizeOnDisk
+		{
+			get => itemSizeOnDisk;
+			set => SetProperty(ref itemSizeOnDisk, value);
+		}
+
 		private string uncompresseditemSize;
 		public string UncompressedItemSize
 		{
@@ -179,6 +186,13 @@ public long ItemSizeBytes
 			set => SetProperty(ref itemSizeBytes, value);
 		}
 
+		private long itemSizeOnDiskBytes;
+		public long ItemSizeOnDiskBytes
+		{
+			get => itemSizeOnDiskBytes;
+			set => SetProperty(ref itemSizeOnDiskBytes, value);
+		}
+
 		private long uncompresseditemSizeBytes;
 		public long UncompressedItemSizeBytes
 		{
@@ -193,6 +207,13 @@ public bool ItemSizeProgressVisibility
 			set => SetProperty(ref itemSizeProgressVisibility, value);
 		}
 
+		private bool itemSizeOnDiskProgressVisibility = false;
+		public bool ItemSizeOnDiskProgressVisibility
+		{
+			get => itemSizeOnDiskProgressVisibility;
+			set => SetProperty(ref itemSizeOnDiskProgressVisibility, value);
+		}
+
 		// For libraries
 		public int locationsCount;
 		public int LocationsCount
diff --git a/src/Files.App/Helpers/Interop/NativeFileOperationsHelper.cs b/src/Files.App/Helpers/Interop/NativeFileOperationsHelper.cs
@@ -478,6 +478,21 @@ public static bool WriteBufferToFileWithProgress(string filePath, byte[] buffer,
 			return null;
 		}
 
+		public static long? GetFileSizeOnDisk(string filePath)
+		{
+			using var handle = OpenFileForRead(filePath);
+			if (!handle.IsInvalid)
+			{
+				try
+				{
+					var fileAllocationInfo = Kernel32.GetFileInformationByHandleEx<Kernel32.FILE_STANDARD_INFO>(handle, Kernel32.FILE_INFO_BY_HANDLE_CLASS.FileStandardInfo);
+					return fileAllocationInfo.AllocationSize;
+				}
+				catch { }
+			}
+			return null;
+		}
+
 		// https://github.com/rad1oactive/BetterExplorer/blob/master/Windows%20API%20Code%20Pack%201.1/source/WindowsAPICodePack/Shell/ReparsePoint.cs
 		public static string ParseSymLink(string path)
 		{
diff --git a/src/Files.App/Strings/en-US/Resources.resw b/src/Files.App/Strings/en-US/Resources.resw
@@ -138,6 +138,9 @@
   <data name="SizeLabel" xml:space="preserve">
     <value>Size:</value>
   </data>
+  <data name="SizeOnDiskLabel" xml:space="preserve">
+    <value>Size on disk:</value>
+  </data>
   <data name="UncompressedSize" xml:space="preserve">
     <value>Uncompressed Size:</value>
   </data>
diff --git a/src/Files.App/ViewModels/Properties/Items/BaseProperties.cs b/src/Files.App/ViewModels/Properties/Items/BaseProperties.cs
@@ -39,16 +39,17 @@ public async Task GetOtherProperties(IStorageItemExtraProperties properties)
 			ViewModel.ItemAccessedTimestamp = dateTimeFormatter.ToShortLabel((DateTimeOffset)(extraProperties[dateAccessedProperty] ?? DateTimeOffset.Now));
 		}
 
-		public async Task<long> CalculateFolderSizeAsync(string path, CancellationToken token)
+		public async Task<(long size, long sizeOnDisk)> CalculateFolderSizeAsync(string path, CancellationToken token)
 		{
 			if (string.IsNullOrEmpty(path))
 			{
 				// In MTP devices calculating folder size would be too slow
 				// Also should use StorageFolder methods instead of FindFirstFileExFromApp
-				return 0;
+				return (0, 0);
 			}
 
 			long size = 0;
+			long sizeOnDisk = 0;
 			FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
 			int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
 
@@ -72,24 +73,30 @@ public async Task<long> CalculateFolderSizeAsync(string path, CancellationToken
 					if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
 					{
 						size += findData.GetSize();
+						var fileSizeOnDisk = NativeFileOperationsHelper.GetFileSizeOnDisk(Path.Combine(path, findData.cFileName));
+						sizeOnDisk += fileSizeOnDisk ?? 0;
 						++count;
 						ViewModel.FilesCount++;
 					}
 					else if (findData.cFileName != "." && findData.cFileName != "..")
 					{
 						var itemPath = Path.Combine(path, findData.cFileName);
 
-						size += await CalculateFolderSizeAsync(itemPath, token);
+						var folderSize = await CalculateFolderSizeAsync(itemPath, token);
+						size += folderSize.size;
+						sizeOnDisk += folderSize.sizeOnDisk;
 						++count;
 						ViewModel.FoldersCount++;
 					}
 
-					if (size > ViewModel.ItemSizeBytes)
+					if (size > ViewModel.ItemSizeBytes || sizeOnDisk > ViewModel.ItemSizeOnDiskBytes)
 					{
 						await Dispatcher.EnqueueOrInvokeAsync(() =>
 						{
 							ViewModel.ItemSizeBytes = size;
 							ViewModel.ItemSize = size.ToSizeString();
+							ViewModel.ItemSizeOnDiskBytes = sizeOnDisk;
+							ViewModel.ItemSizeOnDisk = sizeOnDisk.ToSizeString();
 							SetItemsCountString();
 						},
 						DispatcherQueuePriority.Low);
@@ -102,11 +109,11 @@ await Dispatcher.EnqueueOrInvokeAsync(() =>
 
 				FindClose(hFile);
 
-				return size;
+				return (size, sizeOnDisk);
 			}
 			else
 			{
-				return 0;
+				return (0, 0);
 			}
 		}
 
diff --git a/src/Files.App/ViewModels/Properties/Items/CombinedProperties.cs b/src/Files.App/ViewModels/Properties/Items/CombinedProperties.cs
@@ -72,8 +72,13 @@ public override async Task GetSpecialProperties()
 			long totalSize = 0;
 			long filesSize = List.Where(x => x.PrimaryItemAttribute == StorageItemTypes.File).Sum(x => x.FileSizeBytes);
 			long foldersSize = 0;
+			long totalSizeOnDisk = 0;
+			long filesSizeOnDisk = List.Where(x => x.PrimaryItemAttribute == StorageItemTypes.File)
+				.Sum(x => NativeFileOperationsHelper.GetFileSizeOnDisk(x.ItemPath) ?? 0);
+			long foldersSizeOnDisk = 0;
 
 			ViewModel.ItemSizeProgressVisibility = true;
+			ViewModel.ItemSizeOnDiskProgressVisibility = true;
 
 			foreach (var item in List)
 			{
@@ -88,7 +93,9 @@ public override async Task GetSpecialProperties()
 
 					try
 					{
-						foldersSize += await fileSizeTask;
+						var folderSize = await fileSizeTask;
+						foldersSize += folderSize.size;
+						foldersSizeOnDisk += folderSize.sizeOnDisk;
 					}
 					catch (Exception ex)
 					{
@@ -98,9 +105,12 @@ public override async Task GetSpecialProperties()
 			}
 
 			ViewModel.ItemSizeProgressVisibility = false;
+			ViewModel.ItemSizeOnDiskProgressVisibility = false;
 
 			totalSize = filesSize + foldersSize;
 			ViewModel.ItemSize = totalSize.ToLongSizeString();
+			totalSizeOnDisk = filesSizeOnDisk + foldersSizeOnDisk;
+			ViewModel.ItemSizeOnDisk = totalSizeOnDisk.ToLongSizeString();
 
 			SetItemsCountString();
 		}
diff --git a/src/Files.App/ViewModels/Properties/Items/FileProperties.cs b/src/Files.App/ViewModels/Properties/Items/FileProperties.cs
@@ -97,6 +97,8 @@ public override async Task GetSpecialProperties()
 
 			ViewModel.ItemSizeVisibility = true;
 			ViewModel.ItemSize = Item.FileSizeBytes.ToLongSizeString();
+			ViewModel.ItemSizeOnDisk = NativeFileOperationsHelper.GetFileSizeOnDisk(Item.ItemPath)?.ToLongSizeString() ??
+				string.Empty;
 
 			var fileIconData = await FileThumbnailHelper.LoadIconFromPathAsync(Item.ItemPath, 80, Windows.Storage.FileProperties.ThumbnailMode.DocumentsView, false);
 			if (fileIconData is not null)
diff --git a/src/Files.App/ViewModels/Properties/Items/FolderProperties.cs b/src/Files.App/ViewModels/Properties/Items/FolderProperties.cs
@@ -89,6 +89,11 @@ public async override Task GetSpecialProperties()
 			{
 				ViewModel.ItemSizeVisibility = true;
 				ViewModel.ItemSize = Item.FileSizeBytes.ToLongSizeString();
+				var sizeOnDisk = NativeFileOperationsHelper.GetFileSizeOnDisk(Item.ItemPath);
+				if (sizeOnDisk is not null)
+				{
+					ViewModel.ItemSizeOnDisk = ((long)sizeOnDisk).ToLongSizeString();
+				}
 				ViewModel.ItemCreatedTimestamp = Item.ItemDateCreated;
 				ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;
 				if (Item.IsLinkItem || string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))
@@ -123,6 +128,7 @@ public async override Task GetSpecialProperties()
 				{
 					ViewModel.ItemSizeVisibility = false;
 				}
+				ViewModel.ItemSizeOnDisk = string.Empty;
 				if (recycleBinQuery.NumItems is long numItems)
 				{
 					ViewModel.FilesCount = (int)numItems;
@@ -156,6 +162,7 @@ private async Task GetFolderSize(string folderPath, CancellationToken token)
 
 			ViewModel.ItemSizeVisibility = true;
 			ViewModel.ItemSizeProgressVisibility = true;
+			ViewModel.ItemSizeOnDiskProgressVisibility = true;
 
 			var fileSizeTask = Task.Run(async () =>
 			{
@@ -166,15 +173,18 @@ private async Task GetFolderSize(string folderPath, CancellationToken token)
 			try
 			{
 				var folderSize = await fileSizeTask;
-				ViewModel.ItemSizeBytes = folderSize;
-				ViewModel.ItemSize = folderSize.ToLongSizeString();
+				ViewModel.ItemSizeBytes = folderSize.size;
+				ViewModel.ItemSize = folderSize.size.ToLongSizeString();
+				ViewModel.ItemSizeOnDiskBytes = folderSize.sizeOnDisk;
+				ViewModel.ItemSizeOnDisk = folderSize.sizeOnDisk.ToLongSizeString();
 			}
 			catch (Exception ex)
 			{
 				App.Logger.LogWarning(ex, ex.Message);
 			}
 
 			ViewModel.ItemSizeProgressVisibility = false;
+			ViewModel.ItemSizeOnDiskProgressVisibility = false;
 
 			SetItemsCountString();
 		}
diff --git a/src/Files.App/ViewModels/Properties/Items/LibraryProperties.cs b/src/Files.App/ViewModels/Properties/Items/LibraryProperties.cs
@@ -112,23 +112,30 @@ private async Task GetLibrarySize(List<BaseStorageFolder> storageFolders, Cancel
 		{
 			ViewModel.ItemSizeVisibility = true;
 			ViewModel.ItemSizeProgressVisibility = true;
+			ViewModel.ItemSizeOnDiskProgressVisibility = true;
 
 			try
 			{
 				long librarySize = 0;
+				long librarySizeOnDisk = 0;
 				foreach (var folder in storageFolders)
 				{
-					librarySize += await Task.Run(async () => await CalculateFolderSizeAsync(folder.Path, token));
+					var foldersSize = await Task.Run(async () => await CalculateFolderSizeAsync(folder.Path, token));
+					librarySize += foldersSize.size;
+					librarySizeOnDisk += foldersSize.sizeOnDisk;
 				}
 				ViewModel.ItemSizeBytes = librarySize;
 				ViewModel.ItemSize = librarySize.ToLongSizeString();
+				ViewModel.ItemSizeOnDiskBytes = librarySize;
+				ViewModel.ItemSizeOnDisk = librarySize.ToLongSizeString();
 			}
 			catch (Exception ex)
 			{
 				App.Logger.LogWarning(ex, ex.Message);
 			}
 
 			ViewModel.ItemSizeProgressVisibility = false;
+			ViewModel.ItemSizeOnDiskProgressVisibility = false;
 
 			SetItemsCountString();
 		}
diff --git a/src/Files.App/Views/Properties/GeneralPage.xaml b/src/Files.App/Views/Properties/GeneralPage.xaml

Original file line number	Diff line number	Diff line change
`@@ -39,16 +39,17 @@ public async Task GetOtherProperties(IStorageItemExtraProperties properties)`
`39`	`39`	`ViewModel.ItemAccessedTimestamp = dateTimeFormatter.ToShortLabel((DateTimeOffset)(extraProperties[dateAccessedProperty] ?? DateTimeOffset.Now));`
`40`	`40`	`}`
`41`	`41`
`42`		`- public async Task<long> CalculateFolderSizeAsync(string path, CancellationToken token)`
	`42`	`+ public async Task<(long size, long sizeOnDisk)> CalculateFolderSizeAsync(string path, CancellationToken token)`
`43`	`43`	`{`
`44`	`44`	`if (string.IsNullOrEmpty(path))`
`45`	`45`	`{`
`46`	`46`	`// In MTP devices calculating folder size would be too slow`
`47`	`47`	`// Also should use StorageFolder methods instead of FindFirstFileExFromApp`
`48`		`- return 0;`
	`48`	`+ return (0, 0);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`long size = 0;`
	`52`	`+ long sizeOnDisk = 0;`
`52`	`53`	`FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;`
`53`	`54`	`int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;`
`54`	`55`
`@@ -72,24 +73,30 @@ public async Task<long> CalculateFolderSizeAsync(string path, CancellationToken`
`72`	`73`	`if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)`
`73`	`74`	`{`
`74`	`75`	`size += findData.GetSize();`
	`76`	`+ var fileSizeOnDisk = NativeFileOperationsHelper.GetFileSizeOnDisk(Path.Combine(path, findData.cFileName));`
	`77`	`+ sizeOnDisk += fileSizeOnDisk ?? 0;`
`75`	`78`	`++count;`
`76`	`79`	`ViewModel.FilesCount++;`
`77`	`80`	`}`
`78`	`81`	`else if (findData.cFileName != "." && findData.cFileName != "..")`
`79`	`82`	`{`
`80`	`83`	`var itemPath = Path.Combine(path, findData.cFileName);`
`81`	`84`
`82`		`- size += await CalculateFolderSizeAsync(itemPath, token);`
	`85`	`+ var folderSize = await CalculateFolderSizeAsync(itemPath, token);`
	`86`	`+ size += folderSize.size;`
	`87`	`+ sizeOnDisk += folderSize.sizeOnDisk;`
`83`	`88`	`++count;`
`84`	`89`	`ViewModel.FoldersCount++;`
`85`	`90`	`}`
`86`	`91`
`87`		`- if (size > ViewModel.ItemSizeBytes)`
	`92`	`+ if (size > ViewModel.ItemSizeBytes \|\| sizeOnDisk > ViewModel.ItemSizeOnDiskBytes)`
`88`	`93`	`{`
`89`	`94`	`await Dispatcher.EnqueueOrInvokeAsync(() =>`
`90`	`95`	`{`
`91`	`96`	`ViewModel.ItemSizeBytes = size;`
`92`	`97`	`ViewModel.ItemSize = size.ToSizeString();`
	`98`	`+ ViewModel.ItemSizeOnDiskBytes = sizeOnDisk;`
	`99`	`+ ViewModel.ItemSizeOnDisk = sizeOnDisk.ToSizeString();`
`93`	`100`	`SetItemsCountString();`
`94`	`101`	`},`
`95`	`102`	`DispatcherQueuePriority.Low);`
`@@ -102,11 +109,11 @@ await Dispatcher.EnqueueOrInvokeAsync(() =>`
`102`	`109`
`103`	`110`	`FindClose(hFile);`
`104`	`111`
`105`		`- return size;`
	`112`	`+ return (size, sizeOnDisk);`
`106`	`113`	`}`
`107`	`114`	`else`
`108`	`115`	`{`
`109`		`- return 0;`
	`116`	`+ return (0, 0);`
`110`	`117`	`}`
`111`	`118`	`}`
`112`	`119`
Original file line number	Diff line number	Diff line change
`@@ -72,8 +72,13 @@ public override async Task GetSpecialProperties()`
`72`	`72`	`long totalSize = 0;`
`73`	`73`	`long filesSize = List.Where(x => x.PrimaryItemAttribute == StorageItemTypes.File).Sum(x => x.FileSizeBytes);`
`74`	`74`	`long foldersSize = 0;`
	`75`	`+ long totalSizeOnDisk = 0;`
	`76`	`+ long filesSizeOnDisk = List.Where(x => x.PrimaryItemAttribute == StorageItemTypes.File)`
	`77`	`+ .Sum(x => NativeFileOperationsHelper.GetFileSizeOnDisk(x.ItemPath) ?? 0);`
	`78`	`+ long foldersSizeOnDisk = 0;`
`75`	`79`
`76`	`80`	`ViewModel.ItemSizeProgressVisibility = true;`
	`81`	`+ ViewModel.ItemSizeOnDiskProgressVisibility = true;`
`77`	`82`
`78`	`83`	`foreach (var item in List)`
`79`	`84`	`{`
`@@ -88,7 +93,9 @@ public override async Task GetSpecialProperties()`
`88`	`93`
`89`	`94`	`try`
`90`	`95`	`{`
`91`		`- foldersSize += await fileSizeTask;`
	`96`	`+ var folderSize = await fileSizeTask;`
	`97`	`+ foldersSize += folderSize.size;`
	`98`	`+ foldersSizeOnDisk += folderSize.sizeOnDisk;`
`92`	`99`	`}`
`93`	`100`	`catch (Exception ex)`
`94`	`101`	`{`
`@@ -98,9 +105,12 @@ public override async Task GetSpecialProperties()`
`98`	`105`	`}`
`99`	`106`
`100`	`107`	`ViewModel.ItemSizeProgressVisibility = false;`
	`108`	`+ ViewModel.ItemSizeOnDiskProgressVisibility = false;`
`101`	`109`
`102`	`110`	`totalSize = filesSize + foldersSize;`
`103`	`111`	`ViewModel.ItemSize = totalSize.ToLongSizeString();`
	`112`	`+ totalSizeOnDisk = filesSizeOnDisk + foldersSizeOnDisk;`
	`113`	`+ ViewModel.ItemSizeOnDisk = totalSizeOnDisk.ToLongSizeString();`
`104`	`114`
`105`	`115`	`SetItemsCountString();`
`106`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,11 @@ public async override Task GetSpecialProperties()`
`89`	`89`	`{`
`90`	`90`	`ViewModel.ItemSizeVisibility = true;`
`91`	`91`	`ViewModel.ItemSize = Item.FileSizeBytes.ToLongSizeString();`
	`92`	`+ var sizeOnDisk = NativeFileOperationsHelper.GetFileSizeOnDisk(Item.ItemPath);`
	`93`	`+ if (sizeOnDisk is not null)`
	`94`	`+ {`
	`95`	`+ ViewModel.ItemSizeOnDisk = ((long)sizeOnDisk).ToLongSizeString();`
	`96`	`+ }`
`92`	`97`	`ViewModel.ItemCreatedTimestamp = Item.ItemDateCreated;`
`93`	`98`	`ViewModel.ItemAccessedTimestamp = Item.ItemDateAccessed;`
`94`	`99`	`if (Item.IsLinkItem \|\| string.IsNullOrWhiteSpace(((ShortcutItem)Item).TargetPath))`
`@@ -123,6 +128,7 @@ public async override Task GetSpecialProperties()`
`123`	`128`	`{`
`124`	`129`	`ViewModel.ItemSizeVisibility = false;`
`125`	`130`	`}`
	`131`	`+ ViewModel.ItemSizeOnDisk = string.Empty;`
`126`	`132`	`if (recycleBinQuery.NumItems is long numItems)`
`127`	`133`	`{`
`128`	`134`	`ViewModel.FilesCount = (int)numItems;`
`@@ -156,6 +162,7 @@ private async Task GetFolderSize(string folderPath, CancellationToken token)`
`156`	`162`
`157`	`163`	`ViewModel.ItemSizeVisibility = true;`
`158`	`164`	`ViewModel.ItemSizeProgressVisibility = true;`
	`165`	`+ ViewModel.ItemSizeOnDiskProgressVisibility = true;`
`159`	`166`
`160`	`167`	`var fileSizeTask = Task.Run(async () =>`
`161`	`168`	`{`
`@@ -166,15 +173,18 @@ private async Task GetFolderSize(string folderPath, CancellationToken token)`
`166`	`173`	`try`
`167`	`174`	`{`
`168`	`175`	`var folderSize = await fileSizeTask;`
`169`		`- ViewModel.ItemSizeBytes = folderSize;`
`170`		`- ViewModel.ItemSize = folderSize.ToLongSizeString();`
	`176`	`+ ViewModel.ItemSizeBytes = folderSize.size;`
	`177`	`+ ViewModel.ItemSize = folderSize.size.ToLongSizeString();`
	`178`	`+ ViewModel.ItemSizeOnDiskBytes = folderSize.sizeOnDisk;`
	`179`	`+ ViewModel.ItemSizeOnDisk = folderSize.sizeOnDisk.ToLongSizeString();`
`171`	`180`	`}`
`172`	`181`	`catch (Exception ex)`
`173`	`182`	`{`
`174`	`183`	`App.Logger.LogWarning(ex, ex.Message);`
`175`	`184`	`}`
`176`	`185`
`177`	`186`	`ViewModel.ItemSizeProgressVisibility = false;`
	`187`	`+ ViewModel.ItemSizeOnDiskProgressVisibility = false;`
`178`	`188`
`179`	`189`	`SetItemsCountString();`
`180`	`190`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,23 +112,30 @@ private async Task GetLibrarySize(List<BaseStorageFolder> storageFolders, Cancel`
`112`	`112`	`{`
`113`	`113`	`ViewModel.ItemSizeVisibility = true;`
`114`	`114`	`ViewModel.ItemSizeProgressVisibility = true;`
	`115`	`+ ViewModel.ItemSizeOnDiskProgressVisibility = true;`
`115`	`116`
`116`	`117`	`try`
`117`	`118`	`{`
`118`	`119`	`long librarySize = 0;`
	`120`	`+ long librarySizeOnDisk = 0;`
`119`	`121`	`foreach (var folder in storageFolders)`
`120`	`122`	`{`
`121`		`- librarySize += await Task.Run(async () => await CalculateFolderSizeAsync(folder.Path, token));`
	`123`	`+ var foldersSize = await Task.Run(async () => await CalculateFolderSizeAsync(folder.Path, token));`
	`124`	`+ librarySize += foldersSize.size;`
	`125`	`+ librarySizeOnDisk += foldersSize.sizeOnDisk;`
`122`	`126`	`}`
`123`	`127`	`ViewModel.ItemSizeBytes = librarySize;`
`124`	`128`	`ViewModel.ItemSize = librarySize.ToLongSizeString();`
	`129`	`+ ViewModel.ItemSizeOnDiskBytes = librarySize;`
	`130`	`+ ViewModel.ItemSizeOnDisk = librarySize.ToLongSizeString();`
`125`	`131`	`}`
`126`	`132`	`catch (Exception ex)`
`127`	`133`	`{`
`128`	`134`	`App.Logger.LogWarning(ex, ex.Message);`
`129`	`135`	`}`
`130`	`136`
`131`	`137`	`ViewModel.ItemSizeProgressVisibility = false;`
	`138`	`+ ViewModel.ItemSizeOnDiskProgressVisibility = false;`
`132`	`139`
`133`	`140`	`SetItemsCountString();`
`134`	`141`	`}`