Fixed a lot of bugs

PixiEditor/Models/DataHolders/Document/Document.Constructors.cs

@@ -1,5 +1,7 @@
 using PixiEditor.Models.Controllers;
+using PixiEditor.Models.Layers;
 using PixiEditor.ViewModels;
+using System.Linq;
 
 namespace PixiEditor.Models.DataHolders
 {
@@ -25,9 +27,15 @@ namespace PixiEditor.Models.DataHolders
             LayerStructure.LayerStructureChanged += LayerStructure_LayerStructureChanged;
         }
 
-        private void LayerStructure_LayerStructureChanged(object sender, System.EventArgs e)
+        private void LayerStructure_LayerStructureChanged(object sender, LayerStructureChangedEventArgs e)
         {
             RaisePropertyChanged(nameof(LayerStructure));
+            foreach (var layerGuid in e.AffectedLayerGuids)
+            {
+                Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
+                layer.RaisePropertyChange(nameof(layer.IsVisible));
+                layer.RaisePropertyChange(nameof(layer.Opacity));
+            }
         }
 
         private void Groups_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)

PixiEditor/Models/DataHolders/Document/Document.Layers.cs

@@ -78,7 +78,7 @@ namespace PixiEditor.Models.DataHolders
             }
 
             ActiveLayerGuid = Layers[index].LayerGuid;
-            ActiveLayer!.IsActive = true;
+            ActiveLayer.IsActive = true;
             LayersChanged?.Invoke(this, new LayersChangedEventArgs(ActiveLayerGuid, LayerAction.SetActive));
         }
 
@@ -519,7 +519,7 @@ namespace PixiEditor.Models.DataHolders
 
             if (Layers.Count == 0)
             {
-                Layer layer = new("Base Layer");
+                Layer layer = new("Base Layer", 0, 0) { MaxHeight = Height, MaxWidth = Width };
                 Layers.Add(layer);
                 undoAction = (Layer[] layers, UndoLayer[] undoData) =>
                 {
@@ -626,34 +626,11 @@ namespace PixiEditor.Models.DataHolders
 
             LayerStructure.MoveGroup(groupGuid, newIndex);
 
-            ReassignParent(group, referenceLayerGroup);
+            LayerStructure.ReassignParent(group, referenceLayerGroup);
 
             LayerStructure.PostMoveReassignBounds(new GroupData(group?.Parent?.GroupGuid), new GroupData(group?.GroupGuid));
         }
 
-        private void ReassignParent(GuidStructureItem folder, GuidStructureItem referenceLayerFolder)
-        {
-            folder.Parent?.Subgroups.Remove(folder);
-            if (LayerStructure.Groups.Contains(folder))
-            {
-                LayerStructure.Groups.Remove(folder);
-            }
-
-            if (referenceLayerFolder == null)
-            {
-                if (!LayerStructure.Groups.Contains(folder))
-                {
-                    LayerStructure.Groups.Add(folder);
-                    folder.Parent = null;
-                }
-            }
-            else
-            {
-                referenceLayerFolder.Subgroups.Add(folder);
-                folder.Parent = referenceLayerFolder;
-            }
-        }
-
         private int CalculateNewIndex(int layerIndex, bool above, int oldIndex)
         {
             int newIndex = layerIndex;

PixiEditor/Models/Layers/GroupChangedEventArgs.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+
+namespace PixiEditor.Models.Layers
+{
+    public class GroupChangedEventArgs : EventArgs
+    {
+        public List<GuidStructureItem> GroupsAffected { get; set; }
+
+        public GroupChangedEventArgs(List<GuidStructureItem> groupsAffected)
+        {
+            GroupsAffected = groupsAffected;
+        }
+    }
+}

PixiEditor/Models/Layers/GuidStructureItem.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+using System.Linq;
 using PixiEditor.Helpers;
 
 namespace PixiEditor.Models.Layers
@@ -9,7 +10,7 @@ namespace PixiEditor.Models.Layers
     [DebuggerDisplay("{Name} - {GroupGuid}")]
     public class GuidStructureItem : NotifyableObject, ICloneable
     {
-        public event EventHandler GroupsChanged;
+        public event EventHandler<GroupChangedEventArgs> GroupsChanged;
 
         public Guid GroupGuid { get; init; }
 
@@ -149,8 +150,9 @@ namespace PixiEditor.Models.Layers
 
         private void Subgroups_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
         {
-            GroupsChanged?.Invoke(this, EventArgs.Empty);
-            Parent?.GroupsChanged?.Invoke(this, EventArgs.Empty);
+            var args = new GroupChangedEventArgs(e.NewItems != null ? e.NewItems.Cast<GuidStructureItem>().ToList() : new List<GuidStructureItem>());
+            GroupsChanged?.Invoke(this, args);
+            Parent?.GroupsChanged?.Invoke(this, args);
         }
     }
 }

PixiEditor/Models/Layers/LayerStructure.cs

@@ -17,7 +17,7 @@ namespace PixiEditor.Models.Layers
     /// </summary>
     public class LayerStructure
     {
-        public event EventHandler LayerStructureChanged;
+        public event EventHandler<LayerStructureChangedEventArgs> LayerStructureChanged;
 
         public ObservableCollection<GuidStructureItem> Groups { get; set; }
 
@@ -136,7 +136,7 @@ namespace PixiEditor.Models.Layers
 
             group.GroupsChanged += Group_GroupsChanged;
 
-            LayerStructureChanged?.Invoke(this, EventArgs.Empty);
+            LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(childLayer));
             return group;
         }
 
