Remember the sort option and direction across multiple sessions (#1439)

yaira2 · web-flow · commit 6b7330a2c9d2 · 2020-07-15T18:55:41.000-04:00
diff --git a/Files/Enums/SortOption.cs b/Files/Enums/SortOption.cs
@@ -1,6 +1,6 @@
 ﻿namespace Files.Enums
 {
-    public enum SortOption
+    public enum SortOption : byte
     {
         Name,
         DateModified,
diff --git a/Files/Interacts/Interaction.cs b/Files/Interacts/Interaction.cs
@@ -380,10 +380,10 @@ private async void OpenSelectedItems(bool displayApplicationPicker)
                                 //We can have many sort entries
                                 SortEntry sortEntry = new SortEntry()
                                 {
-                                    AscendingOrder = CurrentInstance.FilesystemViewModel.DirectorySortDirection == Microsoft.Toolkit.Uwp.UI.SortDirection.Ascending,
+                                    AscendingOrder = AppSettings.DirectorySortDirection == Microsoft.Toolkit.Uwp.UI.SortDirection.Ascending,
                                 };
 
-                                var sortOption = CurrentInstance.FilesystemViewModel.DirectorySortOption;
+                                var sortOption = AppSettings.DirectorySortOption;
 
                                 switch (sortOption)
                                 {
diff --git a/Files/View Models/ItemViewModel.cs b/Files/View Models/ItemViewModel.cs
@@ -52,8 +52,6 @@ public class ItemViewModel : INotifyPropertyChanged, IDisposable
 
         private string _jumpString = "";
         private readonly DispatcherTimer jumpTimer = new DispatcherTimer();
-        private SortOption _directorySortOption = SortOption.Name;
-        private SortDirection _directorySortDirection = SortDirection.Ascending;
 
         private string _customPath;
 
@@ -161,111 +159,82 @@ public bool IsFolderEmptyTextDisplayed
             }
         }
 
-        public SortOption DirectorySortOption
+        public void UpdateSortOptionStatus()
         {
-            get
-            {
-                return _directorySortOption;
-            }
-            set
-            {
-                if (value != _directorySortOption)
-                {
-                    _directorySortOption = value;
-                    NotifyPropertyChanged("DirectorySortOption");
-                    NotifyPropertyChanged("IsSortedByName");
-                    NotifyPropertyChanged("IsSortedByDate");
-                    NotifyPropertyChanged("IsSortedByType");
-                    NotifyPropertyChanged("IsSortedBySize");
-                    OrderFiles();
-                }
-            }
+            NotifyPropertyChanged("IsSortedByName");
+            NotifyPropertyChanged("IsSortedByDate");
+            NotifyPropertyChanged("IsSortedByType");
+            NotifyPropertyChanged("IsSortedBySize");
+            OrderFiles();
         }
 
-        public SortDirection DirectorySortDirection
+        public void UpdateSortDirectionStatus()
         {
-            get
-            {
-                return _directorySortDirection;
-            }
-            set
-            {
-                if (value != _directorySortDirection)
-                {
-                    _directorySortDirection = value;
-                    NotifyPropertyChanged("DirectorySortDirection");
-                    NotifyPropertyChanged("IsSortedAscending");
-                    NotifyPropertyChanged("IsSortedDescending");
-                    OrderFiles();
-                }
-            }
+            NotifyPropertyChanged("IsSortedAscending");
+            NotifyPropertyChanged("IsSortedDescending");
+            OrderFiles();
         }
 
         public bool IsSortedByName
         {
-            get => DirectorySortOption == SortOption.Name;
+            get => AppSettings.DirectorySortOption == SortOption.Name;
             set
             {
                 if (value)
                 {
-                    DirectorySortOption = SortOption.Name;
+                    AppSettings.DirectorySortOption = SortOption.Name;
                     NotifyPropertyChanged("IsSortedByName");
-                    NotifyPropertyChanged("DirectorySortOption");
                 }
             }
         }
 
         public bool IsSortedByDate
         {
-            get => DirectorySortOption == SortOption.DateModified;
+            get => AppSettings.DirectorySortOption == SortOption.DateModified;
             set
             {
                 if (value)
                 {
-                    DirectorySortOption = SortOption.DateModified;
+                    AppSettings.DirectorySortOption = SortOption.DateModified;
                     NotifyPropertyChanged("IsSortedByDate");
-                    NotifyPropertyChanged("DirectorySortOption");
                 }
             }
         }
 
         public bool IsSortedByType
         {
-            get => DirectorySortOption == SortOption.FileType;
+            get => AppSettings.DirectorySortOption == SortOption.FileType;
             set
             {
                 if (value)
                 {
-                    DirectorySortOption = SortOption.FileType;
+                    AppSettings.DirectorySortOption = SortOption.FileType;
                     NotifyPropertyChanged("IsSortedByType");
-                    NotifyPropertyChanged("DirectorySortOption");
                 }
             }
         }
 
         public bool IsSortedBySize
         {
-            get => DirectorySortOption == SortOption.Size;
+            get => AppSettings.DirectorySortOption == SortOption.Size;
             set
             {
                 if (value)
                 {
-                    DirectorySortOption = SortOption.Size;
+                    AppSettings.DirectorySortOption = SortOption.Size;
                     NotifyPropertyChanged("IsSortedBySize");
-                    NotifyPropertyChanged("DirectorySortOption");
                 }
             }
         }
 
         public bool IsSortedAscending
         {
-            get => DirectorySortDirection == SortDirection.Ascending;
+            get => AppSettings.DirectorySortDirection == SortDirection.Ascending;
             set
             {
-                DirectorySortDirection = value ? SortDirection.Ascending : SortDirection.Descending;
+                AppSettings.DirectorySortDirection = value ? SortDirection.Ascending : SortDirection.Descending;
                 NotifyPropertyChanged("IsSortedAscending");
                 NotifyPropertyChanged("IsSortedDescending");
-                NotifyPropertyChanged("DirectorySortDirection");
             }
         }
 
@@ -274,10 +243,9 @@ public bool IsSortedDescending
             get => !IsSortedAscending;
             set
             {
-                DirectorySortDirection = value ? SortDirection.Descending : SortDirection.Ascending;
+                AppSettings.DirectorySortDirection = value ? SortDirection.Descending : SortDirection.Ascending;
                 NotifyPropertyChanged("IsSortedAscending");
                 NotifyPropertyChanged("IsSortedDescending");
-                NotifyPropertyChanged("DirectorySortDirection");
             }
         }
 
@@ -393,7 +361,7 @@ public void OrderFiles()
             static object orderByNameFunc(ListedItem item) => item.ItemName;
             Func<ListedItem, object> orderFunc = orderByNameFunc;
             NaturalStringComparer naturalStringComparer = new NaturalStringComparer();
-            switch (DirectorySortOption)
+            switch (AppSettings.DirectorySortOption)
             {
                 case SortOption.Name:
                     orderFunc = orderByNameFunc;
@@ -418,35 +386,35 @@ public void OrderFiles()
             IOrderedEnumerable<ListedItem> ordered;
             List<ListedItem> orderedList;
 
-            if (DirectorySortDirection == SortDirection.Ascending)
+            if (AppSettings.DirectorySortDirection == SortDirection.Ascending)
             {
-                if (DirectorySortOption == SortOption.Name)
+                if (AppSettings.DirectorySortOption == SortOption.Name)
                     ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenBy(orderFunc, naturalStringComparer);
                 else
                     ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenBy(orderFunc);
             }
             else
             {
-                if (DirectorySortOption == SortOption.FileType)
+                if (AppSettings.DirectorySortOption == SortOption.FileType)
                 {
-                    if (DirectorySortOption == SortOption.Name)
+                    if (AppSettings.DirectorySortOption == SortOption.Name)
                         ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenByDescending(orderFunc, naturalStringComparer);
                     else
                         ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenByDescending(orderFunc);
                 }
                 else
                 {
-                    if (DirectorySortOption == SortOption.Name)
+                    if (AppSettings.DirectorySortOption == SortOption.Name)
                         ordered = _filesAndFolders.OrderByDescending(folderThenFileAsync).ThenByDescending(orderFunc, naturalStringComparer);
                     else
                         ordered = _filesAndFolders.OrderByDescending(folderThenFileAsync).ThenByDescending(orderFunc);
                 }
             }
 
             // Further order by name if applicable
-            if (DirectorySortOption != SortOption.Name)
+            if (AppSettings.DirectorySortOption != SortOption.Name)
             {
-                if (DirectorySortDirection == SortDirection.Ascending)
+                if (AppSettings.DirectorySortDirection == SortDirection.Ascending)
                     ordered = ordered.ThenBy(orderByNameFunc, naturalStringComparer);
                 else
                     ordered = ordered.ThenByDescending(orderByNameFunc, naturalStringComparer);
@@ -1480,4 +1448,4 @@ public void Dispose()
             CloseWatcher();
         }
     }
-}
+}
diff --git a/Files/View Models/SettingsViewModel.cs b/Files/View Models/SettingsViewModel.cs
@@ -8,6 +8,7 @@
 using GalaSoft.MvvmLight;
 using GalaSoft.MvvmLight.Command;
 using Microsoft.AppCenter.Analytics;
