Fixed folders collapsing on each lost focus

PixiEditor/Helpers/Converters/LayersToStructuredLayersConverter.cs

@@ -22,18 +22,10 @@ namespace PixiEditor.Helpers.Converters
 
         public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
         {
-            //if (value is ObservableCollection<object> tree)
-            //{
-            //    List<Layer> layers = new ();
-            //    LayerStructure structure = new ();
-            //    foreach (var branchLayers in tree.Select(x => x.Children))
-            //    {
-            //        //layers.AddRange(branchLayers);
-            //        //structure.Items.Add(new GuidStructureItem(new ObservableCollection<Guid>(branchLayers.Select(x => x.LayerGuid))));
-            //    }
+            if (value is ObservableCollection<object> tree)
+            {
 
-            //    return new object[] { layers, structure };
-            //}
+            }
 
             throw new ArgumentException("Value is not a StructuredLayerTree");
         }

PixiEditor/Models/Layers/GuidStructureItem.cs

@@ -7,6 +7,8 @@ namespace PixiEditor.Models.Layers
 {
     public class GuidStructureItem : NotifyableObject
     {
+        public Guid FolderGuid { get; init; }
+
         private string name;
 
         public string Name
@@ -23,11 +25,24 @@ namespace PixiEditor.Models.Layers
 
         public ObservableCollection<GuidStructureItem> Subfolders { get; set; }
 
+        private bool isExpanded;
+
+        public bool IsExpanded
+        {
+            get => isExpanded;
+            set
+            {
+                isExpanded = value;
+                RaisePropertyChanged(nameof(IsExpanded));
+            }
+        }
+
         public GuidStructureItem(string name, IEnumerable<Guid> children, IEnumerable<GuidStructureItem> subfolders)
         {
             Name = name;
             LayerGuids = new ObservableCollection<Guid>(children);
             Subfolders = new ObservableCollection<GuidStructureItem>(subfolders);
+            FolderGuid = Guid.NewGuid();
         }
 
         public GuidStructureItem(string name)
@@ -35,6 +50,7 @@ namespace PixiEditor.Models.Layers
             Name = name;
             LayerGuids = new ObservableCollection<Guid>();
             Subfolders = new ObservableCollection<GuidStructureItem>();
+            FolderGuid = Guid.NewGuid();
         }
     }
 }

PixiEditor/Models/Layers/LayerFolder.cs

@@ -1,13 +1,17 @@
-using System.Collections;
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using PixiEditor.Helpers;
+using PixiEditor.ViewModels;
 
 namespace PixiEditor.Models.Layers
 {
     public class LayerFolder : NotifyableObject
     {
+        public Guid FolderGuid { get; init; }
+
         public ObservableCollection<Layer> Layers { get; set; } = new ObservableCollection<Layer>();
 
         public ObservableCollection<LayerFolder> Subfolders { get; set; } = new ObservableCollection<LayerFolder>();
@@ -26,11 +30,37 @@ namespace PixiEditor.Models.Layers
             }
         }
 
+        private bool isExpanded = false;
+
+        public bool IsExpanded
+        {
+            get => isExpanded;
+            set
+            {
+                isExpanded = value;
+                UpdateIsExpandedInDocument(value);
+                RaisePropertyChanged(nameof(IsExpanded));
+            }
+        }
+
+        private void UpdateIsExpandedInDocument(bool value)
+        {
+            var folder = ViewModelMain.Current.BitmapManager.ActiveDocument.LayerStructure.GetFolderByGuid(FolderGuid);
+            if(folder != null)
+            {
+                folder.IsExpanded = value;
+            }
+        }
+
         public LayerFolder(IEnumerable<Layer> layers, IEnumerable<LayerFolder> subfolders, string name)
+            : this(layers, subfolders, name, Guid.NewGuid()) { }
+
+        public LayerFolder(IEnumerable<Layer> layers, IEnumerable<LayerFolder> subfolders, string name, Guid guid)
         {
             Layers = new ObservableCollection<Layer>(layers);
             Subfolders = new ObservableCollection<LayerFolder>(subfolders);
             Name = name;
+            FolderGuid = guid;
         }
     }
 }

PixiEditor/Models/Layers/LayerStructure.cs

@@ -1,4 +1,6 @@
-using System.Collections.ObjectModel;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 
 namespace PixiEditor.Models.Layers
 {
@@ -6,6 +8,29 @@ namespace PixiEditor.Models.Layers
     {
         public ObservableCollection<GuidStructureItem> Folders { get; set; }
 
+        public GuidStructureItem GetFolderByGuid(Guid folderGuid)
+        {
+            return GetFolderByGuid(folderGuid, Folders);
+        }
+
+        private GuidStructureItem GetFolderByGuid(Guid folderGuid, IEnumerable<GuidStructureItem> folders)
+        {
+            foreach (var folder in folders)
+            {
+                if (folder.FolderGuid == folderGuid)
+                {
+                    return folder;
+                }
+
+                if (folder.Subfolders.Count > 0)
+                {
+                    return GetFolderByGuid(folderGuid, folder.Subfolders);
+                }
+            }
+
+            return null;
+        }
+
         public LayerStructure(ObservableCollection<GuidStructureItem> items)
         {
             Folders = items;

PixiEditor/Models/Layers/StructuredLayerTree.cs

@@ -54,7 +54,10 @@ namespace PixiEditor.Models.Layers
                 subFolders = ParseFolders(structureItem.Subfolders, layers);
             }
 
-            LayerFolder folder = new (structureItemLayers, subFolders, structureItem.Name);
+            LayerFolder folder = new (structureItemLayers, subFolders, structureItem.Name, structureItem.FolderGuid)
+            {
+                IsExpanded = structureItem.IsExpanded
+            };
             return folder;
         }
     }