@@ -173,7 +173,7 @@ namespace PixiEditor.Models.Layers
 
             MoveLayersInGroup(layersInOrder, difference, reverseOrder);
 
-            LayerStructureChanged?.Invoke(this, EventArgs.Empty);
+            LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layersInOrder));
         }
 
         /// <summary>
@@ -218,12 +218,7 @@ namespace PixiEditor.Models.Layers
         {
             var layerParent = GetGroupByLayer(layerGuid);
 
-            if (layerParent == parent)
-            {
-                return true;
-            }
-
-            return IsChildOf(layerParent, parent);
+            return layerParent == parent ? true : IsChildOf(layerParent, parent);
         }
 
         /// <summary>
@@ -276,6 +271,36 @@ namespace PixiEditor.Models.Layers
             AssignParent(layer, parent.HasValue ? GetGroupByGuid(parent) : null);
         }
 
+        /// <summary>
+        /// Assigns group new parent.
+        /// </summary>
+        /// <param name="group">Group to assign parent</param>
+        /// <param name="referenceLayerGroup">Parent of group.</param>
+        public void ReassignParent(GuidStructureItem group, GuidStructureItem referenceLayerGroup)
+        {
+            group.Parent?.Subgroups.Remove(group);
+            if (Groups.Contains(group))
+            {
+                Groups.Remove(group);
+            }
+
+            if (referenceLayerGroup == null)
+            {
+                if (!Groups.Contains(group))
+                {
+                    Groups.Add(group);
+                    group.Parent = null;
+                }
+            }
+            else
+            {
+                referenceLayerGroup.Subgroups.Add(group);
+                group.Parent = referenceLayerGroup;
+            }
+
+            LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(GetGroupLayerGuids(group)));
+        }
+
         /// <summary>
         /// Gets all layers inside group, including nested groups.
         /// </summary>
@@ -356,6 +381,7 @@ namespace PixiEditor.Models.Layers
                 {
                     ApplyBoundsToParents(parentOfParent, parentGroup, oldStart, oldEnd);
                 }
+                LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layer));
             }
         }
 
@@ -422,6 +448,19 @@ namespace PixiEditor.Models.Layers
                 {
                     ApplyBoundsToParents(parentGroup.Parent, parentGroup, oldStart, oldEnd);
                 }
+
+                var args = new LayerStructureChangedEventArgs(layerGuid);
+
+                if (topBoundLayer.HasValue)
+                {
+                    args.AffectedLayerGuids.Add(topBoundLayer.Value);
+                }
+                if (bottomBoundLayer.HasValue)
+                {
+                    args.AffectedLayerGuids.Add(bottomBoundLayer.Value);
+                }
+
+                LayerStructureChanged?.Invoke(this, args);
             }
         }
 
@@ -470,17 +509,22 @@ namespace PixiEditor.Models.Layers
 
             PostMoveReassignBounds(parent, layer);
 
-            LayerStructureChanged?.Invoke(this, EventArgs.Empty);
+            LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layer));
         }
 