+using Microsoft.Toolkit.Uwp.UI;
 using Microsoft.Toolkit.Uwp.UI.Controls.TextToolbarSymbols;
 using System;
 using System.Collections.Generic;
@@ -43,7 +44,6 @@ public SettingsViewModel()
             DetectRecycleBinPreference();
             DetectQuickLook();
             DetectGridViewSize();
-
             DrivesManager = new DrivesManager();
 
             //DetectWSLDistros();
@@ -59,8 +59,8 @@ public SettingsViewModel()
             Analytics.TrackEvent("ShowConfirmDeleteDialog " + ShowConfirmDeleteDialog.ToString());
             Analytics.TrackEvent("AcrylicSidebar " + AcrylicEnabled.ToString());
             Analytics.TrackEvent("ShowFileOwner " + ShowFileOwner.ToString());
-
             // Load the supported languages
+
             var supportedLang = ApplicationLanguages.ManifestLanguages;
             DefaultLanguages = new ObservableCollection<DefaultLanguageModel> { new DefaultLanguageModel(null) };
             foreach (var lang in supportedLang)
@@ -86,6 +86,38 @@ public DefaultLanguageModel DefaultLanguage
             }
         }
 
+        public SortOption DirectorySortOption
+        {
+            get => (SortOption)SortOptionByte;
+            set
+            {
+                SortOptionByte = (byte)value;
+                App.CurrentInstance?.FilesystemViewModel?.UpdateSortOptionStatus();
+            }
+        }
+
+        public SortDirection DirectorySortDirection
+        {
+            get => (SortDirection)SortDirectionByte;
+            set
+            {
+                SortDirectionByte = (byte)value;
+                App.CurrentInstance?.FilesystemViewModel?.UpdateSortDirectionStatus();
+            }
+        }
+
+        private byte SortOptionByte
+        {
+            get => Get((byte)0);
+            set => Set(value);
+        }
+
+        private byte SortDirectionByte
+        {
+            get => Get((byte)0);
+            set => Set(value);
+        }
+
         public async void DetectQuickLook()
         {
             // Detect QuickLook
diff --git a/Files/Views/LayoutModes/GenericFileBrowser.xaml.cs b/Files/Views/LayoutModes/GenericFileBrowser.xaml.cs
@@ -34,23 +34,23 @@ public DataGridColumn SortedColumn
             set
             {
                 if (value == nameColumn)
-                    App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.Name;
+                    AppSettings.DirectorySortOption = SortOption.Name;
                 else if (value == dateColumn)
-                    App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.DateModified;
+                    AppSettings.DirectorySortOption = SortOption.DateModified;
                 else if (value == typeColumn)
-                    App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.FileType;
+                    AppSettings.DirectorySortOption = SortOption.FileType;
                 else if (value == sizeColumn)
-                    App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.Size;
+                    AppSettings.DirectorySortOption = SortOption.Size;
                 else
-                    App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.Name;
+                    AppSettings.DirectorySortOption = SortOption.Name;
 
                 if (value != _sortedColumn)
                 {
                     // Remove arrow on previous sorted column
                     if (_sortedColumn != null)
                         _sortedColumn.SortDirection = null;
                 }
-                value.SortDirection = App.CurrentInstance.FilesystemViewModel.DirectorySortDirection == SortDirection.Ascending ? DataGridSortDirection.Ascending : DataGridSortDirection.Descending;
+                value.SortDirection = AppSettings.DirectorySortDirection == SortDirection.Ascending ? DataGridSortDirection.Ascending : DataGridSortDirection.Descending;
                 _sortedColumn = value;
             }
         }