PixiEditor/Styles/TreeViewStyle.xaml

@@ -6,6 +6,10 @@
         <Setter Property="BorderThickness" Value="0"/>
     </Style>
 
+    <Style TargetType="{x:Type TreeViewItem}">
+        <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
+    </Style>
+
     <Style x:Key="TreeViewItemFocusVisual">
         <Setter Property="Control.Template">
             <Setter.Value>
@@ -17,8 +21,6 @@
     </Style>
 
 
-
-
     <SolidColorBrush x:Key="TreeViewItem.TreeArrow.Static.Checked.Fill" Color="#FF595959"/>
     <SolidColorBrush x:Key="TreeViewItem.TreeArrow.Static.Checked.Stroke" Color="#FF262626"/>
     <SolidColorBrush x:Key="TreeViewItem.TreeArrow.MouseOver.Stroke" Color="#FF27C7F7"/>

PixiEditor/ViewModels/SubViewModels/Main/FileViewModel.cs

@@ -126,7 +126,8 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                         Owner.BitmapManager.ActiveDocument.Layers[3].LayerGuid,
                         Owner.BitmapManager.ActiveDocument.Layers[4].LayerGuid
                     },  Array.Empty<GuidStructureItem>()
-                    )}));
+                    )})
+                { IsExpanded = true});
         }
 
         /// <summary>

PixiEditor/Views/UserControls/LayerFolder.xaml.cs

@@ -1,17 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Data;
-using System.Windows.Documents;
 using System.Windows.Input;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-using System.Windows.Navigation;
-using System.Windows.Shapes;
+using PixiEditor.ViewModels.SubViewModels.Main;
 
 namespace PixiEditor.Views.UserControls
 {
@@ -20,6 +12,25 @@ namespace PixiEditor.Views.UserControls
     /// </summary>
     public partial class LayerFolder : UserControl
     {
+        public Guid FolderGuid
+        {
+            get { return (Guid)GetValue(FolderGuidProperty); }
+            set { SetValue(FolderGuidProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty FolderGuidProperty =
+            DependencyProperty.Register("FolderGuid", typeof(Guid), typeof(LayerFolder), new PropertyMetadata(Guid.NewGuid()));
+
+        public LayersViewModel LayersViewModel
+        {
+            get { return (LayersViewModel)GetValue(LayersViewModelProperty); }
+            set { SetValue(LayersViewModelProperty, value); }
+        }
+
+        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty LayersViewModelProperty =
+            DependencyProperty.Register("LayersViewModel", typeof(LayersViewModel), typeof(LayerFolder), new PropertyMetadata(default(LayersViewModel)));
 
         public string FolderName
         {

PixiEditor/Views/UserControls/LayersManager.xaml

@@ -45,31 +45,16 @@
             <TreeView ItemsSource="{Binding LayerTreeRoot, ElementName=layersManager}">
                 <TreeView.Resources>
                     <HierarchicalDataTemplate DataType="{x:Type layers:LayerFolder}" ItemsSource="{Binding Items}">
-                        <local:LayerFolder FolderName="{Binding Name}" />
+                        <local:LayerFolder FolderName="{Binding Name}" LayersViewModel="{Binding LayerCommandsViewModel, ElementName=layersManager}" FolderGuid="{Binding FolderGuid}" />
                     </HierarchicalDataTemplate>
                     <DataTemplate DataType="{x:Type layers:Layer}">
-                        <local:LayerStructureItemContainer 
+                        <local:LayerStructureItemContainer                             
                             MouseMove="LayerStructureItemContainer_MouseMove" 
                             ContainerIndex="{Binding Converter={StaticResource IndexOfConverter}}"
                             Layer="{Binding}" LayerCommandsViewModel="{Binding LayerCommandsViewModel, ElementName=layersManager}"/>
                     </DataTemplate>
                 </TreeView.Resources>
             </TreeView>
-            <!--<ItemsControl DataContext="{Binding ElementName=layersManager}"
-                          x:Name="layersItemsControl" AlternationCount="9999" ItemsSource="{Binding StructuredLayers}">
-                <ItemsControl.ItemsPanel>
-                    <ItemsPanelTemplate>
-                        <ui:ReversedOrderStackPanel Orientation="Vertical" />
-                    </ItemsPanelTemplate>
-                </ItemsControl.ItemsPanel>
-                <ItemsControl.ItemTemplate>
-                    <DataTemplate>
-                        <local:LayerStructureItemContainer MouseMove="LayerStructureItemContainer_MouseMove"
-                            Item="{Binding}" ContainerIndex="{Binding Path=(ItemsControl.AlternationIndex), RelativeSource={RelativeSource TemplatedParent}}"
-                                                           LayerCommandsViewModel="{Binding LayerCommandsViewModel, ElementName=layersManager}"/>
-                    </DataTemplate>
-                </ItemsControl.ItemTemplate>
-            </ItemsControl>-->
         </ScrollViewer>
     </Grid>
 </UserControl>

PixiEditor/Views/UserControls/LayersManager.xaml.cs

@@ -10,7 +10,6 @@ namespace PixiEditor.Views.UserControls
     /// </summary>
     public partial class LayersManager : UserControl
     {
-
         public ObservableCollection<object> LayerTreeRoot
         {
             get { return (ObservableCollection<object>)GetValue(LayerTreeRootProperty); }