-        private void Group_GroupsChanged(object sender, EventArgs e)
+        private void Group_GroupsChanged(object sender, GroupChangedEventArgs e)
         {
-            LayerStructureChanged?.Invoke(this, EventArgs.Empty);
+            List<Guid> layersAffected = new List<Guid>();
+            e.GroupsAffected.ForEach(x => layersAffected.AddRange(GetGroupLayerGuids(x)));
+            LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layersAffected));
         }
 
         private void RemoveGroup(GuidStructureItem parentFolder)
         {
             parentFolder.GroupsChanged -= Group_GroupsChanged;
+
+            var layerGuids = GetGroupLayerGuids(parentFolder);
+
             if (parentFolder.Parent == null)
             {
                 Groups.Remove(parentFolder);
@@ -490,7 +534,8 @@ namespace PixiEditor.Models.Layers
                 parentFolder.Parent.Subgroups.Remove(parentFolder);
             }
 
-            LayerStructureChanged?.Invoke(this, EventArgs.Empty);
+            LayerStructureChanged?.Invoke(this, new LayerStructureChangedEventArgs(layerGuids));
+
         }
 
         private void ApplyBoundsToParents(GuidStructureItem parent, GuidStructureItem group, Guid? oldStart, Guid? oldEnd)
@@ -620,4 +665,4 @@ namespace PixiEditor.Models.Layers
             Owner = owner;
         }
     }
-}
+}

PixiEditor/Models/Layers/LayerStructureChangedEventArgs.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+
+namespace PixiEditor.Models.Layers
+{
+    public class LayerStructureChangedEventArgs : EventArgs
+    {
+        public List<Guid> AffectedLayerGuids { get; set; }
+
+        public LayerStructureChangedEventArgs(List<Guid> affectedLayerGuids)
+        {
+            AffectedLayerGuids = affectedLayerGuids;
+        }
+
+        public LayerStructureChangedEventArgs(Guid affectedLayerGuid)
+        {
+            AffectedLayerGuids = new List<Guid>() { affectedLayerGuid };
+        }
+    }
+}

PixiEditor/Views/MainWindow.xaml

@@ -317,8 +317,9 @@
                                     <LayoutAnchorable ContentId="navigation" Title="Navigation" 
                                                       CanHide="True" CanAutoHide="False"
                                                       CanDockAsTabbedDocument="False" CanFloat="True">
-                                        <usercontrols:PreviewWindow Document="{Binding BitmapManager.ActiveDocument}"
-                                                                    PrimaryColor="{Binding ColorsSubViewModel.PrimaryColor, Mode=TwoWay}"/>
+                                        <usercontrols:PreviewWindow 
+                                            Document="{Binding BitmapManager.ActiveDocument}"
+                                            PrimaryColor="{Binding ColorsSubViewModel.PrimaryColor, Mode=TwoWay}"/>
                                     </LayoutAnchorable>
                                 </LayoutAnchorablePane>
                             </LayoutAnchorablePaneGroup>

PixiEditor/Views/UserControls/LayersManager.xaml

@@ -66,7 +66,7 @@
                 </TreeView.ItemsPanel>
                 <TreeView.Resources>
                     <HierarchicalDataTemplate DataType="{x:Type layers:LayerGroup}" ItemsSource="{Binding Items}">
-                    <local:LayerGroupControl GroupName="{Binding Name}" 
+                        <local:LayerGroupControl GroupName="{Binding Name}" MouseDown="SelectActiveItem"
                                              IsVisibleUndoTriggerable="{Binding StructureData.IsVisible}" 
                                              GroupOpacity="{Binding StructureData.Opacity}"
                                              LayersViewModel="{Binding LayerCommandsViewModel, ElementName=layersManager}" 
@@ -75,7 +75,8 @@
                                              MouseMove="LayerGroup_MouseMove"/>
                     </HierarchicalDataTemplate>
                     <DataTemplate DataType="{x:Type layers:Layer}">
-                        <local:LayerStructureItemContainer                             
+                        <local:LayerStructureItemContainer    
+                            MouseDown="SelectActiveItem"
                             MouseMove="LayerStructureItemContainer_MouseMove" 
                             ContainerIndex="{Binding Converter={StaticResource IndexOfConverter}}"
                             Layer="{Binding}" LayerCommandsViewModel="{Binding LayerCommandsViewModel, ElementName=layersManager}"/>