@@ -59,7 +59,7 @@ public GenericFileBrowser()
         {
             InitializeComponent();
             base.BaseLayoutItemContextFlyout = this.BaseLayoutItemContextFlyout;
-            switch (App.CurrentInstance.FilesystemViewModel.DirectorySortOption)
+            switch (AppSettings.DirectorySortOption)
             {
                 case SortOption.Name:
                     SortedColumn = nameColumn;
@@ -192,7 +192,7 @@ private async void ViewModel_PropertyChanged(object sender, PropertyChangedEvent
         {
             if (e.PropertyName == "DirectorySortOption")
             {
-                switch (App.CurrentInstance.FilesystemViewModel.DirectorySortOption)
+                switch (AppSettings.DirectorySortOption)
                 {
                     case SortOption.Name:
                         SortedColumn = nameColumn;

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`namespace Files.Enums`
`2`	`2`	`{`
`3`		`- public enum SortOption`
	`3`	`+ public enum SortOption : byte`
`4`	`4`	`{`
`5`	`5`	`Name,`
`6`	`6`	`DateModified,`
Original file line number	Diff line number	Diff line change
`@@ -380,10 +380,10 @@ private async void OpenSelectedItems(bool displayApplicationPicker)`
`380`	`380`	`//We can have many sort entries`
`381`	`381`	`SortEntry sortEntry = new SortEntry()`
`382`	`382`	`{`
`383`		`- AscendingOrder = CurrentInstance.FilesystemViewModel.DirectorySortDirection == Microsoft.Toolkit.Uwp.UI.SortDirection.Ascending,`
	`383`	`+ AscendingOrder = AppSettings.DirectorySortDirection == Microsoft.Toolkit.Uwp.UI.SortDirection.Ascending,`
`384`	`384`	`};`
`385`	`385`
`386`		`- var sortOption = CurrentInstance.FilesystemViewModel.DirectorySortOption;`
	`386`	`+ var sortOption = AppSettings.DirectorySortOption;`
`387`	`387`
`388`	`388`	`switch (sortOption)`
`389`	`389`	`{`
Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,6 @@ public class ItemViewModel : INotifyPropertyChanged, IDisposable`
`52`	`52`
`53`	`53`	`private string _jumpString = "";`
`54`	`54`	`private readonly DispatcherTimer jumpTimer = new DispatcherTimer();`
`55`		`- private SortOption _directorySortOption = SortOption.Name;`
`56`		`- private SortDirection _directorySortDirection = SortDirection.Ascending;`
`57`	`55`
`58`	`56`	`private string _customPath;`
`59`	`57`
`@@ -161,111 +159,82 @@ public bool IsFolderEmptyTextDisplayed`
`161`	`159`	`}`
`162`	`160`	`}`
`163`	`161`
`164`		`- public SortOption DirectorySortOption`
	`162`	`+ public void UpdateSortOptionStatus()`
`165`	`163`	`{`
`166`		`- get`
`167`		`- {`
`168`		`- return _directorySortOption;`
`169`		`- }`
`170`		`- set`
`171`		`- {`
`172`		`- if (value != _directorySortOption)`
`173`		`- {`
`174`		`- _directorySortOption = value;`
`175`		`- NotifyPropertyChanged("DirectorySortOption");`
`176`		`- NotifyPropertyChanged("IsSortedByName");`
`177`		`- NotifyPropertyChanged("IsSortedByDate");`
`178`		`- NotifyPropertyChanged("IsSortedByType");`
`179`		`- NotifyPropertyChanged("IsSortedBySize");`
`180`		`- OrderFiles();`
`181`		`- }`
`182`		`- }`
	`164`	`+ NotifyPropertyChanged("IsSortedByName");`
	`165`	`+ NotifyPropertyChanged("IsSortedByDate");`
	`166`	`+ NotifyPropertyChanged("IsSortedByType");`
	`167`	`+ NotifyPropertyChanged("IsSortedBySize");`
	`168`	`+ OrderFiles();`
`183`	`169`	`}`
`184`	`170`
`185`		`- public SortDirection DirectorySortDirection`
	`171`	`+ public void UpdateSortDirectionStatus()`
`186`	`172`	`{`
`187`		`- get`
`188`		`- {`
`189`		`- return _directorySortDirection;`
`190`		`- }`
`191`		`- set`
`192`		`- {`
`193`		`- if (value != _directorySortDirection)`
`194`		`- {`
`195`		`- _directorySortDirection = value;`
`196`		`- NotifyPropertyChanged("DirectorySortDirection");`
`197`		`- NotifyPropertyChanged("IsSortedAscending");`
`198`		`- NotifyPropertyChanged("IsSortedDescending");`
`199`		`- OrderFiles();`
`200`		`- }`
`201`		`- }`
	`173`	`+ NotifyPropertyChanged("IsSortedAscending");`
	`174`	`+ NotifyPropertyChanged("IsSortedDescending");`
	`175`	`+ OrderFiles();`
`202`	`176`	`}`
`203`	`177`
`204`	`178`	`public bool IsSortedByName`
`205`	`179`	`{`
`206`		`- get => DirectorySortOption == SortOption.Name;`
	`180`	`+ get => AppSettings.DirectorySortOption == SortOption.Name;`
`207`	`181`	`set`
`208`	`182`	`{`
`209`	`183`	`if (value)`
`210`	`184`	`{`
`211`		`- DirectorySortOption = SortOption.Name;`
	`185`	`+ AppSettings.DirectorySortOption = SortOption.Name;`
`212`	`186`	`NotifyPropertyChanged("IsSortedByName");`
`213`		`- NotifyPropertyChanged("DirectorySortOption");`
`214`	`187`	`}`
`215`	`188`	`}`
`216`	`189`	`}`
`217`	`190`
`218`	`191`	`public bool IsSortedByDate`
`219`	`192`	`{`
`220`		`- get => DirectorySortOption == SortOption.DateModified;`
	`193`	`+ get => AppSettings.DirectorySortOption == SortOption.DateModified;`
`221`	`194`	`set`
`222`	`195`	`{`
`223`	`196`	`if (value)`
`224`	`197`	`{`
`225`		`- DirectorySortOption = SortOption.DateModified;`
	`198`	`+ AppSettings.DirectorySortOption = SortOption.DateModified;`
`226`	`199`	`NotifyPropertyChanged("IsSortedByDate");`
`227`		`- NotifyPropertyChanged("DirectorySortOption");`
`228`	`200`	`}`
`229`	`201`	`}`
`230`	`202`	`}`
`231`	`203`
`232`	`204`	`public bool IsSortedByType`
`233`	`205`	`{`
`234`		`- get => DirectorySortOption == SortOption.FileType;`
	`206`	`+ get => AppSettings.DirectorySortOption == SortOption.FileType;`
`235`	`207`	`set`
`236`	`208`	`{`
`237`	`209`	`if (value)`
`238`	`210`	`{`
`239`		`- DirectorySortOption = SortOption.FileType;`
	`211`	`+ AppSettings.DirectorySortOption = SortOption.FileType;`
`240`	`212`	`NotifyPropertyChanged("IsSortedByType");`
`241`		`- NotifyPropertyChanged("DirectorySortOption");`
`242`	`213`	`}`
`243`	`214`	`}`
`244`	`215`	`}`
`245`	`216`
`246`	`217`	`public bool IsSortedBySize`
`247`	`218`	`{`
`248`		`- get => DirectorySortOption == SortOption.Size;`
	`219`	`+ get => AppSettings.DirectorySortOption == SortOption.Size;`
`249`	`220`	`set`
`250`	`221`	`{`
`251`	`222`	`if (value)`
`252`	`223`	`{`
`253`		`- DirectorySortOption = SortOption.Size;`
	`224`	`+ AppSettings.DirectorySortOption = SortOption.Size;`
`254`	`225`	`NotifyPropertyChanged("IsSortedBySize");`
`255`		`- NotifyPropertyChanged("DirectorySortOption");`
`256`	`226`	`}`
`257`	`227`	`}`
`258`	`228`	`}`
`259`	`229`
`260`	`230`	`public bool IsSortedAscending`
`261`	`231`	`{`
`262`		`- get => DirectorySortDirection == SortDirection.Ascending;`
	`232`	`+ get => AppSettings.DirectorySortDirection == SortDirection.Ascending;`
`263`	`233`	`set`
`264`	`234`	`{`
`265`		`- DirectorySortDirection = value ? SortDirection.Ascending : SortDirection.Descending;`
	`235`	`+ AppSettings.DirectorySortDirection = value ? SortDirection.Ascending : SortDirection.Descending;`
`266`	`236`	`NotifyPropertyChanged("IsSortedAscending");`
`267`	`237`	`NotifyPropertyChanged("IsSortedDescending");`
`268`		`- NotifyPropertyChanged("DirectorySortDirection");`
`269`	`238`	`}`
`270`	`239`	`}`
`271`	`240`
`@@ -274,10 +243,9 @@ public bool IsSortedDescending`
`274`	`243`	`get => !IsSortedAscending;`
`275`	`244`	`set`
`276`	`245`	`{`
`277`		`- DirectorySortDirection = value ? SortDirection.Descending : SortDirection.Ascending;`
	`246`	`+ AppSettings.DirectorySortDirection = value ? SortDirection.Descending : SortDirection.Ascending;`
`278`	`247`	`NotifyPropertyChanged("IsSortedAscending");`
`279`	`248`	`NotifyPropertyChanged("IsSortedDescending");`
`280`		`- NotifyPropertyChanged("DirectorySortDirection");`
`281`	`249`	`}`
`282`	`250`	`}`
`283`	`251`
`@@ -393,7 +361,7 @@ public void OrderFiles()`
`393`	`361`	`static object orderByNameFunc(ListedItem item) => item.ItemName;`
`394`	`362`	`Func<ListedItem, object> orderFunc = orderByNameFunc;`
`395`	`363`	`NaturalStringComparer naturalStringComparer = new NaturalStringComparer();`
`396`		`- switch (DirectorySortOption)`
	`364`	`+ switch (AppSettings.DirectorySortOption)`
`397`	`365`	`{`
`398`	`366`	`case SortOption.Name:`
`399`	`367`	`orderFunc = orderByNameFunc;`
`@@ -418,35 +386,35 @@ public void OrderFiles()`
`418`	`386`	`IOrderedEnumerable<ListedItem> ordered;`
`419`	`387`	`List<ListedItem> orderedList;`
`420`	`388`
`421`		`- if (DirectorySortDirection == SortDirection.Ascending)`
	`389`	`+ if (AppSettings.DirectorySortDirection == SortDirection.Ascending)`
`422`	`390`	`{`
`423`		`- if (DirectorySortOption == SortOption.Name)`
	`391`	`+ if (AppSettings.DirectorySortOption == SortOption.Name)`
`424`	`392`	`ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenBy(orderFunc, naturalStringComparer);`
`425`	`393`	`else`
`426`	`394`	`ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenBy(orderFunc);`
`427`	`395`	`}`
`428`	`396`	`else`
`429`	`397`	`{`
`430`		`- if (DirectorySortOption == SortOption.FileType)`
	`398`	`+ if (AppSettings.DirectorySortOption == SortOption.FileType)`
`431`	`399`	`{`
`432`		`- if (DirectorySortOption == SortOption.Name)`
	`400`	`+ if (AppSettings.DirectorySortOption == SortOption.Name)`
`433`	`401`	`ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenByDescending(orderFunc, naturalStringComparer);`
`434`	`402`	`else`
`435`	`403`	`ordered = _filesAndFolders.OrderBy(folderThenFileAsync).ThenByDescending(orderFunc);`
`436`	`404`	`}`
`437`	`405`	`else`
`438`	`406`	`{`
`439`		`- if (DirectorySortOption == SortOption.Name)`
	`407`	`+ if (AppSettings.DirectorySortOption == SortOption.Name)`
`440`	`408`	`ordered = _filesAndFolders.OrderByDescending(folderThenFileAsync).ThenByDescending(orderFunc, naturalStringComparer);`
`441`	`409`	`else`
`442`	`410`	`ordered = _filesAndFolders.OrderByDescending(folderThenFileAsync).ThenByDescending(orderFunc);`
`443`	`411`	`}`
`444`	`412`	`}`
`445`	`413`
`446`	`414`	`// Further order by name if applicable`
`447`		`- if (DirectorySortOption != SortOption.Name)`
	`415`	`+ if (AppSettings.DirectorySortOption != SortOption.Name)`
`448`	`416`	`{`
`449`		`- if (DirectorySortDirection == SortDirection.Ascending)`
	`417`	`+ if (AppSettings.DirectorySortDirection == SortDirection.Ascending)`
`450`	`418`	`ordered = ordered.ThenBy(orderByNameFunc, naturalStringComparer);`
`451`	`419`	`else`
`452`	`420`	`ordered = ordered.ThenByDescending(orderByNameFunc, naturalStringComparer);`
`@@ -1480,4 +1448,4 @@ public void Dispose()`
`1480`	`1448`	`CloseWatcher();`
`1481`	`1449`	`}`
`1482`	`1450`	`}`
`1483`		`-}`
	`1451`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -34,23 +34,23 @@ public DataGridColumn SortedColumn`
`34`	`34`	`set`
`35`	`35`	`{`
`36`	`36`	`if (value == nameColumn)`
`37`		`- App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.Name;`
	`37`	`+ AppSettings.DirectorySortOption = SortOption.Name;`
`38`	`38`	`else if (value == dateColumn)`
`39`		`- App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.DateModified;`
	`39`	`+ AppSettings.DirectorySortOption = SortOption.DateModified;`
`40`	`40`	`else if (value == typeColumn)`
`41`		`- App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.FileType;`
	`41`	`+ AppSettings.DirectorySortOption = SortOption.FileType;`
`42`	`42`	`else if (value == sizeColumn)`
`43`		`- App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.Size;`
	`43`	`+ AppSettings.DirectorySortOption = SortOption.Size;`
`44`	`44`	`else`
`45`		`- App.CurrentInstance.FilesystemViewModel.DirectorySortOption = SortOption.Name;`
	`45`	`+ AppSettings.DirectorySortOption = SortOption.Name;`
`46`	`46`
`47`	`47`	`if (value != _sortedColumn)`
`48`	`48`	`{`
`49`	`49`	`// Remove arrow on previous sorted column`
`50`	`50`	`if (_sortedColumn != null)`
`51`	`51`	`_sortedColumn.SortDirection = null;`
`52`	`52`	`}`
`53`		`- value.SortDirection = App.CurrentInstance.FilesystemViewModel.DirectorySortDirection == SortDirection.Ascending ? DataGridSortDirection.Ascending : DataGridSortDirection.Descending;`
	`53`	`+ value.SortDirection = AppSettings.DirectorySortDirection == SortDirection.Ascending ? DataGridSortDirection.Ascending : DataGridSortDirection.Descending;`
`54`	`54`	`_sortedColumn = value;`
`55`	`55`	`}`
`56`	`56`	`}`
`@@ -59,7 +59,7 @@ public GenericFileBrowser()`
`59`	`59`	`{`
`60`	`60`	`InitializeComponent();`
`61`	`61`	`base.BaseLayoutItemContextFlyout = this.BaseLayoutItemContextFlyout;`
`62`		`- switch (App.CurrentInstance.FilesystemViewModel.DirectorySortOption)`
	`62`	`+ switch (AppSettings.DirectorySortOption)`
`63`	`63`	`{`
`64`	`64`	`case SortOption.Name:`
`65`	`65`	`SortedColumn = nameColumn;`
`@@ -192,7 +192,7 @@ private async void ViewModel_PropertyChanged(object sender, PropertyChangedEvent`
`192`	`192`	`{`
`193`	`193`	`if (e.PropertyName == "DirectorySortOption")`
`194`	`194`	`{`
`195`		`- switch (App.CurrentInstance.FilesystemViewModel.DirectorySortOption)`
	`195`	`+ switch (AppSettings.DirectorySortOption)`
`196`	`196`	`{`
`197`	`197`	`case SortOption.Name:`
`198`	`198`	`SortedColumn = nameColumn;`