PixiEditor/Views/UserControls/LayersManager.xaml.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.ObjectModel;
+using System.Linq;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Media;
@@ -29,7 +30,7 @@ namespace PixiEditor.Views.UserControls
                 "LayerTreeRoot",
                 typeof(ObservableCollection<object>),
                 typeof(LayersManager),
-                new PropertyMetadata(default(ObservableCollection<object>), ItemsChanged));
+                new PropertyMetadata(default(ObservableCollection<object>)));
         public LayersViewModel LayerCommandsViewModel
         {
             get { return (LayersViewModel)GetValue(LayerCommandsViewModelProperty); }
@@ -38,141 +39,149 @@ namespace PixiEditor.Views.UserControls
 
         // Using a DependencyProperty as the backing store for LayerCommandsViewModel.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty LayerCommandsViewModelProperty =
-            DependencyProperty.Register("LayerCommandsViewModel", typeof(LayersViewModel), typeof(LayersManager), new PropertyMetadata(default(LayersViewModel)));
-
-        public bool OpacityInputEnabled
-        {
-            get { return (bool)GetValue(OpacityInputEnabledProperty); }
-            set { SetValue(OpacityInputEnabledProperty, value); }
-        }
-
-        // Using a DependencyProperty as the backing store for OpacityInputEnabled.  This enables animation, styling, binding, etc...
-        public static readonly DependencyProperty OpacityInputEnabledProperty =
-            DependencyProperty.Register("OpacityInputEnabled", typeof(bool), typeof(LayersManager), new PropertyMetadata(false));
-
-        public LayersManager()
-        {
-            InitializeComponent();
+            DependencyProperty.Register("LayerCommandsViewModel", typeof(LayersViewModel), typeof(LayersManager), new PropertyMetadata(default(LayersViewModel), ViewModelChanged));
+
+        public bool OpacityInputEnabled
+        {
+            get { return (bool)GetValue(OpacityInputEnabledProperty); }
+            set { SetValue(OpacityInputEnabledProperty, value); }
         }
 
-        private static void ItemsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-        {
-            var items = (ObservableCollection<object>)e.NewValue;
-            LayersManager manager = (LayersManager)d;
-            var numberInput = manager.numberInput;
-            object item = manager.treeView.SelectedItem;
-            if (items != null && items.Count > 0 && (e.OldValue == null || ((ObservableCollection<object>)e.OldValue).Count == 0))
-            {
-                item = items[0];
-                manager.cachedItem = item;
+        // Using a DependencyProperty as the backing store for OpacityInputEnabled.  This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty OpacityInputEnabledProperty =
+            DependencyProperty.Register("OpacityInputEnabled", typeof(bool), typeof(LayersManager), new PropertyMetadata(false));
+
+        public LayersManager()
+        {
+            InitializeComponent();
+        }
+
+        private static void ViewModelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (e.NewValue is LayersViewModel vm)
+            {
+                LayersManager manager = (LayersManager)d;
+                vm.Owner.BitmapManager.AddPropertyChangedCallback(nameof(vm.Owner.BitmapManager.ActiveDocument), () =>
+                {
+                    var doc = vm.Owner.BitmapManager.ActiveDocument;
+                    if (doc != null)
+                    {
+                        doc.AddPropertyChangedCallback(nameof(doc.ActiveLayer), () =>
+                        {
+                            manager.cachedItem = doc.ActiveLayer;
+                            SetInputOpacity(manager.cachedItem, manager.numberInput);
+                        });
+                    }
+                });
             }
+        }
 
-            SetInputOpacity(item, numberInput);
-        }
-
-        private static void SetInputOpacity(object item, NumberInput numberInput)
-        {
-            if (item is Layer layer)
-            {
-                numberInput.Value = layer.Opacity * 100f;
-            }
-            else if (item is LayerGroup group)
-            {
-                numberInput.Value = group.StructureData.Opacity * 100f;
-            }
-        }
-
-        private void LayerStructureItemContainer_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
-        {
-            if (sender is LayerStructureItemContainer container && e.LeftButton == System.Windows.Input.MouseButtonState.Pressed)
-            {
-                DragDrop.DoDragDrop(container, container, DragDropEffects.Move);
-            }
-        }
-
-        private void HandleGroupOpacityChange(LayerGroup group, float value)
-        {
-            if (LayerCommandsViewModel.Owner?.BitmapManager?.ActiveDocument != null)
-            {
-                var doc = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument;
-
-                var processArgs = new object[] { group.StructureData.GroupGuid, value };
-                var reverseProcessArgs = new object[] { group.StructureData.GroupGuid, group.StructureData.Opacity };
-
-                ChangeGroupOpacityProcess(processArgs);
-
-                doc.UndoManager.AddUndoChange(
-                new Change(
-                    ChangeGroupOpacityProcess,
-                    reverseProcessArgs,
-                    ChangeGroupOpacityProcess,
-                    processArgs,
-                    $"Change {group.Name} opacity"), false);
-            }
-        }
-
-        private void ChangeGroupOpacityProcess(object[] processArgs)
-        {
-            if (processArgs.Length > 0 && processArgs[0] is Guid groupGuid && processArgs[1] is float opacity)
-            {
-                var structure = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument.LayerStructure;
-                var group = structure.GetGroupByGuid(groupGuid);
-                group.Opacity = opacity;
-                var layers = structure.GetGroupLayers(group);
+        private static void SetInputOpacity(object item, NumberInput numberInput)
+        {
+            if (item is Layer layer)
+            {
+                numberInput.Value = layer.Opacity * 100f;
+            }
+            else if (item is LayerGroup group)
+            {
+                numberInput.Value = group.StructureData.Opacity * 100f;
+            }
+            else if (item is LayerGroupControl groupControl)
+            {
+                numberInput.Value = groupControl.GroupData.Opacity * 100f;
+            }
+        }
+
+        private void LayerStructureItemContainer_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
+        {
+            if (sender is LayerStructureItemContainer container && e.LeftButton == System.Windows.Input.MouseButtonState.Pressed)
+            {
+                DragDrop.DoDragDrop(container, container, DragDropEffects.Move);
+            }
+        }
+
+        private void HandleGroupOpacityChange(GuidStructureItem group, float value)
+        {
+            if (LayerCommandsViewModel.Owner?.BitmapManager?.ActiveDocument != null)
+            {
+                var doc = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument;
+
+                var processArgs = new object[] { group.GroupGuid, value };
+                var reverseProcessArgs = new object[] { group.GroupGuid, group.Opacity };
+
+                ChangeGroupOpacityProcess(processArgs);
+
+                doc.UndoManager.AddUndoChange(
+                new Change(
+                    ChangeGroupOpacityProcess,
+                    reverseProcessArgs,
+                    ChangeGroupOpacityProcess,
+                    processArgs,
+                    $"Change {group.Name} opacity"), false);
+            }
+        }
+
+        private void ChangeGroupOpacityProcess(object[] processArgs)
+        {
+            if (processArgs.Length > 0 && processArgs[0] is Guid groupGuid && processArgs[1] is float opacity)
+            {
+                var structure = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument.LayerStructure;
+                var group = structure.GetGroupByGuid(groupGuid);
+                group.Opacity = opacity;
+                var layers = structure.GetGroupLayers(group);
                 layers.ForEach(x => x.Opacity = x.Opacity); // This might seems stupid, but it raises property changed, without setting any value. This is used to trigger converters that use group opacity
-                numberInput.Value = opacity * 100;
-            }
-        }
-
-        private void LayerGroup_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
-        {
-            if (sender is LayerGroupControl container && e.LeftButton == System.Windows.Input.MouseButtonState.Pressed)
-            {
-                DragDrop.DoDragDrop(container, container, DragDropEffects.Move);
-            }
-        }
-
-        private void NumberInput_LostFocus(object sender, RoutedEventArgs e)
-        {
-            float val = numberInput.Value / 100f;
-
-            object item = treeView.SelectedItem;
-
-            if (item == null && cachedItem != null)
-            {
-                item = cachedItem;
-            }
-
-            if (item is Layer layer)
-            {
-                float oldOpacity = layer.Opacity;
-                layer.OpacityUndoTriggerable = val;
-                UndoManager undoManager = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument.UndoManager;
-                undoManager.AddUndoChange(
-                    new Change(
-                        UpdateNumberInputLayerOpacityProcess,
-                        new object[] { oldOpacity },
-                        UpdateNumberInputLayerOpacityProcess,
-                        new object[] { val }));
-                undoManager.SquashUndoChanges(2);
-            }
-            else if (item is LayerGroup group)
-            {
-                HandleGroupOpacityChange(group, val);
-            }
-        }
-
+                numberInput.Value = opacity * 100;
+            }
+        }
+
+        private void LayerGroup_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
+        {
+            if (sender is LayerGroupControl container && e.LeftButton == System.Windows.Input.MouseButtonState.Pressed)
+            {
+                DragDrop.DoDragDrop(container, container, DragDropEffects.Move);
+            }
+        }
+
+        private void NumberInput_LostFocus(object sender, RoutedEventArgs e)
+        {
+            float val = numberInput.Value / 100f;
+
+            object item = cachedItem;
+
+            if (item is Layer layer)
+            {
+                float oldOpacity = layer.Opacity;
+                layer.OpacityUndoTriggerable = val;
+                UndoManager undoManager = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument.UndoManager;
+                undoManager.AddUndoChange(
+                    new Change(
+                        UpdateNumberInputLayerOpacityProcess,
+                        new object[] { oldOpacity },
+                        UpdateNumberInputLayerOpacityProcess,
+                        new object[] { val }));
+                undoManager.SquashUndoChanges(2);
+            }
+            else if (item is LayerGroup group)
+            {
+                HandleGroupOpacityChange(group.StructureData, val);
+            }
+            else if(item is LayerGroupControl groupControl)
+            {
+                HandleGroupOpacityChange(groupControl.GroupData, val);
+            }
+        }
+
         private void UpdateNumberInputLayerOpacityProcess(object[] args)
         {
             if (args.Length > 0 && args[0] is float opacity)
             {
                 numberInput.Value = opacity * 100;
             }
-        }
-
-        private void TreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
-        {
-            SetInputOpacity(treeView.SelectedItem, numberInput);
+        }
+
+        private void TreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
+        {
+            SetInputOpacity(cachedItem, numberInput);
         }
 
         private void TreeView_PreviewMouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
@@ -188,17 +197,17 @@ namespace PixiEditor.Views.UserControls
         }
 
         private void Grid_Drop(object sender, DragEventArgs e)
-        {
+        {
             dropBorder.BorderBrush = Brushes.Transparent;
-
-            if (e.Data.GetDataPresent(LayerGroupControl.LayerContainerDataName))
-            {
-                HandleLayerDrop(e.Data);
-            }
-
-            if (e.Data.GetDataPresent(LayerGroupControl.LayerGroupControlDataName))
-            {
-                HandleGroupControlDrop(e.Data);
+
+            if (e.Data.GetDataPresent(LayerGroupControl.LayerContainerDataName))
+            {
+                HandleLayerDrop(e.Data);
+            }
+
+            if (e.Data.GetDataPresent(LayerGroupControl.LayerGroupControlDataName))
+            {
+                HandleGroupControlDrop(e.Data);
             }
         }
 
@@ -229,5 +238,10 @@ namespace PixiEditor.Views.UserControls
         {
             ((Border)sender).BorderBrush = Brushes.Transparent;
         }
+
+        private void SelectActiveItem(object sender, System.Windows.Input.MouseButtonEventArgs e)
+        {
+            cachedItem = sender;
+        }
     }
 }

PixiEditor/Views/UserControls/PreviewWindow.xaml

@@ -34,7 +34,6 @@
                     <ItemsControl.ItemTemplate>
                         <DataTemplate>
                             <Image VerticalAlignment="Top" HorizontalAlignment="Left" Source="{Binding LayerBitmap}"
-                                               Visibility="{Binding IsVisible, Converter={StaticResource BoolToVisibilityConverter}}"
                                                RenderOptions.BitmapScalingMode="NearestNeighbor" Stretch="Uniform"
                                                Width="{Binding Width}" Height="{Binding Height}" Margin="{Binding Offset}">
                             <Image.Opacity>
@@ -43,6 +42,12 @@
                                         <Binding Path="Opacity"/>
                                     </MultiBinding>
                             </Image.Opacity>
+                                <Image.Visibility>
+                                    <MultiBinding Converter="{converters:FinalIsVisibleToVisiblityConverter}">
+                                        <Binding Path="."/>
+                                        <Binding Path="IsVisible"/>
+                                    </MultiBinding>
+                                </Image.Visibility>
                             </Image>
                         </DataTemplate>
                     </ItemsControl.ItemTemplate>