Merge pull request #288 from PixiEditor/quickfill

0.1.6.5-dev release

PixiEditor/Helpers/Behaviours/ClearFocusOnClickBehavior.cs

@@ -1,6 +1,6 @@
-using System.Windows;
+using PixiEditor.Models.Controllers.Shortcuts;
+using System.Windows;
 using System.Windows.Interactivity;
-using PixiEditor.Models.Controllers.Shortcuts;
 
 namespace PixiEditor.Helpers.Behaviours
 {
@@ -23,4 +23,4 @@ namespace PixiEditor.Helpers.Behaviours
             ShortcutController.BlockShortcutExecution = false;
         }
     }
-}
+}

PixiEditor/Helpers/Behaviours/TextBoxFocusBehavior.cs

@@ -3,27 +3,32 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Input;
 using System.Windows.Interactivity;
-using PixiEditor.Models.Controllers.Shortcuts;
 
 namespace PixiEditor.Helpers.Behaviours
 {
     internal class TextBoxFocusBehavior : Behavior<TextBox>
     {
         // Using a DependencyProperty as the backing store for FillSize.  This enables animation, styling, binding, etc...
-        public static readonly DependencyProperty FillSizeProperty =
+        public static readonly DependencyProperty SelectOnFocusProperty =
             DependencyProperty.Register(
-                "FillSize",
+                nameof(SelectOnFocus),
                 typeof(bool),
                 typeof(TextBoxFocusBehavior),
-                new PropertyMetadata(false));
+                new PropertyMetadata(true));
 
-        private string oldText; // Value of textbox before editing
-        private bool valueConverted; // This bool is used to avoid double convertion if enter is hitted
+        public static readonly DependencyProperty NextControlProperty =
+            DependencyProperty.Register(nameof(NextControl), typeof(FrameworkElement), typeof(TextBoxFocusBehavior));
 
-        public bool FillSize
+        public FrameworkElement NextControl
         {
-            get => (bool)GetValue(FillSizeProperty);
-            set => SetValue(FillSizeProperty, value);
+            get => (FrameworkElement)GetValue(NextControlProperty);
+            set => SetValue(NextControlProperty, value);
+        }
+
+        public bool SelectOnFocus
+        {
+            get => (bool)GetValue(SelectOnFocusProperty);
+            set => SetValue(SelectOnFocusProperty, value);
         }
 
         protected override void OnAttached()
@@ -32,7 +37,6 @@ namespace PixiEditor.Helpers.Behaviours
             AssociatedObject.GotKeyboardFocus += AssociatedObjectGotKeyboardFocus;
             AssociatedObject.GotMouseCapture += AssociatedObjectGotMouseCapture;
             AssociatedObject.PreviewMouseLeftButtonDown += AssociatedObjectPreviewMouseLeftButtonDown;
-            AssociatedObject.LostKeyboardFocus += AssociatedObject_LostKeyboardFocus;
             AssociatedObject.KeyUp += AssociatedObject_KeyUp;
         }
 
@@ -42,7 +46,6 @@ namespace PixiEditor.Helpers.Behaviours
             AssociatedObject.GotKeyboardFocus -= AssociatedObjectGotKeyboardFocus;
             AssociatedObject.GotMouseCapture -= AssociatedObjectGotMouseCapture;
             AssociatedObject.PreviewMouseLeftButtonDown -= AssociatedObjectPreviewMouseLeftButtonDown;
-            AssociatedObject.LostKeyboardFocus -= AssociatedObject_LostKeyboardFocus;
             AssociatedObject.KeyUp -= AssociatedObject_KeyUp;
         }
 
@@ -54,19 +57,26 @@ namespace PixiEditor.Helpers.Behaviours
                 return;
             }
 
-            ConvertValue();
             RemoveFocus();
         }
 
         private void RemoveFocus()
         {
+            DependencyObject scope = FocusManager.GetFocusScope(AssociatedObject);
+
+            if (NextControl != null)
+            {
+                FocusManager.SetFocusedElement(scope, NextControl);
+                return;
+            }
+
             FrameworkElement parent = (FrameworkElement)AssociatedObject.Parent;
+
             while (parent != null && parent is IInputElement element && !element.Focusable)
             {
                 parent = (FrameworkElement)parent.Parent;
             }
 
-            DependencyObject scope = FocusManager.GetFocusScope(AssociatedObject);
             FocusManager.SetFocusedElement(scope, parent);
         }
 
@@ -74,19 +84,16 @@ namespace PixiEditor.Helpers.Behaviours
             object sender,
             KeyboardFocusChangedEventArgs e)
         {
-            AssociatedObject.SelectAll();
-            if (FillSize)
-            {
-                valueConverted = false;
-                oldText = AssociatedObject.Text; // Sets old value when keyboard is focused on object
-            }
+            if (SelectOnFocus)
+                AssociatedObject.SelectAll();
         }
 
         private void AssociatedObjectGotMouseCapture(
             object sender,
             MouseEventArgs e)
         {
-            AssociatedObject.SelectAll();
+            if (SelectOnFocus)
+                AssociatedObject.SelectAll();
         }
 
         private void AssociatedObjectPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
@@ -97,34 +104,5 @@ namespace PixiEditor.Helpers.Behaviours
                 e.Handled = true;
             }
         }
-
-        private void AssociatedObject_LostKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
-        {
-            ConvertValue();
-        }
-
-        /// <summary>
-        ///     Converts number from textbox to format "number px" ex. "15 px".
-        /// </summary>
-        private void ConvertValue()
-        {
-            if (valueConverted || FillSize == false || AssociatedObject.Text == oldText)
-            {
-                return;
-            }
-
-            if (int.TryParse(Regex.Replace(AssociatedObject.Text, "\\p{L}", string.Empty).Trim(), out int result) && result > 0)
-            {
-                AssociatedObject.Text = $"{result} px";
-            }
-
-            // If text in textbox isn't number, set it to old value
-            else
-            {
-                AssociatedObject.Text = oldText;
-            }
-
-            valueConverted = true;
-        }
     }
-}
+}

PixiEditor/Helpers/Converters/DockingManagerActiveContentConverter.cs

@@ -8,12 +8,16 @@ namespace PixiEditor.Helpers.Converters
 {
     class DockingManagerActiveContentConverter : IValueConverter
     {
+        private Document cachedDocument = null;
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
             if (value == null)
                 return DependencyProperty.UnsetValue;
             if (value is Document document)
+            {
+                cachedDocument = document;
                 return document;
+            }
             return DependencyProperty.UnsetValue;
         }
 
@@ -21,6 +25,9 @@ namespace PixiEditor.Helpers.Converters
         {
             if (value is Document document)
                 return document;
+            if (value != null && cachedDocument != null && !cachedDocument.Disposed)
+                return cachedDocument;
+            cachedDocument = null;
             return DependencyProperty.UnsetValue;
         }
     }

PixiEditor/Helpers/Converters/LayerStructureToGroupsConverter.cs

@@ -6,6 +6,7 @@ using System.Collections.ObjectModel;
 using System.Globalization;
 using System.Linq;
 using System.Windows.Data;
+using PixiEditor.Models.DataHolders;
 
 namespace PixiEditor.Helpers.Converters
 {
@@ -24,7 +25,7 @@ namespace PixiEditor.Helpers.Converters
 
         private ObservableCollection<GuidStructureItem> GetSubGroups(IEnumerable<GuidStructureItem> groups)
         {
-            ObservableCollection<GuidStructureItem> finalGroups = new ObservableCollection<GuidStructureItem>();
+            WpfObservableRangeCollection<GuidStructureItem> finalGroups = new WpfObservableRangeCollection<GuidStructureItem>();
             foreach (var group in groups)
             {
                 finalGroups.AddRange(GetSubGroups(group));

PixiEditor/Helpers/Converters/LayersToStructuredLayersConverter.cs

@@ -6,6 +6,7 @@ using System.Globalization;
 using System.Linq;
 using System.Windows;
 using System.Windows.Data;
+using PixiEditor.Models.DataHolders;
 
 namespace PixiEditor.Helpers.Converters
 {
@@ -16,11 +17,11 @@ namespace PixiEditor.Helpers.Converters
         private static StructuredLayerTree cachedTree;
         private List<Guid> lastLayerGuids = new List<Guid>();
         private IList<Layer> lastLayers = new List<Layer>();
-        private ObservableCollection<GuidStructureItem> lastStructure = new ObservableCollection<GuidStructureItem>();
+        private WpfObservableRangeCollection<GuidStructureItem> lastStructure = new WpfObservableRangeCollection<GuidStructureItem>();
 
         public override object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
         {
-            if (values[0] is ObservableCollection<Layer> layers && values[1] is LayerStructure structure)
+            if (values[0] is WpfObservableRangeCollection<Layer> layers && values[1] is LayerStructure structure)
             {
                 if (cachedTree == null)
                 {

PixiEditor/Helpers/Converters/ToolSizeToIntConverter.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Globalization;
-using System.Linq;
 using System.Text.RegularExpressions;
 using System.Windows.Data;
 
@@ -12,24 +11,24 @@ namespace PixiEditor.Helpers.Converters
     {
         public override object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            return string.Format("{0} {1}", value, "px");
+            return value.ToString();
         }
 
         public override object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            if (string.IsNullOrWhiteSpace(value as string))
+            if (value is not string s)
             {
                 return null;
             }
 
-            string slicedString = value.ToString().Split(' ').First();
-            slicedString = Regex.Replace(slicedString, "\\p{L}", string.Empty);
-            if (slicedString == string.Empty)
+            Match match = Regex.Match(s, @"\d+");
+
+            if (!match.Success)
             {
                 return null;
             }
 
-            return int.Parse(slicedString);
+            return int.Parse(match.Groups[0].ValueSpan);
         }
     }
 }

PixiEditor/Helpers/CoordinatesHelper.cs

@@ -0,0 +1,85 @@
+using PixiEditor.Models.Position;
+using System;
+using System.Collections.Generic;
+
+namespace PixiEditor.Helpers
+{
+    internal class CoordinatesHelper
+    {
+        public static (Coordinates, Coordinates) GetSquareOrLineCoordinates(IReadOnlyList<Coordinates> coords)
+        {
+            if (DoCoordsFormLine(coords))
+            {
+                return GetLineCoordinates(coords);
+            }
+            return GetSquareCoordiantes(coords);
+        }
+
+        private static bool DoCoordsFormLine(IReadOnlyList<Coordinates> coords)
+        {
+            var p1 = coords[0];
+            var p2 = coords[^1];
+            //find delta and mirror to first quadrant
+            float dX = Math.Abs(p2.X - p1.X);
+            float dY = Math.Abs(p2.Y - p1.Y);
+
+            //normalize
+            float length = (float)Math.Sqrt(dX * dX + dY * dY);
+            if (length == 0)
+                return false;
+            dX = dX / length;
+            dY = dY / length;
+
+            return dX < 0.25f || dY < 0.25f; //angle < 15 deg or angle > 75 deg (sin 15 ~= 0.25)
+        }
+
+        public static (Coordinates, Coordinates) GetLineCoordinates(IReadOnlyList<Coordinates> mouseMoveCords)
+        {
+            int xStart = mouseMoveCords[0].X;
+            int yStart = mouseMoveCords[0].Y;
+
+            int xEnd = mouseMoveCords[^1].X;
+            int yEnd = mouseMoveCords[^1].Y;
+
+
+            if (Math.Abs(xStart - xEnd) > Math.Abs(yStart - yEnd))
+            {
+                yEnd = yStart;
+            }
+            else
+            {
+                xEnd = xStart;
+            }
+            return (new(xStart, yStart), new(xEnd, yEnd));
+        }
+
+        /// <summary>
+        ///     Extracts square from rectangle mouse drag, used to draw symmetric shapes.
+        /// </summary>
+        public static (Coordinates, Coordinates) GetSquareCoordiantes(IReadOnlyList<Coordinates> mouseMoveCords)
+        {
+            var end = mouseMoveCords[^1];
+            var start = mouseMoveCords[0];
+
+            //find delta and mirror to first quadrant
+            var dX = Math.Abs(start.X - end.X);
+            var dY = Math.Abs(start.Y - end.Y);
+
+            float sqrt2 = (float)Math.Sqrt(2);
+            //vector of length 1 at 45 degrees;
+            float diagX, diagY;
+            diagX = diagY = 1 / sqrt2;
+
+            //dot product of delta and diag, returns length of [delta projected onto diag]
+            float projectedLength = diagX * dX + diagY * dY;
+            //project above onto axes
+            float axisLength = projectedLength / sqrt2;
+
+            //final coords
+            float x = -Math.Sign(start.X - end.X) * axisLength;
+            float y = -Math.Sign(start.Y - end.Y) * axisLength;
+            end = new Coordinates((int)x + start.X, (int)y + start.Y);
+            return (start, end);
+        }
+    }
+}

PixiEditor/Helpers/Extensions/ObservableCollectionEx.cs

@@ -1,16 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-
-namespace PixiEditor.Helpers.Extensions
-{
-    public static class ObservableCollectionEx
-    {
-        public static void AddRange<T>(this ObservableCollection<T> collection, IEnumerable<T> items)
-        {
-            foreach (var item in items)
-            {
-                collection.Add(item);
-            }
-        }
-    }
-}

PixiEditor/Helpers/Extensions/ParserHelpers.cs

@@ -25,13 +25,14 @@ namespace PixiEditor.Helpers.Extensions
             {
                 document.SetMainActiveLayer(0);
             }
+            document.Renderer.ForceRerender();
 
             return document;
         }
 
-        public static ObservableCollection<Layer> ToLayers(this SerializableDocument document)
+        public static WpfObservableRangeCollection<Layer> ToLayers(this SerializableDocument document)
         {
-            ObservableCollection<Layer> layers = new();
+            WpfObservableRangeCollection<Layer> layers = new();
             foreach (SerializableLayer slayer in document)
             {
                 layers.Add(slayer.ToLayer());
@@ -50,9 +51,9 @@ namespace PixiEditor.Helpers.Extensions
             };
         }
 
-        public static ObservableCollection<GuidStructureItem> ToGroups(this SerializableDocument sdocument, Document document)
+        public static WpfObservableRangeCollection<GuidStructureItem> ToGroups(this SerializableDocument sdocument, Document document)
         {
-            ObservableCollection<GuidStructureItem> groups = new();
+            WpfObservableRangeCollection<GuidStructureItem> groups = new();
 
             if (sdocument.Groups == null)
             {

PixiEditor/Helpers/GlobalMouseHook.cs

@@ -5,7 +5,8 @@ using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using System.Windows;
 using System.Windows.Input;
-
+using System.Windows.Threading;
+
 namespace PixiEditor.Helpers
 {
     public delegate void MouseUpEventHandler(object sender, Point p, MouseButton button);
@@ -88,9 +89,11 @@ namespace PixiEditor.Helpers
                 {
                     if (MouseUp != null)
                     {
+
                         MouseButton button = wParam == WM_LBUTTONUP ? MouseButton.Left
-                            : wParam == WM_MBUTTONUP ? MouseButton.Middle : MouseButton.Right;
-                        MouseUp.Invoke(null, new Point(mouseHookStruct.Pt.X, mouseHookStruct.Pt.Y), button);
+                            : wParam == WM_MBUTTONUP ? MouseButton.Middle : MouseButton.Right;
+                        Dispatcher.CurrentDispatcher.BeginInvoke(() =>
+                            MouseUp.Invoke(null, new Point(mouseHookStruct.Pt.X, mouseHookStruct.Pt.Y), button));
                     }
                 }
             }
@@ -138,4 +141,4 @@ namespace PixiEditor.Helpers
             public IntPtr DwExtraInfo;
         }
     }
-}
+}

PixiEditor/Helpers/RelayCommand.cs

@@ -40,4 +40,4 @@ namespace PixiEditor.Helpers
             execute(parameter);
         }
     }
-}
+}

PixiEditor/Helpers/Validators/SizeValidationRule.cs

@@ -7,7 +7,9 @@ namespace PixiEditor.Helpers.Validators
     {
         public override ValidationResult Validate(object value, CultureInfo cultureInfo)
         {
-            return new ValidationResult(int.Parse(((string)value).Split(' ')[0]) > 0, null); // Size is greater than 0
+            int i = int.Parse(((string)value).Split(' ')[0]);
+
+            return new ValidationResult(i > 0, null); // Size is greater than 0
         }
     }
 }

PixiEditor/Models/Controllers/BitmapManager.cs

@@ -3,98 +3,92 @@ using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Events;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
-using PixiEditor.Models.Tools;
+using PixiEditor.Models.Tools;
 using PixiEditor.Models.Tools.Tools;
-using PixiEditor.Models.Tools.ToolSettings.Settings;
-using PixiEditor.ViewModels;
 using PixiEditor.ViewModels.SubViewModels.Main;
 using SkiaSharp;
 using System;
-using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
-using System.Linq;
 using System.Windows;
-using System.Windows.Input;
-
+
 namespace PixiEditor.Models.Controllers
 {
     [DebuggerDisplay("{Documents.Count} Document(s)")]
     public class BitmapManager : NotifyableObject
     {
-        private readonly ToolsViewModel _tools;
-
-        private int previewLayerSize;
-        private Document activeDocument;
-        private Coordinates? startPosition = null;
-        private int halfSize;
-        private SKColor _highlightColor;
-        private PenTool _highlightPen;
-        private bool hideReferenceLayer;
-        private bool onlyReferenceLayer;
-
-        public BitmapManager(ToolsViewModel tools)
-        {
-            _tools = tools;
-
-            MouseController = new MouseMovementController();
-            MouseController.StartedRecordingChanges += MouseController_StartedRecordingChanges;
-            MouseController.MousePositionChanged += Controller_MousePositionChanged;
-            MouseController.StoppedRecordingChanges += MouseController_StoppedRecordingChanges;
-            MouseController.OnMouseDown += MouseController_OnMouseDown;
-            MouseController.OnMouseUp += MouseController_OnMouseUp;
-            MouseController.OnMouseDownCoordinates += MouseController_OnMouseDownCoordinates;
-            BitmapOperations = new BitmapOperationsUtility(this, tools);
-            ReadonlyToolUtility = new ReadonlyToolUtility();
-            DocumentChanged += BitmapManager_DocumentChanged;
-            _highlightPen = new PenTool(this)
-            {
-                AutomaticallyResizeCanvas = false
-            };
-            _highlightColor = new SKColor(0, 0, 0, 77);
-        }
+        private ToolSessionController ToolSessionController { get; set; }
+        public ICanvasInputTarget InputTarget => ToolSessionController;
+        public BitmapOperationsUtility BitmapOperations { get; set; }
 
-        public event EventHandler<DocumentChangedEventArgs> DocumentChanged;
-
-        public MouseMovementController MouseController { get; set; }
-
-        public Layer ActiveLayer => ActiveDocument.ActiveLayer;
-
-        public SKColor PrimaryColor { get; set; }
+        public ObservableCollection<Document> Documents { get; set; } = new ObservableCollection<Document>();
 
-        public BitmapOperationsUtility BitmapOperations { get; set; }
-
-        public ReadonlyToolUtility ReadonlyToolUtility { get; set; }
-
-#nullable enable
+        private Document activeDocument;
         public Document ActiveDocument
         {
             get => activeDocument;
             set
             {
                 activeDocument?.UpdatePreviewImage();
-                Document? oldDoc = activeDocument;
+                Document oldDoc = activeDocument;
                 activeDocument = value;
                 RaisePropertyChanged(nameof(ActiveDocument));
                 DocumentChanged?.Invoke(this, new DocumentChangedEventArgs(value, oldDoc));
             }
         }
 
-#nullable disable
-        public ObservableCollection<Document> Documents { get; set; } = new ObservableCollection<Document>();
+        public event EventHandler<DocumentChangedEventArgs> DocumentChanged;
+        public event EventHandler StopUsingTool;
+
+        public Layer ActiveLayer => ActiveDocument.ActiveLayer;
+
+        public SKColor PrimaryColor { get; set; }
 
+        private bool hideReferenceLayer;
         public bool HideReferenceLayer
         {
             get => hideReferenceLayer;
             set => SetProperty(ref hideReferenceLayer, value);
         }
 
+        private bool onlyReferenceLayer;
         public bool OnlyReferenceLayer
         {
             get => onlyReferenceLayer;
             set => SetProperty(ref onlyReferenceLayer, value);
         }
 
+        private readonly ToolsViewModel _tools;
+
+        private int previewLayerSize;
+        private int halfSize;
+        private SKColor _highlightColor;
+        private PenTool _highlightPen;
+
+        private ToolSession activeSession = null;
+
+
+        public BitmapManager(ToolsViewModel tools)
+        {
+            _tools = tools;
+
+            ToolSessionController = new ToolSessionController();
+            ToolSessionController.SessionStarted += OnSessionStart;
+            ToolSessionController.SessionEnded += OnSessionEnd;
+            ToolSessionController.PixelMousePositionChanged += OnPixelMousePositionChange;
+            ToolSessionController.PreciseMousePositionChanged += OnPreciseMousePositionChange;
+            ToolSessionController.KeyStateChanged += (_, _) => UpdateActionDisplay(_tools.ActiveTool);
+            BitmapOperations = new BitmapOperationsUtility(this, tools);
+
+            DocumentChanged += BitmapManager_DocumentChanged;
+
+            _highlightPen = new PenTool(this)
+            {
+                AutomaticallyResizeCanvas = false
+            };
+            _highlightColor = new SKColor(0, 0, 0, 77);
+        }
+
         public void CloseDocument(Document document)
         {
             int nextIndex = 0;
@@ -107,49 +101,110 @@ namespace PixiEditor.Models.Controllers
             Documents.Remove(document);
             ActiveDocument = nextIndex >= 0 ? Documents[nextIndex] : null;
             document.Dispose();
+        }
+
+        public void UpdateActionDisplay(Tool tool)
+        {
+            tool?.UpdateActionDisplay(ToolSessionController.IsCtrlDown, ToolSessionController.IsShiftDown, ToolSessionController.IsAltDown);
+        }
+
+        private void OnSessionStart(object sender, ToolSession e)
+        {
+            activeSession = e;
+
+            ActiveDocument.PreviewLayer.Reset();
+            ExecuteTool();
         }
 
-        public void ExecuteTool(Coordinates newPosition, bool clickedOnCanvas)
-        {
-            Tool activeTool = _tools.ActiveTool;
-
-            if (activeTool.CanStartOutsideCanvas && !clickedOnCanvas)
+        private void OnSessionEnd(object sender, ToolSession e)
+        {
+            activeSession = null;
+
+            if (e.Tool is BitmapOperationTool operationTool && operationTool.RequiresPreviewLayer)
             {
-                return;
+                BitmapOperations.ApplyPreviewLayer();
             }
 
-            if (startPosition == null)
+            ActiveDocument.PreviewLayer.Reset();
+            HighlightPixels(ToolSessionController.LastPixelPosition);
+            StopUsingTool?.Invoke(this, EventArgs.Empty);
+        }
+
+        private void OnPreciseMousePositionChange(object sender, (double, double) e)
+        {
+            if (activeSession == null || !activeSession.Tool.RequiresPreciseMouseData)
+                return;
+            ExecuteTool();
+        }
+
+        private void OnPixelMousePositionChange(object sender, MouseMovementEventArgs e)
+        {
+            if (activeSession != null)
             {
-                activeTool.OnStart(newPosition);
-                startPosition = newPosition;
+                if (activeSession.Tool.RequiresPreciseMouseData)
+                    return;
+                ExecuteTool();
+                return;
+            }
+            else
+            {
+                HighlightPixels(e.NewPosition);
             }
+        }
+
+        private void ExecuteTool()
+        {
+            if (activeSession == null)
+                throw new Exception("Can't execute tool's Use outside a session");
 
-            if (activeTool is BitmapOperationTool operationTool)
+            if (activeSession.Tool is BitmapOperationTool operationTool)
             {
-                BitmapOperations.ExecuteTool(newPosition, MouseController.LastMouseMoveCoordinates, operationTool);
+                BitmapOperations.UseTool(activeSession.MouseMovement, operationTool, PrimaryColor);
             }
-            else if (activeTool is ReadonlyTool readonlyTool)
+            else if (activeSession.Tool is ReadonlyTool readonlyTool)
             {
-                ActiveDocument.PreviewLayer.Reset();
-                ReadonlyToolUtility.ExecuteTool(
-                    MouseController.LastMouseMoveCoordinates,
-                    readonlyTool);
+                readonlyTool.Use(activeSession.MouseMovement);
             }
             else
             {
-                throw new InvalidOperationException($"'{activeTool.GetType().Name}' is either not a Tool or can't inherit '{nameof(Tool)}' directly.\nChanges the base type to either '{nameof(BitmapOperationTool)}' or '{nameof(ReadonlyTool)}'");
+                throw new InvalidOperationException($"'{activeSession.Tool.GetType().Name}' is either not a Tool or can't inherit '{nameof(Tool)}' directly.\nChanges the base type to either '{nameof(BitmapOperationTool)}' or '{nameof(ReadonlyTool)}'");
             }
-        }
+        }
+
+        private void BitmapManager_DocumentChanged(object sender, DocumentChangedEventArgs e)
+        {
+            e.NewDocument?.GeneratePreviewLayer();
+            if (e.OldDocument != e.NewDocument)
+                ToolSessionController.ForceStopActiveSessionIfAny();
+        }
+
+        public void UpdateHighlightIfNecessary(bool forceHide = false)
+        {
+            if (activeSession != null)
+                return;
 
-        public void HighlightPixels(Coordinates newPosition)
+            HighlightPixels(forceHide ? new(-1, -1) : ToolSessionController.LastPixelPosition);
+        }
+
+        private void HighlightPixels(Coordinates newPosition)
         {
-            if (ActiveDocument == null || ActiveDocument.Layers.Count == 0 || _tools.ActiveTool.HideHighlight)
+            if (ActiveDocument == null || ActiveDocument.Layers.Count == 0)
             {
                 return;
             }
 
             var previewLayer = ActiveDocument.PreviewLayer;
 
+            if (newPosition.X > ActiveDocument.Width
+                || newPosition.Y > ActiveDocument.Height
+                || newPosition.X < 0 || newPosition.Y < 0
+                || _tools.ActiveTool.HideHighlight)
+            {
+                previewLayer.Reset();
+                previewLayerSize = -1;
+                return;
+            }
+
             if (_tools.ToolSize != previewLayerSize || previewLayer.IsReset)
             {
                 previewLayerSize = _tools.ToolSize;
@@ -160,97 +215,12 @@ namespace PixiEditor.Models.Controllers
 
                 previewLayer.Offset = new Thickness(0, 0, 0, 0);
                 _highlightPen.Draw(previewLayer, cords, cords, _highlightColor, _tools.ToolSize);
-
-                AdjustOffset(newPosition, previewLayer);
-
             }
-
-            previewLayer.InvokeLayerBitmapChange();
-
             AdjustOffset(newPosition, previewLayer);
-
-            if (newPosition.X > ActiveDocument.Width
-                || newPosition.Y > ActiveDocument.Height
-                || newPosition.X < 0 || newPosition.Y < 0)
-            {
-                previewLayer.Reset();
-                previewLayerSize = -1;
-            }
-        }
 
-        private void BitmapManager_DocumentChanged(object sender, DocumentChangedEventArgs e)
-        {
-            e.NewDocument?.GeneratePreviewLayer();
-        }
-
-        private void Controller_MousePositionChanged(object sender, MouseMovementEventArgs e)
-        {
-            Tool activeTool = _tools.ActiveTool;
-
-            if (activeTool == null)
-            {
-                return;
-            }
-
-            activeTool.OnMouseMove(new MouseEventArgs(Mouse.PrimaryDevice, (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds()));
-            if (!MaybeExecuteTool(e.NewPosition) && MouseController.LeftMouseState == MouseButtonState.Released)
-            {
-                HighlightPixels(e.NewPosition);
-            }
-        }
-
-        private void MouseController_OnMouseDown(object sender, MouseEventArgs e)
-        {
-            _tools.ActiveTool.OnMouseDown(e);
-        }
-
-        private void MouseController_OnMouseUp(object sender, MouseEventArgs e)
-        {
-            _tools.ActiveTool.OnMouseUp(e);
-        }
-        private void MouseController_OnMouseDownCoordinates(object sender, MouseMovementEventArgs e)
-        {
-            MaybeExecuteTool(e.NewPosition);
-        }
-
-        private bool MaybeExecuteTool(Coordinates newPosition)
-        {
-            if (MouseController.LeftMouseState == MouseButtonState.Pressed && !IsDraggingViewport() && ActiveDocument != null)
-            {
-                ExecuteTool(newPosition, MouseController.ClickedOnCanvas);
-                return true;
-            }
-            return false;
-        }
-
-        private bool IsDraggingViewport()
-        {
-            return _tools.ActiveTool is MoveViewportTool;
-        }
-
-        private void MouseController_StartedRecordingChanges(object sender, EventArgs e)
-        {
-            _tools.ActiveTool.OnRecordingLeftMouseDown(new MouseEventArgs(Mouse.PrimaryDevice, (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds()));
-            if (ActiveDocument != null)
-            {
-                ActiveDocument.PreviewLayer.Reset();
-            }
+            previewLayer.InvokeLayerBitmapChange();
         }
 
-        private void MouseController_StoppedRecordingChanges(object sender, EventArgs e)
-        {
-            Tool selectedTool = _tools.ActiveTool;
-            selectedTool.OnStoppedRecordingMouseUp(new MouseEventArgs(Mouse.PrimaryDevice, (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds()));
-            if (selectedTool is BitmapOperationTool operationTool && operationTool.RequiresPreviewLayer)
-            {
-                BitmapOperations.ApplyPreviewLayer();
-            }
-
-            HighlightPixels(MousePositionConverter.CurrentCoordinates);
-
-            startPosition = null;
-        }
-
         private void AdjustOffset(Coordinates newPosition, Layer previewLayer)
         {
             Coordinates start = newPosition - halfSize;

PixiEditor/Models/Controllers/BitmapOperationsUtility.cs

@@ -2,23 +2,24 @@
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools;
-using PixiEditor.Models.Tools.ToolSettings.Settings;
 using PixiEditor.Models.Undo;
 using PixiEditor.ViewModels.SubViewModels.Main;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
 using System.Windows;
-using System.Windows.Input;
 
 namespace PixiEditor.Models.Controllers
 {
     public class BitmapOperationsUtility
     {
-        private SKPaint BlendingPaint { get; } = new SKPaint() { BlendMode = SKBlendMode.SrcOver };
+        public event EventHandler<BitmapChangedEventArgs> BitmapChanged;
+
+        public BitmapManager Manager { get; set; }
 
+        public ToolsViewModel Tools { get; set; }
 
-        private SizeSetting sizeSetting;
+        private SKPaint BlendingPaint { get; } = new SKPaint() { BlendMode = SKBlendMode.SrcOver };
 
         public BitmapOperationsUtility(BitmapManager manager, ToolsViewModel tools)
         {
@@ -26,12 +27,6 @@ namespace PixiEditor.Models.Controllers
             Tools = tools;
         }
 
-        public event EventHandler<BitmapChangedEventArgs> BitmapChanged;
-
-        public BitmapManager Manager { get; set; }
-
-        public ToolsViewModel Tools { get; set; }
-
         public void DeletePixels(Layer[] layers, Coordinates[] pixels)
         {
             if (Manager.ActiveDocument == null)
@@ -40,19 +35,11 @@ namespace PixiEditor.Models.Controllers
             }
 
             StorageBasedChange change = new StorageBasedChange(Manager.ActiveDocument, layers, true);
-            
 
-            // TODO: Fix
             BitmapPixelChanges changes = BitmapPixelChanges.FromSingleColoredArray(pixels, SKColors.Empty);
-            //Dictionary<Guid, SKColor[]> oldValues = BitmapUtils.GetPixelsForSelection(layers, pixels);
-            //LayerChange[] old = new LayerChange[layers.Length];
-            //LayerChange[] newChange = new LayerChange[layers.Length];
             for (int i = 0; i < layers.Length; i++)
             {
                 Guid guid = layers[i].LayerGuid;
-                //old[i] = new LayerChange(
-                    //BitmapPixelChanges.FromArrays(pixels, oldValues[layers[i].LayerGuid]), guid);
-                //newChange[i] = new LayerChange(changes, guid);
                 layers[i].SetPixels(changes);
             }
 
@@ -60,22 +47,37 @@ namespace PixiEditor.Models.Controllers
             Manager.ActiveDocument.UndoManager.AddUndoChange(change.ToChange(StorageBasedChange.BasicUndoProcess, args, "Delete selected pixels"));
         }
 
-        /// <summary>
-        ///     Executes tool Use() method with given parameters. NOTE: [0] is a start point, [^1] is latest.
-        /// </summary>
-        /// <param name="newPos">Most recent coordinates.</param>
-        /// <param name="mouseMove">Last mouse movement coordinates.</param>
-        /// <param name="tool">Tool to execute.</param>
-        public void ExecuteTool(Coordinates newPos, List<Coordinates> mouseMove, BitmapOperationTool tool)
+        public void UseTool(IReadOnlyList<Coordinates> recordedMouseMovement, BitmapOperationTool tool, SKColor color)
         {
-            if (Manager.ActiveDocument != null && tool != null)
+            if (Manager.ActiveDocument.Layers.Count == 0)
+                return;
+
+            if (!tool.RequiresPreviewLayer)
+            {
+                tool.Use(Manager.ActiveLayer, null, Manager.ActiveDocument.Layers, recordedMouseMovement, color);
+                BitmapChanged?.Invoke(this, null);
+            }
+            else
             {
-                if (Manager.ActiveDocument.Layers.Count == 0 || mouseMove.Count == 0)
+                UseToolOnPreviewLayer(recordedMouseMovement, tool.ClearPreviewLayerOnEachIteration);
+            }
+        }
+
+        private void UseToolOnPreviewLayer(IReadOnlyList<Coordinates> recordedMouseMovement, bool clearPreviewLayer)
+        {
+            if (recordedMouseMovement.Count > 0)
+            {
+                if (clearPreviewLayer)
                 {
-                    return;
+                    Manager.ActiveDocument.PreviewLayer.ClearCanvas();
                 }
 
-                UseTool(mouseMove, tool, Manager.PrimaryColor);
+                ((BitmapOperationTool)Tools.ActiveTool).Use(
+                    Manager.ActiveLayer,
+                    Manager.ActiveDocument.PreviewLayer,
+                    Manager.ActiveDocument.Layers,
+                    recordedMouseMovement,
+                    Manager.PrimaryColor);
             }
         }
 
@@ -95,147 +97,9 @@ namespace PixiEditor.Models.Controllers
                     previewLayer.OffsetY - activeLayer.OffsetY,
                     BlendingPaint
                 );
+
             Manager.ActiveLayer.InvokeLayerBitmapChange(dirtyRect);
-            // Don't forget about firing BitmapChanged
             BitmapChanged?.Invoke(this, null);
-            Manager.ActiveDocument.PreviewLayer.Reset();
-        }
-
-        private void UseTool(List<Coordinates> mouseMoveCords, BitmapOperationTool tool, SKColor color)
-        {
-            if (sizeSetting == null)
-            {
-                sizeSetting = tool.Toolbar.GetSetting<SizeSetting>("ToolSize");
-            }
-
-            int thickness = sizeSetting != null ? sizeSetting.Value : 1;
-
-            bool shiftDown = Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift);
-
-            if (shiftDown && tool.UsesShift)
-            {
-                bool mouseInLine = DoCoordsFormLine(mouseMoveCords, thickness);
-
-                if (!mouseInLine)
-                {
-                    mouseMoveCords = GetSquareCoordiantes(mouseMoveCords);
-                }
-                else
-                {
-                    mouseMoveCords = GetLineCoordinates(mouseMoveCords, thickness);
-                }
-            }
-
-            if (!tool.RequiresPreviewLayer)
-            {
-                if (!Manager.ActiveDocument.PreviewLayer.IsReset)
-                    Manager.ActiveDocument.PreviewLayer.Reset();
-                tool.Use(Manager.ActiveLayer, mouseMoveCords, color);
-                BitmapChanged?.Invoke(this, null);
-            }
-            else
-            {
-                UseToolOnPreviewLayer(mouseMoveCords, tool.ClearPreviewLayerOnEachIteration);
-            }
-        }
-
-        private bool DoCoordsFormLine(List<Coordinates> coords, int thickness)
-        {
-            var p1 = coords[0];
-            var p2 = coords[^1];
-            //find delta and mirror to first quadrant
-            float dX = Math.Abs(p2.X - p1.X);
-            float dY = Math.Abs(p2.Y - p1.Y);
-
-            //normalize
-            float length = (float)Math.Sqrt(dX * dX + dY * dY);
-            if (length == 0)
-                return false;
-            dX = dX / length;
-            dY = dY / length;
-
-            return dX < 0.25f || dY < 0.25f; //angle < 15 deg or angle > 75 deg (sin 15 ~= 0.25)
-        }
-
-        private List<Coordinates> GetLineCoordinates(List<Coordinates> mouseMoveCords, int thickness)
-        {
-            int y = mouseMoveCords[0].Y;
-            int x = mouseMoveCords[0].X;
-
-            if (Math.Abs(mouseMoveCords[^1].X - mouseMoveCords[0].X) > Math.Abs(mouseMoveCords[^1].Y - mouseMoveCords[0].Y))
-            {
-                y = mouseMoveCords[^1].Y;
-            }
-            else
-            {
-                x = mouseMoveCords[^1].X;
-            }
-
-            mouseMoveCords[0] = new Coordinates(x, y);
-            return mouseMoveCords;
-        }
-
-        /// <summary>
-        ///     Extracts square from rectangle mouse drag, used to draw symmetric shapes.
-        /// </summary>
-        private List<Coordinates> GetSquareCoordiantes(List<Coordinates> mouseMoveCords)
-        {
-            var p1 = mouseMoveCords[0];
-            var p2 = mouseMoveCords[^1];
-
-            //find delta and mirror to first quadrant
-            var dX = Math.Abs(p2.X - p1.X);
-            var dY = Math.Abs(p2.Y - p1.Y);
-
-            float sqrt2 = (float)Math.Sqrt(2);
-            //vector of length 1 at 45 degrees;
-            float diagX, diagY;
-            diagX = diagY = 1 / sqrt2;
-
-            //dot product of delta and diag, returns length of [delta projected onto diag]
-            float projectedLength = diagX * dX + diagY * dY;
-            //project above onto axes
-            float axisLength = projectedLength / sqrt2;
-
-            //final coords
-            float x = -Math.Sign(p2.X - p1.X) * axisLength;
-            float y = -Math.Sign(p2.Y - p1.Y) * axisLength;
-            mouseMoveCords[0] = new Coordinates((int)x + p2.X, (int)y + p2.Y);
-            return mouseMoveCords;
-        }
-
-        private BitmapPixelChanges GetOldPixelsValues(Coordinates[] coordinates)
-        {
-            Dictionary<Coordinates, SKColor> values = new Dictionary<Coordinates, SKColor>();
-            //using (Manager.ActiveLayer.LayerBitmap.GetBitmapContext(ReadWriteMode.ReadOnly))
-            {
-                Coordinates[] relativeCoords = Manager.ActiveLayer.ConvertToRelativeCoordinates(coordinates);
-                for (int i = 0; i < coordinates.Length; i++)
-                {
-                    var cl = Manager.ActiveLayer.GetPixel(relativeCoords[i].X, relativeCoords[i].Y);
-                    values.Add(
-                        coordinates[i],
-                        cl);
-                }
-            }
-
-            return new BitmapPixelChanges(values);
-        }
-
-        private void UseToolOnPreviewLayer(List<Coordinates> mouseMove, bool clearPreviewLayer = true)
-        {
-            if (mouseMove.Count > 0)
-            {
-                if (clearPreviewLayer)
-                {
-                    Manager.ActiveDocument.PreviewLayer.ClearCanvas();
-                }
-
-                ((BitmapOperationTool)Tools.ActiveTool).Use(
-                    Manager.ActiveDocument.PreviewLayer,
-                    mouseMove,
-                    Manager.PrimaryColor);
-            }
         }
     }
 }

PixiEditor/Models/Controllers/ICanvasInputTarget.cs

@@ -0,0 +1,15 @@
+using PixiEditor.Models.Tools;
+using System.Windows.Input;
+
+namespace PixiEditor.Models.Controllers
+{
+    public interface ICanvasInputTarget
+    {
+        void OnToolChange(Tool tool);
+        void OnKeyDown(Key key);
+        void OnKeyUp(Key key);
+        void OnLeftMouseButtonDown(double canvasPosX, double canvasPosY);
+        void OnLeftMouseButtonUp();
+        void OnMouseMove(double newCanvasX, double newCanvasY);
+    }
+}

PixiEditor/Models/Controllers/LayerStackRenderer.cs

@@ -66,6 +66,11 @@ namespace PixiEditor.Models.Controllers
             Update(new Int32Rect(0, 0, finalSurface.Width, finalSurface.Height));
         }
 
+        public void ForceRerender()
+        {
+            Update(new Int32Rect(0, 0, finalSurface.Width, finalSurface.Height));
+        }
+
         public void Dispose()
         {
             finalSurface.Dispose();

PixiEditor/Models/Controllers/MouseInputFilter.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Input;
+
+namespace PixiEditor.Models.Controllers
+{
+    internal class MouseInputFilter
+    {
+        public EventHandler<MouseButton> OnMouseDown;
+        public EventHandler OnMouseMove;
+        public EventHandler<MouseButton> OnMouseUp;
+
+
+        private Dictionary<MouseButton, MouseButtonState> buttonStates = new()
+        {
+            [MouseButton.Left] = MouseButtonState.Released,
+            [MouseButton.Right] = MouseButtonState.Released,
+            [MouseButton.Middle] = MouseButtonState.Released,
+        };
+
+        public void MouseDown(object args) => MouseDown(((MouseButtonEventArgs)args).ChangedButton);
+        public void MouseDown(MouseButton button)
+        {
+            if (button is MouseButton.XButton1 or MouseButton.XButton2)
+                return;
+            if (buttonStates[button] == MouseButtonState.Pressed)
+                return;
+            buttonStates[button] = MouseButtonState.Pressed;
+
+            OnMouseDown?.Invoke(this, button);
+        }
+
+        public void MouseMove(object args) => OnMouseMove?.Invoke(this, EventArgs.Empty);
+        public void MouseMove(MouseEventArgs args) => OnMouseMove?.Invoke(this, EventArgs.Empty);
+
+        public void MouseUp(object args) => MouseUp(((MouseButtonEventArgs)args).ChangedButton);
+        public void MouseUp(object sender, Point p, MouseButton button) => MouseUp(button);
+        public void MouseUp(MouseButton button)
+        {
+            if (button is MouseButton.XButton1 or MouseButton.XButton2)
+                return;
+            if (buttonStates[button] == MouseButtonState.Released)
+                return;
+            buttonStates[button] = MouseButtonState.Released;
+
+            OnMouseUp?.Invoke(this, button);
+        }
+    }
+}

PixiEditor/Models/Controllers/MouseMovementController.cs

@@ -1,94 +0,0 @@
-using PixiEditor.Models.Position;
-using System;
-using System.Collections.Generic;
-using System.Windows.Input;
-
-namespace PixiEditor.Models.Controllers
-{
-    public class MouseMovementController
-    {
-        public event EventHandler StartedRecordingChanges;
-
-        public event EventHandler<MouseEventArgs> OnMouseDown;
-        public event EventHandler<MouseMovementEventArgs> OnMouseDownCoordinates;
-
-        public event EventHandler<MouseEventArgs> OnMouseUp;
-
-        public event EventHandler<MouseMovementEventArgs> MousePositionChanged;
-
-        public event EventHandler StoppedRecordingChanges;
-
-        public MouseButtonState LeftMouseState { get; private set; }
-
-        public List<Coordinates> LastMouseMoveCoordinates { get; set; } = new List<Coordinates>();
-
-        public bool IsRecordingChanges { get; private set; }
-
-        public bool ClickedOnCanvas { get; set; }
-
-
-        public void StartRecordingMouseMovementChanges(bool clickedOnCanvas)
-        {
-            if (IsRecordingChanges == false)
-            {
-                LastMouseMoveCoordinates.Clear();
-                IsRecordingChanges = true;
-                ClickedOnCanvas = clickedOnCanvas;
-                StartedRecordingChanges?.Invoke(this, EventArgs.Empty);
-            }
-        }
-
-        public void RecordMouseMovementChange(Coordinates mouseCoordinates)
-        {
-            if (IsRecordingChanges)
-            {
-                if (LastMouseMoveCoordinates.Count == 0 || mouseCoordinates != LastMouseMoveCoordinates[^1])
-                {
-                    LastMouseMoveCoordinates.Insert(0, mouseCoordinates);
-                    MousePositionChanged?.Invoke(this, new MouseMovementEventArgs(mouseCoordinates));
-                }
-            }
-        }
-
-        /// <summary>
-        ///     Plain mouse move, does not affect mouse drag recordings.
-        /// </summary>
-        public void MouseMoved(Coordinates mouseCoordinates)
-        {
-            MousePositionChanged?.Invoke(this, new MouseMovementEventArgs(mouseCoordinates));
-        }
-
-        /// <summary>
-        /// Plain mouse down, does not affect mouse recordings.
-        /// </summary>
-        public void MouseDown(MouseEventArgs args)
-        {
-            LeftMouseState = args.LeftButton;
-            OnMouseDown?.Invoke(this, args);
-        }
-
-        public void MouseDownCoordinates(Coordinates mouseCoordinates)
-        {
-            OnMouseDownCoordinates?.Invoke(this, new MouseMovementEventArgs(mouseCoordinates));
-        }
-
-        /// <summary>
-        /// Plain mouse up, does not affect mouse recordings.
-        /// </summary>
-        public void MouseUp(MouseEventArgs args)
-        {
-            LeftMouseState = MouseButtonState.Released;
-            OnMouseUp?.Invoke(this, args);
-        }
-
-        public void StopRecordingMouseMovementChanges()
-        {
-            if (IsRecordingChanges)
-            {
-                IsRecordingChanges = false;
-                ClickedOnCanvas = false;
-                StoppedRecordingChanges?.Invoke(this, EventArgs.Empty);
-            }
-        }
-    }
-}

PixiEditor/Models/Controllers/ReadonlyToolUtility.cs

@@ -1,14 +0,0 @@
-using System.Collections.Generic;
-using PixiEditor.Models.Position;
-using PixiEditor.Models.Tools;
-
-namespace PixiEditor.Models.Controllers
-{
-    public class ReadonlyToolUtility
-    {
-        public void ExecuteTool(List<Coordinates> mouseMove, ReadonlyTool tool)
-        {
-            tool.Use(mouseMove);
-        }
-    }
-}

PixiEditor/Models/Controllers/Shortcuts/ShortcutController.cs

@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Windows.Input;
 
@@ -41,4 +40,4 @@ namespace PixiEditor.Models.Controllers.Shortcuts
             }
         }
     }
-}
+}

PixiEditor/Models/Controllers/ToolSession.cs

@@ -0,0 +1,97 @@
+using PixiEditor.Models.Position;
+using PixiEditor.Models.Tools;
+using System;
+using System.Collections.Generic;
+using System.Windows.Input;
+
+namespace PixiEditor.Models.Controllers
+{
+    public class ToolSession
+    {
+        private List<Coordinates> mouseMovement = new();
+        private bool ended = false;
+
+        public IReadOnlyList<Coordinates> MouseMovement => mouseMovement;
+        public Tool Tool { get; }
+
+        public bool IsCtrlDown { get; private set; }
+        public bool IsShiftDown { get; private set; }
+        public bool IsAltDown { get; private set; }
+
+        public ToolSession(
+            Tool tool,
+            double mouseXOnCanvas,
+            double mouseYOnCanvas,
+            IReadOnlyDictionary<Key, KeyStates> keyboardStates)
+        {
+            if (tool == null)
+                throw new ArgumentNullException(nameof(tool));
+            Tool = tool;
+
+            Tool.Session = this;
+            InvokeKeyboardEvents(keyboardStates);
+            mouseMovement.Add(new((int)Math.Floor(mouseXOnCanvas), (int)Math.Floor(mouseYOnCanvas)));
+            Tool.BeforeUse();
+        }
+
+        private void InvokeKeyboardEvents(IReadOnlyDictionary<Key, KeyStates> keyboardStates)
+        {
+            foreach (var pair in keyboardStates)
+            {
+                if (pair.Value == KeyStates.None)
+                    OnKeyUp(pair.Key);
+                else if (pair.Value == KeyStates.Down)
+                    OnKeyDown(pair.Key);
+            }
+        }
+
+        public void EndSession(IReadOnlyDictionary<Key, KeyStates> keyboardStates)
+        {
+            if (ended)
+                throw new Exception("Session has ended already");
+            ended = true;
+
+            Tool.AfterUse();
+            InvokeReleaseKeyboardEvents(keyboardStates);
+            Tool.Session = null;
+        }
+
+        private void InvokeReleaseKeyboardEvents(IReadOnlyDictionary<Key, KeyStates> keyboardStates)
+        {
+            foreach (var pair in keyboardStates)
+            {
+                if (pair.Value == KeyStates.Down)
+                    OnKeyUp(pair.Key);
+            }
+        }
+
+        public void OnKeyDown(Key key)
+        {
+            if (key == Key.LeftCtrl)
+                IsCtrlDown = true;
+            else if (key == Key.LeftShift)
+                IsShiftDown = true;
+            else if (key == Key.LeftAlt)
+                IsAltDown = true;
+
+            Tool.OnKeyDown(key);
+        }
+
+        public void OnKeyUp(Key key)
+        {
+            if (key == Key.LeftCtrl)
+                IsCtrlDown = false;
+            else if (key == Key.LeftShift)
+                IsShiftDown = false;
+            else if (key == Key.LeftAlt)
+                IsAltDown = false;
+
+            Tool.OnKeyUp(key);
+        }
+
+        public void OnPixelPositionChange(Coordinates pos)
+        {
+            mouseMovement.Add(pos);
+        }
+    }
+}

PixiEditor/Models/Controllers/ToolSessionController.cs

@@ -0,0 +1,140 @@
+using PixiEditor.Models.Position;
+using PixiEditor.Models.Tools;
+using System;
+using System.Collections.Generic;
+using System.Windows.Input;
+
+namespace PixiEditor.Models.Controllers
+{
+    public class ToolSessionController : ICanvasInputTarget
+    {
+        public event EventHandler<MouseMovementEventArgs> PixelMousePositionChanged;
+        public event EventHandler<(double, double)> PreciseMousePositionChanged;
+        public event EventHandler<(Key, KeyStates)> KeyStateChanged;
+
+        public event EventHandler<ToolSession> SessionStarted;
+        public event EventHandler<ToolSession> SessionEnded;
+
+        public MouseButtonState LeftMouseState { get; private set; }
+
+        public bool IsShiftDown => keyboardState.ContainsKey(Key.LeftShift) ? keyboardState[Key.LeftShift] == KeyStates.Down : false;
+        public bool IsCtrlDown => keyboardState.ContainsKey(Key.LeftCtrl) ? keyboardState[Key.LeftCtrl] == KeyStates.Down : false;
+        public bool IsAltDown => keyboardState.ContainsKey(Key.LeftAlt) ? keyboardState[Key.LeftAlt] == KeyStates.Down : false;
+
+        public Coordinates LastPixelPosition => new(lastPixelX, lastPixelY);
+
+        private int lastPixelX;
+        private int lastPixelY;
+
+        private Dictionary<Key, KeyStates> keyboardState = new();
+        private Tool currentTool = null;
+        private ToolSession currentSession = null;
+
+        private void TryStartToolSession(Tool tool, double mouseXOnCanvas, double mouseYOnCanvas)
+        {
+            if (currentSession != null)
+                return;
+            currentSession = new(tool, mouseXOnCanvas, mouseYOnCanvas, keyboardState);
+            SessionStarted?.Invoke(this, currentSession);
+        }
+
+        private void TryStopToolSession()
+        {
+            if (currentSession == null)
+                return;
+            currentSession.EndSession(keyboardState);
+            SessionEnded?.Invoke(this, currentSession);
+            currentSession = null;
+        }
+
+        public void OnKeyDown(Key key)
+        {
+            key = ConvertRightKeys(key);
+            UpdateKeyState(key, KeyStates.Down);
+            currentSession?.OnKeyDown(key);
+            KeyStateChanged?.Invoke(this, (key, KeyStates.Down));
+        }
+
+        public void OnKeyUp(Key key)
+        {
+            key = ConvertRightKeys(key);
+            UpdateKeyState(key, KeyStates.None);
+            currentSession?.OnKeyUp(key);
+            KeyStateChanged?.Invoke(this, (key, KeyStates.None));
+        }
+
+        private void UpdateKeyState(Key key, KeyStates state)
+        {
+            key = ConvertRightKeys(key);
+            if (!keyboardState.ContainsKey(key))
+                keyboardState.Add(key, state);
+            else
+                keyboardState[key] = state;
+        }
+
+        private Key ConvertRightKeys(Key key)
+        {
+            if (key == Key.RightAlt)
+                return Key.LeftAlt;
+            if (key == Key.RightCtrl)
+                return Key.LeftCtrl;
+            if (key == Key.RightShift)
+                return Key.LeftShift;
+            return key;
+        }
+
+        public void ForceStopActiveSessionIfAny() => TryStopToolSession();
+
+        public void OnToolChange(Tool tool)
+        {
+            currentTool = tool;
+            TryStopToolSession();
+        }
+
+        public void OnMouseMove(double newCanvasX, double newCanvasY)
+        {
+            //update internal state
+
+            int newX = (int)Math.Floor(newCanvasX);
+            int newY = (int)Math.Floor(newCanvasY);
+            bool pixelPosChanged = false;
+            if (lastPixelX != newX || lastPixelY != newY)
+            {
+                lastPixelX = newX;
+                lastPixelY = newY;
+                pixelPosChanged = true;
+            }
+
+
+            //call session events
+            if (currentSession != null && pixelPosChanged)
+                currentSession.OnPixelPositionChange(new(newX, newY));
+
+            //call internal events
+            PreciseMousePositionChanged?.Invoke(this, (newCanvasX, newCanvasY));
+            if (pixelPosChanged)
+                PixelMousePositionChanged?.Invoke(this, new MouseMovementEventArgs(new Coordinates(newX, newY)));
+        }
+
+        public void OnLeftMouseButtonDown(double canvasPosX, double canvasPosY)
+        {
+            //update internal state
+            LeftMouseState = MouseButtonState.Pressed;
+
+            //call session events
+
+            if (currentTool == null)
+                throw new Exception("Current tool must not be null here");
+            TryStartToolSession(currentTool, canvasPosX, canvasPosY);
+        }
+
+        public void OnLeftMouseButtonUp()
+        {
+            //update internal state
+            LeftMouseState = MouseButtonState.Released;
+
+            //call session events
+            TryStopToolSession();
+        }
+    }
+}

PixiEditor/Models/Controllers/UndoManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -106,6 +106,11 @@ namespace PixiEditor.Models.Controllers
         public void SquashUndoChanges(int amount)
         {
             string description = UndoStack.ElementAt(UndoStack.Count - amount).Description;
+            if (string.IsNullOrEmpty(description))
+            {
+                description = $"Squash {amount} undo changes.";
+            }
+
             SquashUndoChanges(amount, description);
         }
 

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

@@ -24,9 +24,9 @@ namespace PixiEditor.Models.DataHolders
         private Guid activeLayerGuid;
         private LayerStructure layerStructure;
 
-        private ObservableCollection<Layer> layers = new();
+        private WpfObservableRangeCollection<Layer> layers = new();
 
-        public ObservableCollection<Layer> Layers
+        public WpfObservableRangeCollection<Layer> Layers
         {
             get => layers;
             set
@@ -137,7 +137,7 @@ namespace PixiEditor.Models.DataHolders
             }
         }
 
-        public void MoveLayerInStructure(Guid layerGuid, Guid referenceLayer, bool above = false)
+        public void MoveLayerInStructure(Guid layerGuid, Guid referenceLayer, bool above = false, bool addToUndo = true)
         {
             var args = new object[] { layerGuid, referenceLayer, above };
 
@@ -151,6 +151,8 @@ namespace PixiEditor.Models.DataHolders
 
             AddLayerStructureToUndo(oldLayerStrcutureGroups);
 
+            if (!addToUndo) return;
+
             UndoManager.AddUndoChange(new Change(
                 ReverseMoveLayerInStructureProcess,
                 new object[] { oldIndex, layerGuid },
@@ -407,14 +409,14 @@ namespace PixiEditor.Models.DataHolders
 
         }
 
-        public void AddLayerStructureToUndo(ObservableCollection<GuidStructureItem> oldLayerStructureGroups)
+        public void AddLayerStructureToUndo(WpfObservableRangeCollection<GuidStructureItem> oldLayerStructureGroups)
         {
             UndoManager.AddUndoChange(
                 new Change(
                     BuildLayerStructureProcess,
-                    new[] { oldLayerStructureGroups },
+                    new object[] { oldLayerStructureGroups },
                     BuildLayerStructureProcess,
-                    new[] { LayerStructure.CloneGroups() }));
+                    new object[] { LayerStructure.CloneGroups() }, "Reload LayerStructure"));
         }
 
         public Layer MergeLayers(Layer[] layersToMerge, bool nameOfLast, int index)
@@ -514,9 +516,9 @@ namespace PixiEditor.Models.DataHolders
             renderer?.Dispose();
         }
 
-        private void BuildLayerStructureProcess(object[] parameters)
+        public void BuildLayerStructureProcess(object[] parameters)
         {
-            if (parameters.Length > 0 && parameters[0] is ObservableCollection<GuidStructureItem> groups)
+            if (parameters.Length > 0 && parameters[0] is WpfObservableRangeCollection<GuidStructureItem> groups)
             {
                 LayerStructure.Groups.CollectionChanged -= Groups_CollectionChanged;
                 LayerStructure.Groups = LayerStructure.CloneGroups(groups);

PixiEditor/Models/DataHolders/Document/Document.cs

@@ -95,6 +95,8 @@ namespace PixiEditor.Models.DataHolders
             }
         }
 
+        public bool Disposed { get; private set; } = false;
+
         public ExecutionTrigger<Size> CenterViewportTrigger { get; } = new();
         public ExecutionTrigger<double> ZoomViewportTrigger { get; } = new();
 
@@ -187,6 +189,9 @@ namespace PixiEditor.Models.DataHolders
 
         public void Dispose()
         {
+            if (Disposed)
+                return;
+            Disposed = true;
             DisposeLayerBitmaps();
             UndoManager.Dispose();
 
@@ -195,8 +200,6 @@ namespace PixiEditor.Models.DataHolders
 
         private void SetAsActiveOnClick(object obj)
         {
-            XamlAccesibleViewModel.BitmapManager.MouseController.StopRecordingMouseMovementChanges();
-            //XamlAccesibleViewModel.BitmapManager.MouseController.StartRecordingMouseMovementChanges(true);
             if (XamlAccesibleViewModel.BitmapManager.ActiveDocument != this)
             {
                 XamlAccesibleViewModel.BitmapManager.ActiveDocument = this;

PixiEditor/Models/DataHolders/RangeObservableCollection.cs

@@ -0,0 +1,666 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+
+namespace PixiEditor.Models.DataHolders
+{
+  // Licensed to the .NET Foundation under one or more agreements.
+  // The .NET Foundation licenses this file to you under the MIT license.
+  // See the LICENSE file in the project root for more information.
+  /// <summary>
+  /// Implementation of a dynamic data collection based on generic Collection&lt;T&gt;,
+  /// implementing INotifyCollectionChanged to notify listeners
+  /// when items get added, removed or the whole list is refreshed.
+  /// </summary>
+  public class RangeObservableCollection<T> : ObservableCollection<T>
+  {
+    //------------------------------------------------------
+    //
+    //  Private Fields
+    //
+    //------------------------------------------------------
+
+    #region Private Fields    
+    [NonSerialized]
+    private DeferredEventsCollection? _deferredEvents;
+    #endregion Private Fields
+
+
+    //------------------------------------------------------
+    //
+    //  Constructors
+    //
+    //------------------------------------------------------
+
+    #region Constructors
+    /// <summary>
+    /// Initializes a new instance of ObservableCollection that is empty and has default initial capacity.
+    /// </summary>
+    public RangeObservableCollection() { }
+
+    /// <summary>
+    /// Initializes a new instance of the ObservableCollection class that contains
+    /// elements copied from the specified collection and has sufficient capacity
+    /// to accommodate the number of elements copied.
+    /// </summary>
+    /// <param name="collection">The collection whose elements are copied to the new list.</param>
+    /// <remarks>
+    /// The elements are copied onto the ObservableCollection in the
+    /// same order they are read by the enumerator of the collection.
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"> collection is a null reference </exception>
+    public RangeObservableCollection(IEnumerable<T> collection) : base(collection) { }
+
+    /// <summary>
+    /// Initializes a new instance of the ObservableCollection class
+    /// that contains elements copied from the specified list
+    /// </summary>
+    /// <param name="list">The list whose elements are copied to the new list.</param>
+    /// <remarks>
+    /// The elements are copied onto the ObservableCollection in the
+    /// same order they are read by the enumerator of the list.
+    /// </remarks>
+    /// <exception cref="ArgumentNullException"> list is a null reference </exception>
+    public RangeObservableCollection(List<T> list) : base(list) { }
+
+    #endregion Constructors
+
+    //------------------------------------------------------
+    //
+    //  Public Properties
+    //
+    //------------------------------------------------------
+
+    #region Public Properties
+    EqualityComparer<T>? _Comparer;
+    public EqualityComparer<T> Comparer
+    {
+      get => _Comparer ??= EqualityComparer<T>.Default;
+      private set => _Comparer = value;
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this collection acts as a <see cref="HashSet{T}"/>,
+    /// disallowing duplicate items, based on <see cref="Comparer"/>.
+    /// This might indeed consume background performance, but in the other hand,
+    /// it will pay off in UI performance as less required UI updates are required.
+    /// </summary>
+    public bool AllowDuplicates { get; set; } = true;
+
+    #endregion Public Properties
+
+    //------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    //------------------------------------------------------
+
+    #region Public Methods
+
+    /// <summary>
+    /// Adds the elements of the specified collection to the end of the <see cref="ObservableCollection{T}"/>.
+    /// </summary>
+    /// <param name="collection">
+    /// The collection whose elements should be added to the end of the <see cref="ObservableCollection{T}"/>.
+    /// The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type.
+    /// </param>
+    /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
+    public void AddRange(IEnumerable<T> collection)
+    {
+      InsertRange(Count, collection);
+    }
+
+    /// <summary>
+    /// Inserts the elements of a collection into the <see cref="ObservableCollection{T}"/> at the specified index.
+    /// </summary>
+    /// <param name="index">The zero-based index at which the new elements should be inserted.</param>
+    /// <param name="collection">The collection whose elements should be inserted into the List<T>.
+    /// The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type.</param>                
+    /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is not in the collection range.</exception>
+    public void InsertRange(int index, IEnumerable<T> collection)
+    {
+      if (collection == null)
+        throw new ArgumentNullException(nameof(collection));
+      if (index < 0)
+        throw new ArgumentOutOfRangeException(nameof(index));
+      if (index > Count)
+        throw new ArgumentOutOfRangeException(nameof(index));
+
+      if (!AllowDuplicates)
+        collection =
+          collection
+          .Distinct(Comparer)
+          .Where(item => !Items.Contains(item, Comparer))
+          .ToList();
+
+      if (collection is ICollection<T> countable)
+      {
+        if (countable.Count == 0)
+          return;
+      }
+      else if (!collection.Any())
+        return;
+
+      CheckReentrancy();
+
+      //expand the following couple of lines when adding more constructors.
+      var target = (List<T>)Items;
+      target.InsertRange(index, collection);
+
+      OnEssentialPropertiesChanged();
+
+      if (!(collection is IList list))
+        list = new List<T>(collection);
+
+      OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, list, index));
+    }
+
+
+    /// <summary> 
+    /// Removes the first occurence of each item in the specified collection from the <see cref="ObservableCollection{T}"/>.
+    /// </summary>
+    /// <param name="collection">The items to remove.</param>        
+    /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
+    public void RemoveRange(IEnumerable<T> collection)
+    {
+      if (collection == null)
+        throw new ArgumentNullException(nameof(collection));
+
+      if (Count == 0)
+        return;
+      else if (collection is ICollection<T> countable)
+      {
+        if (countable.Count == 0)
+          return;
+        else if (countable.Count == 1)
+          using (IEnumerator<T> enumerator = countable.GetEnumerator())
+          {
+            enumerator.MoveNext();
+            Remove(enumerator.Current);
+            return;
+          }
+      }
+      else if (!collection.Any())
+        return;
+
+      CheckReentrancy();
+
+      var clusters = new Dictionary<int, List<T>>();
+      var lastIndex = -1;
+      List<T>? lastCluster = null;
+      foreach (T item in collection)
+      {
+        var index = IndexOf(item);
+        if (index < 0)
+          continue;
+
+        Items.RemoveAt(index);
+
+        if (lastIndex == index && lastCluster != null)
+          lastCluster.Add(item);
+        else
+          clusters[lastIndex = index] = lastCluster = new List<T> { item };
+      }
+
+      OnEssentialPropertiesChanged();
+
+      if (Count == 0)
+        OnCollectionReset();
+      else
+        foreach (KeyValuePair<int, List<T>> cluster in clusters)
+          OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, cluster.Value, cluster.Key));
+
+    }
+
+    /// <summary>
+    /// Iterates over the collection and removes all items that satisfy the specified match.
+    /// </summary>
+    /// <remarks>The complexity is O(n).</remarks>
+    /// <param name="match"></param>
+    /// <returns>Returns the number of elements that where </returns>
+    /// <exception cref="ArgumentNullException"><paramref name="match"/> is null.</exception>
+    public int RemoveAll(Predicate<T> match)
+    {
+      return RemoveAll(0, Count, match);
+    }
+
+    /// <summary>
+    /// Iterates over the specified range within the collection and removes all items that satisfy the specified match.
+    /// </summary>
+    /// <remarks>The complexity is O(n).</remarks>
+    /// <param name="index">The index of where to start performing the search.</param>
+    /// <param name="count">The number of items to iterate on.</param>
+    /// <param name="match"></param>
+    /// <returns>Returns the number of elements that where </returns>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is out of range.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is out of range.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="match"/> is null.</exception>
+    public int RemoveAll(int index, int count, Predicate<T> match)
+    {
+      if (index < 0)
+        throw new ArgumentOutOfRangeException(nameof(index));
+      if (count < 0)
+        throw new ArgumentOutOfRangeException(nameof(count));
+      if (index + count > Count)
+        throw new ArgumentOutOfRangeException(nameof(index));
+      if (match == null)
+        throw new ArgumentNullException(nameof(match));
+
+      if (Count == 0)
+        return 0;
+
+      List<T>? cluster = null;
+      var clusterIndex = -1;
+      var removedCount = 0;
+
+      using (BlockReentrancy())
+      using (DeferEvents())
+      {
+        for (var i = 0; i < count; i++, index++)
+        {
+          T item = Items[index];
+          if (match(item))
+          {
+            Items.RemoveAt(index);
+            removedCount++;
+
+            if (clusterIndex == index)
+            {
+              Debug.Assert(cluster != null);
+              cluster!.Add(item);
+            }
+            else
+            {
+              cluster = new List<T> { item };
+              clusterIndex = index;
+            }
+
+            index--;
+          }
+          else if (clusterIndex > -1)
+          {
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, cluster, clusterIndex));
+            clusterIndex = -1;
+            cluster = null;
+          }
+        }
+
+        if (clusterIndex > -1)
+          OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, cluster, clusterIndex));
+      }
+
+      if (removedCount > 0)
+        OnEssentialPropertiesChanged();
+
+      return removedCount;
+    }
+
+    /// <summary>
+    /// Removes a range of elements from the <see cref="ObservableCollection{T}"/>>.
+    /// </summary>
+    /// <param name="index">The zero-based starting index of the range of elements to remove.</param>
+    /// <param name="count">The number of elements to remove.</param>
+    /// <exception cref="ArgumentOutOfRangeException">The specified range is exceeding the collection.</exception>
+    public void RemoveRange(int index, int count)
+    {
+      if (index < 0)
+        throw new ArgumentOutOfRangeException(nameof(index));
+      if (count < 0)
+        throw new ArgumentOutOfRangeException(nameof(count));
+      if (index + count > Count)
+        throw new ArgumentOutOfRangeException(nameof(index));
+
+      if (count == 0)
+        return;
+
+      if (count == 1)
+      {
+        RemoveItem(index);
+        return;
+      }
+
+      //Items will always be List<T>, see constructors
+      var items = (List<T>)Items;
+      List<T> removedItems = items.GetRange(index, count);
+
+      CheckReentrancy();
+
+      items.RemoveRange(index, count);
+
+      OnEssentialPropertiesChanged();
+
+      if (Count == 0)
+        OnCollectionReset();
+      else
+        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removedItems, index));
+    }
+
+    /// <summary> 
+    /// Clears the current collection and replaces it with the specified collection,
+    /// using <see cref="Comparer"/>.
+    /// </summary>             
+    /// <param name="collection">The items to fill the collection with, after clearing it.</param>
+    /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
+    public void ReplaceRange(IEnumerable<T> collection)
+    {
+      ReplaceRange(0, Count, collection);
+    }
+
+    /// <summary>
+    /// Removes the specified range and inserts the specified collection in its position, leaving equal items in equal positions intact.
+    /// </summary>
+    /// <param name="index">The index of where to start the replacement.</param>
+    /// <param name="count">The number of items to be replaced.</param>
+    /// <param name="collection">The collection to insert in that location.</param>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is out of range.</exception>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is out of range.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="collection"/> is null.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is null.</exception>
+    public void ReplaceRange(int index, int count, IEnumerable<T> collection)
+    {
+      if (index < 0)
+        throw new ArgumentOutOfRangeException(nameof(index));
+      if (count < 0)
+        throw new ArgumentOutOfRangeException(nameof(count));
+      if (index + count > Count)
+        throw new ArgumentOutOfRangeException(nameof(index));
+
+      if (collection == null)
+        throw new ArgumentNullException(nameof(collection));
+
+      if (!AllowDuplicates)
+        collection =
+          collection
+          .Distinct(Comparer)
+          .ToList();
+
+      if (collection is ICollection<T> countable)
+      {
+        if (countable.Count == 0)
+        {
+          RemoveRange(index, count);
+          return;
+        }
+      }
+      else if (!collection.Any())
+      {
+        RemoveRange(index, count);
+        return;
+      }
+
+      if (index + count == 0)
+      {
+        InsertRange(0, collection);
+        return;
+      }
+
+      if (!(collection is IList<T> list))
+        list = new List<T>(collection);
+
+      using (BlockReentrancy())
+      using (DeferEvents())
+      {
+        var rangeCount = index + count;
+        var addedCount = list.Count;
+
+        var changesMade = false;
+        List<T>?
+          newCluster = null,
+          oldCluster = null;
+
+
+        int i = index;
+        for (; i < rangeCount && i - index < addedCount; i++)
+        {
+          //parallel position
+          T old = this[i], @new = list[i - index];
+          if (Comparer.Equals(old, @new))
+          {
+            OnRangeReplaced(i, newCluster!, oldCluster!);
+            continue;
+          }
+          else
+          {
+            Items[i] = @new;
+
+            if (newCluster == null)
+            {
+              Debug.Assert(oldCluster == null);
+              newCluster = new List<T> { @new };
+              oldCluster = new List<T> { old };
+            }
+            else
+            {
+              newCluster.Add(@new);
+              oldCluster!.Add(old);
+            }
+
+            changesMade = true;
+          }
+        }
+
+        OnRangeReplaced(i, newCluster!, oldCluster!);
+
+        //exceeding position
+        if (count != addedCount)
+        {
+          var items = (List<T>)Items;
+          if (count > addedCount)
+          {
+            var removedCount = rangeCount - addedCount;
+            T[] removed = new T[removedCount];
+            items.CopyTo(i, removed, 0, removed.Length);
+            items.RemoveRange(i, removedCount);
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, removed, i));
+          }
+          else
+          {
+            var k = i - index;
+            T[] added = new T[addedCount - k];
+            for (int j = k; j < addedCount; j++)
+            {
+              T @new = list[j];
+              added[j - k] = @new;
+            }
+            items.InsertRange(i, added);
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, added, i));
+          }
+
+          OnEssentialPropertiesChanged();
+        }
+        else if (changesMade)
+        {
+          OnIndexerPropertyChanged();
+        }
+      }
+    }
+
+    #endregion Public Methods
+
+
+    //------------------------------------------------------
+    //
+    //  Protected Methods
+    //
+    //------------------------------------------------------
+
+    #region Protected Methods
+
+    /// <summary>
+    /// Called by base class Collection&lt;T&gt; when the list is being cleared;
+    /// raises a CollectionChanged event to any listeners.
+    /// </summary>
+    protected override void ClearItems()
+    {
+      if (Count == 0)
+        return;
+
+      CheckReentrancy();
+      base.ClearItems();
+      OnEssentialPropertiesChanged();
+      OnCollectionReset();
+    }
+
+    /// <inheritdoc/>
+    protected override void InsertItem(int index, T item)
+    {
+      if (!AllowDuplicates && Items.Contains(item))
+        return;
+
+      base.InsertItem(index, item);
+    }
+
+    /// <inheritdoc/>
+    protected override void SetItem(int index, T item)
+    {
+      if (AllowDuplicates)
+      {
+        if (Comparer.Equals(this[index], item))
+          return;
+      }
+      else
+        if (Items.Contains(item, Comparer))
+        return;
+
+      CheckReentrancy();
+      T oldItem = this[index];
+      base.SetItem(index, item);
+
+      OnIndexerPropertyChanged();
+      OnCollectionChanged(NotifyCollectionChangedAction.Replace, oldItem!, item!, index);
+    }
+
+    /// <summary>
+    /// Raise CollectionChanged event to any listeners.
+    /// Properties/methods modifying this ObservableCollection will raise
+    /// a collection changed event through this virtual method.
+    /// </summary>
+    /// <remarks>
+    /// When overriding this method, either call its base implementation
+    /// or call <see cref="BlockReentrancy"/> to guard against reentrant collection changes.
+    /// </remarks>
+    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+    {
+      if (_deferredEvents != null)
+      {
+        _deferredEvents.Add(e);
+        return;
+      }
+      base.OnCollectionChanged(e);
+    }
+
+    protected virtual IDisposable DeferEvents() => new DeferredEventsCollection(this);
+
+    #endregion Protected Methods
+
+
+    //------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    //------------------------------------------------------
+
+    #region Private Methods
+
+    /// <summary>
+    /// Helper to raise Count property and the Indexer property.
+    /// </summary>
+    void OnEssentialPropertiesChanged()
+    {
+      OnPropertyChanged(EventArgsCache.CountPropertyChanged);
+      OnIndexerPropertyChanged();
+    }
+
+    /// <summary>
+    /// /// Helper to raise a PropertyChanged event for the Indexer property
+    /// /// </summary>
+    void OnIndexerPropertyChanged() =>
+     OnPropertyChanged(EventArgsCache.IndexerPropertyChanged);
+
+    /// <summary>
+    /// Helper to raise CollectionChanged event to any listeners
+    /// </summary>
+    void OnCollectionChanged(NotifyCollectionChangedAction action, object oldItem, object newItem, int index) =>
+     OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index));
+
+    /// <summary>
+    /// Helper to raise CollectionChanged event with action == Reset to any listeners
+    /// </summary>
+    void OnCollectionReset() =>
+     OnCollectionChanged(EventArgsCache.ResetCollectionChanged);
+
+    /// <summary>
+    /// Helper to raise event for clustered action and clear cluster.
+    /// </summary>
+    /// <param name="followingItemIndex">The index of the item following the replacement block.</param>
+    /// <param name="newCluster"></param>
+    /// <param name="oldCluster"></param>
+    //TODO should have really been a local method inside ReplaceRange(int index, int count, IEnumerable<T> collection, IEqualityComparer<T> comparer),
+    //move when supported language version updated.
+    void OnRangeReplaced(int followingItemIndex, ICollection<T> newCluster, ICollection<T> oldCluster)
+    {
+      if (oldCluster == null || oldCluster.Count == 0)
+      {
+        Debug.Assert(newCluster == null || newCluster.Count == 0);
+        return;
+      }
+
+      OnCollectionChanged(
+        new NotifyCollectionChangedEventArgs(
+          NotifyCollectionChangedAction.Replace,
+          new List<T>(newCluster),
+          new List<T>(oldCluster),
+          followingItemIndex - oldCluster.Count));
+
+      oldCluster.Clear();
+      newCluster.Clear();
+    }
+
+    #endregion Private Methods
+
+    //------------------------------------------------------
+    //
+    //  Private Types
+    //
+    //------------------------------------------------------
+
+    #region Private Types
+    sealed class DeferredEventsCollection : List<NotifyCollectionChangedEventArgs>, IDisposable
+    {
+      readonly RangeObservableCollection<T> _collection;
+      public DeferredEventsCollection(RangeObservableCollection<T> collection)
+      {
+        Debug.Assert(collection != null);
+        Debug.Assert(collection._deferredEvents == null);
+        _collection = collection;
+        _collection._deferredEvents = this;
+      }
+
+      public void Dispose()
+      {
+        _collection._deferredEvents = null;
+        foreach (var args in this)
+          _collection.OnCollectionChanged(args);
+      }
+    }
+
+    #endregion Private Types
+
+  }
+
+  /// <remarks>
+  /// To be kept outside <see cref="ObservableCollection{T}"/>, since otherwise, a new instance will be created for each generic type used.
+  /// </remarks>
+  internal static class EventArgsCache
+  {
+    internal static readonly PropertyChangedEventArgs CountPropertyChanged = new PropertyChangedEventArgs("Count");
+    internal static readonly PropertyChangedEventArgs IndexerPropertyChanged = new PropertyChangedEventArgs("Item[]");
+    internal static readonly NotifyCollectionChangedEventArgs ResetCollectionChanged = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
+  }
+}

PixiEditor/Models/DataHolders/Surface.cs

@@ -23,6 +23,8 @@ namespace PixiEditor.Models.DataHolders
         public int Width { get; }
         public int Height { get; }
 
+        public bool Disposed { get; private set; } = false;
+
         private SKPaint drawingPaint = new SKPaint() { BlendMode = SKBlendMode.Src };
         private IntPtr surfaceBuffer;
 
@@ -152,6 +154,9 @@ namespace PixiEditor.Models.DataHolders
 
         public void Dispose()
         {
+            if (Disposed)
+                return;
+            Disposed = true;
             SkiaSurface.Dispose();
             drawingPaint.Dispose();
             Marshal.FreeHGlobal(surfaceBuffer);

PixiEditor/Models/DataHolders/WpfObservableRangeCollection.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Windows.Data;
+
+namespace PixiEditor.Models.DataHolders
+{
+public class WpfObservableRangeCollection<T> : RangeObservableCollection<T>
+{
+        public bool SuppressNotify { get; set; } = false;
+  DeferredEventsCollection _deferredEvents;
+
+  public WpfObservableRangeCollection()
+  {
+  }
+
+  public WpfObservableRangeCollection(IEnumerable<T> collection) : base(collection)
+  {
+  }
+
+  public WpfObservableRangeCollection(List<T> list) : base(list)
+  {
+  }
+
+
+  /// <summary>
+  /// Raise CollectionChanged event to any listeners.
+  /// Properties/methods modifying this ObservableCollection will raise
+  /// a collection changed event through this virtual method.
+  /// </summary>
+  /// <remarks>
+  /// When overriding this method, either call its base implementation
+  /// or call <see cref="BlockReentrancy"/> to guard against reentrant collection changes.
+  /// </remarks>
+  protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
+  {
+            if (SuppressNotify) return;
+    var _deferredEvents = (ICollection<NotifyCollectionChangedEventArgs>) typeof(RangeObservableCollection<T>)
+      .GetField("_deferredEvents", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this);
+    if (_deferredEvents != null)
+    {
+      _deferredEvents.Add(e);
+      return;
+    }
+
+    foreach (var handler in GetHandlers())
+      if (IsRange(e) && handler.Target is CollectionView cv)
+        cv.Refresh();
+      else
+        handler(this, e);
+  }
+
+  protected override IDisposable DeferEvents() => new DeferredEventsCollection(this);
+
+  bool IsRange(NotifyCollectionChangedEventArgs e) => e.NewItems?.Count > 1 || e.OldItems?.Count > 1;
+
+  IEnumerable<NotifyCollectionChangedEventHandler> GetHandlers()
+  {
+    var info = typeof(ObservableCollection<T>).GetField(nameof(CollectionChanged),
+      BindingFlags.Instance | BindingFlags.NonPublic);
+    var @event = (MulticastDelegate) info.GetValue(this);
+    return @event?.GetInvocationList()
+             .Cast<NotifyCollectionChangedEventHandler>()
+             .Distinct()
+           ?? Enumerable.Empty<NotifyCollectionChangedEventHandler>();
+  }
+
+  class DeferredEventsCollection : List<NotifyCollectionChangedEventArgs>, IDisposable
+  {
+    private readonly WpfObservableRangeCollection<T> _collection;
+
+    public DeferredEventsCollection(WpfObservableRangeCollection<T> collection)
+    {
+      Debug.Assert(collection != null);
+      Debug.Assert(collection._deferredEvents == null);
+      _collection = collection;
+      _collection._deferredEvents = this;
+    }
+
+    public void Dispose()
+    {
+      _collection._deferredEvents = null;
+
+      var handlers = _collection
+        .GetHandlers()
+        .ToLookup(h => h.Target is CollectionView);
+
+      foreach (var handler in handlers[false])
+      foreach (var e in this)
+        handler(_collection, e);
+
+      foreach (var cv in handlers[true]
+                 .Select(h => h.Target)
+                 .Cast<CollectionView>()
+                 .Distinct())
+        cv.Refresh();
+    }
+  }
+}
+}

PixiEditor/Models/Dialogs/NewFileDialog.cs

@@ -1,53 +1,42 @@
-using System;
-using System.Windows;
-using PixiEditor.Models.UserPreferences;
+using PixiEditor.Models.UserPreferences;
 using PixiEditor.Views;
 
 namespace PixiEditor.Models.Dialogs
 {
     public class NewFileDialog : CustomDialog
     {
-        private int height = (int)IPreferences.Current.GetPreference("DefaultNewFileHeight", 16L);
+        public const int defaultSize = 64;
 
-        private int width = (int)IPreferences.Current.GetPreference("DefaultNewFileWidth", 16L);
+        private int height = IPreferences.Current.GetPreference("DefaultNewFileHeight", defaultSize);
+
+        private int width = IPreferences.Current.GetPreference("DefaultNewFileWidth", defaultSize);
 
         public int Width
         {
             get => width;
-            set
-            {
-                if (width != value)
-                {
-                    width = value;
-                    RaisePropertyChanged("Width");
-                }
-            }
+            set => SetProperty(ref width, value);
         }
 
         public int Height
         {
             get => height;
-            set
-            {
-                if (height != value)
-                {
-                    height = value;
-                    RaisePropertyChanged("Height");
-                }
-            }
+            set => SetProperty(ref height, value);
         }
 
         public override bool ShowDialog()
         {
-            Window popup = new NewFilePopup()
+            NewFilePopup popup = new()
             {
                 FileWidth = Width,
                 FileHeight = Height
             };
+
             popup.ShowDialog();
-            Height = (popup as NewFilePopup).FileHeight;
-            Width = (popup as NewFilePopup).FileWidth;
-            return (bool)popup.DialogResult;
+
+            Height = popup.FileHeight;
+            Width = popup.FileWidth;
+
+            return popup.DialogResult.GetValueOrDefault();
         }
     }
 }

PixiEditor/Models/Layers/GuidStructureItem.cs

@@ -146,7 +146,9 @@ namespace PixiEditor.Models.Layers
             {
                 GroupGuid = GroupGuid,
                 IsExpanded = isExpanded,
-                IsRenaming = isRenaming
+                IsRenaming = isRenaming,
+                IsVisible = isVisible,
+                Opacity = opacity
             };
 
             if(Subgroups.Count > 0)

PixiEditor/Models/Layers/LayerStructure.cs

@@ -18,7 +18,7 @@ namespace PixiEditor.Models.Layers
     {
         public event EventHandler<LayerStructureChangedEventArgs> LayerStructureChanged;
 
-        public ObservableCollection<GuidStructureItem> Groups { get; set; }
+        public WpfObservableRangeCollection<GuidStructureItem> Groups { get; set; }
 
         private Document Owner { get; }
 
@@ -38,9 +38,9 @@ namespace PixiEditor.Models.Layers
         /// </summary>
         /// <param name="groups">Groups to clone.</param>
         /// <returns>ObservableCollection with cloned groups.</returns>
-        public static ObservableCollection<GuidStructureItem> CloneGroups(ObservableCollection<GuidStructureItem> groups)
+        public static WpfObservableRangeCollection<GuidStructureItem> CloneGroups(WpfObservableRangeCollection<GuidStructureItem> groups)
         {
-            ObservableCollection<GuidStructureItem> outputGroups = new();
+            WpfObservableRangeCollection<GuidStructureItem> outputGroups = new();
             foreach (var group in groups.ToArray())
             {
                 outputGroups.Add(group.CloneGroup());
@@ -69,7 +69,7 @@ namespace PixiEditor.Models.Layers
             return GetGroupByGuid(groupGuid, Groups);
         }
 
-        public ObservableCollection<GuidStructureItem> CloneGroups()
+        public WpfObservableRangeCollection<GuidStructureItem> CloneGroups()
         {
             return CloneGroups(Groups);
         }
@@ -709,7 +709,7 @@ namespace PixiEditor.Models.Layers
             return null;
         }
 
-        public LayerStructure(ObservableCollection<GuidStructureItem> items, Document owner)
+        public LayerStructure(WpfObservableRangeCollection<GuidStructureItem> items, Document owner)
         {
             Groups = items;
             Owner = owner;
@@ -717,7 +717,7 @@ namespace PixiEditor.Models.Layers
 
         public LayerStructure(Document owner)
         {
-            Groups = new ObservableCollection<GuidStructureItem>();
+            Groups = new WpfObservableRangeCollection<GuidStructureItem>();
             Owner = owner;
         }
     }

PixiEditor/Models/Layers/StructuredLayerTree.cs

@@ -4,6 +4,7 @@ using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using PixiEditor.Models.DataHolders;
 
 namespace PixiEditor.Models.Layers
 {
@@ -11,16 +12,14 @@ namespace PixiEditor.Models.Layers
     {
         private List<Guid> layersInStructure = new();
 
-        public ObservableCollection<object> RootDirectoryItems { get; } = new ObservableCollection<object>();
+        public WpfObservableRangeCollection<object> RootDirectoryItems { get; } = new WpfObservableRangeCollection<object>();
 
         private static void Swap(ref int startIndex, ref int endIndex)
         {
-            int tmp = startIndex;
-            startIndex = endIndex;
-            endIndex = tmp;
+            (startIndex, endIndex) = (endIndex, startIndex);
         }
 
-        public StructuredLayerTree(ObservableCollection<Layer> layers, LayerStructure structure)
+        public StructuredLayerTree(WpfObservableRangeCollection<Layer> layers, LayerStructure structure)
         {
             if (layers == null || structure == null)
             {

PixiEditor/Models/Tools/BitmapOperationTool.cs

@@ -1,13 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Windows.Documents;
-using System.Windows.Input;
-using System.Windows.Media;
-using PixiEditor.Models.DataHolders;
+using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Undo;
 using SkiaSharp;
+using System.Collections.Generic;
 
 namespace PixiEditor.Models.Tools
 {
@@ -18,33 +14,40 @@ namespace PixiEditor.Models.Tools
         public bool ClearPreviewLayerOnEachIteration { get; set; } = true;
 
         public bool UseDefaultUndoMethod { get; set; } = true;
-        public virtual bool UsesShift => true;
 
         private StorageBasedChange _change;
 
-        public abstract void Use(Layer layer, List<Coordinates> mouseMove, SKColor color);
+        public abstract void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color);
+
+        public override void BeforeUse()
+        {
+            if (UseDefaultUndoMethod)
+            {
+                Document doc = ViewModels.ViewModelMain.Current.BitmapManager.ActiveDocument;
+                _change = new StorageBasedChange(doc, new[] { doc.ActiveLayer }, true);
+            }
+        }
 
         /// <summary>
         /// Executes undo adding procedure.
         /// </summary>
-        /// <param name="document">Active document</param>
         /// <remarks>When overriding, set UseDefaultUndoMethod to false.</remarks>
-        public override void AddUndoProcess(Document document)
+        public override void AfterUse()
         {
-            if (!UseDefaultUndoMethod) return;
-
+            if (!UseDefaultUndoMethod)
+                return;
+            var document = ViewModels.ViewModelMain.Current.BitmapManager.ActiveDocument;
             var args = new object[] { _change.Document };
-            document.UndoManager.AddUndoChange(_change.ToChange(StorageBasedChange.BasicUndoProcess, args));
+            document.UndoManager.AddUndoChange(_change.ToChange(UndoStorageBasedChange, args));
             _change = null;
         }
 
-        public override void OnRecordingLeftMouseDown(MouseEventArgs e)
+        private void UndoStorageBasedChange(Layer[] layers, UndoLayer[] data, object[] args)
         {
-            if (UseDefaultUndoMethod && e.LeftButton == MouseButtonState.Pressed)
-            {
-                Document doc = ViewModels.ViewModelMain.Current.BitmapManager.ActiveDocument;
-                _change = new StorageBasedChange(doc, new[] { doc.ActiveLayer }, true);
-            }
+            Document document = (Document)args[0];
+            var ls = document.LayerStructure.CloneGroups();
+            StorageBasedChange.BasicUndoProcess(layers, data, args);
+            document.BuildLayerStructureProcess(new object[] { ls });
         }
     }
 }

PixiEditor/Models/Tools/ReadonlyTool.cs

@@ -1,10 +1,10 @@
-using System.Collections.Generic;
-using PixiEditor.Models.Position;
+using PixiEditor.Models.Position;
+using System.Collections.Generic;
 
 namespace PixiEditor.Models.Tools
 {
     public abstract class ReadonlyTool : Tool
     {
-        public abstract void Use(List<Coordinates> pixels);
+        public abstract void Use(IReadOnlyList<Coordinates> pixels);
     }
-}
+}

PixiEditor/Models/Tools/ShapeTool.cs

@@ -1,10 +1,8 @@
-using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings.Toolbars;
 using SkiaSharp;
 using System.Collections.Generic;
-using System.Linq;
 using System.Windows.Input;
 
 namespace PixiEditor.Models.Tools
@@ -55,9 +53,6 @@ namespace PixiEditor.Models.Tools
             Toolbar = new BasicShapeToolbar();
         }
 
-        // TODO: Add cache for lines 31, 32 (hopefully it would speed up calculation)
-        public abstract override void Use(Layer layer, List<Coordinates> coordinates, SKColor color);
-
         public static void ThickenShape(Layer layer, SKColor color, IEnumerable<Coordinates> shape, int thickness)
         {
             foreach (Coordinates item in shape)

PixiEditor/Models/Tools/Tool.cs

@@ -1,19 +1,11 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows;
-using System.Windows.Input;
-using PixiEditor.Helpers;
+using PixiEditor.Helpers;
 using PixiEditor.Helpers.Extensions;
 using PixiEditor.Models.Controllers;
-using PixiEditor.Models.DataHolders;
-using PixiEditor.Models.Layers;
-using PixiEditor.Models.Position;
-using PixiEditor.Models.Tools.ToolSettings;
-using PixiEditor.Models.Tools.ToolSettings.Toolbars;
-using PixiEditor.Models.Undo;
-
-namespace PixiEditor.Models.Tools
+using PixiEditor.Models.Tools.ToolSettings;
+using PixiEditor.Models.Tools.ToolSettings.Toolbars;
+using System.Windows.Input;
+
+namespace PixiEditor.Models.Tools
 {
     public abstract class Tool : NotifyableObject
     {
@@ -25,6 +17,8 @@ namespace PixiEditor.Models.Tools
 
         public virtual bool HideHighlight { get; }
 
+        public virtual bool RequiresPreciseMouseData { get; }
+
         public abstract string Tooltip { get; }
 
         public string ActionDisplay
@@ -51,53 +45,20 @@ namespace PixiEditor.Models.Tools
 
         public Toolbar Toolbar { get; set; } = new EmptyToolbar();
 
-        public bool CanStartOutsideCanvas { get; set; } = false;
+        public ToolSession Session { get; set; }
 
         private bool isActive;
         private string actionDisplay = string.Empty;
 
-        public virtual void OnMouseDown(MouseEventArgs e)
-        {
-        }
 
-        public virtual void AddUndoProcess(Document document)
-        {
-        }
+        public virtual void OnKeyDown(Key key) { }
 
-        public virtual void OnMouseUp(MouseEventArgs e)
-        {
-        }
+        public virtual void OnKeyUp(Key key) { }
 
-        public virtual void OnKeyDown(KeyEventArgs e)
-        {
-        }
+        public virtual void BeforeUse() { }
 
-        public virtual void OnKeyUp(KeyEventArgs e)
-        {
-        }
-
-        public virtual void OnStart(Coordinates clickPosition)
-        {
-        }
+        public virtual void AfterUse() { }
 
-        public virtual void OnRecordingLeftMouseDown(MouseEventArgs e)
-        {
-        }
-
-        public virtual void OnStoppedRecordingMouseUp(MouseEventArgs e)
-        {
-        }
-
-        public virtual void OnMouseMove(MouseEventArgs e)
-        {
-        }
-
-        public virtual void OnSelected()
-        {
-        }
-
-        public virtual void OnDeselected()
-        {
-        }
-    }
-}
+        public virtual void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown) { }
+    }
+}

PixiEditor/Models/Tools/ToolSettings/Settings/BoolSetting.cs

@@ -2,17 +2,15 @@
 using System.Windows.Controls;
 using System.Windows.Controls.Primitives;
 using System.Windows.Data;
-
+using System.Windows.Media;
+
 namespace PixiEditor.Models.Tools.ToolSettings.Settings
 {
     public class BoolSetting : Setting<bool>
     {
         public BoolSetting(string name, string label = "")
-            : base(name)
+            : this(name, false, label)
         {
-            Label = label;
-            Value = false;
-            SettingControl = GenerateCheckBox();
         }
 
         public BoolSetting(string name, bool isChecked, string label = "")

PixiEditor/Models/Tools/ToolSettings/Settings/SizeSetting.cs

@@ -1,10 +1,6 @@
-using System.Windows;
-using System.Windows.Controls;
+using PixiEditor.Views;
+using System.Windows;
 using System.Windows.Data;
-using System.Windows.Interactivity;
-using PixiEditor.Helpers;
-using PixiEditor.Helpers.Behaviours;
-using PixiEditor.Views;
 
 namespace PixiEditor.Models.Tools.ToolSettings.Settings
 {
@@ -22,9 +18,11 @@ namespace PixiEditor.Models.Tools.ToolSettings.Settings
         {
             SizeInput tb = new SizeInput
             {
-                Width = 40,
+                Width = 65,
                 Height = 20,
-                FontSize = 12,
+                VerticalAlignment = VerticalAlignment.Center,
+                MaxSize = 9999,
+                IsEnabled = true
             };
 
             Binding binding = new Binding("Value")
@@ -35,4 +33,4 @@ namespace PixiEditor.Models.Tools.ToolSettings.Settings
             return tb;
         }
     }
-}
+}

PixiEditor/Models/Tools/Tools/BrightnessTool.cs

@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Windows.Input;
-using System.Linq;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
+using PixiEditor.Helpers;
 using PixiEditor.Helpers.Extensions;
 using PixiEditor.Models.Colors;
 using PixiEditor.Models.Enums;
@@ -12,8 +7,9 @@ using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings.Settings;
 using PixiEditor.Models.Tools.ToolSettings.Toolbars;
 using SkiaSharp;
+using System;
+using System.Collections.Generic;
 using System.Windows;
-using PixiEditor.Helpers;
 
 namespace PixiEditor.Models.Tools.Tools
 {
@@ -21,62 +17,52 @@ namespace PixiEditor.Models.Tools.Tools
     {
         private const float CorrectionFactor = 5f; // Initial correction factor
 
+        private readonly string defaultActionDisplay = "Draw on pixels to make them brighter. Hold Ctrl to darken.";
         private readonly List<Coordinates> pixelsVisited = new List<Coordinates>();
         private List<DoubleCoords> circleCache = new List<DoubleCoords>();
         private int cachedCircleSize = -1;
 
-        private string defaultActionDisplay = "Draw on pixels to make them brighter. Hold Ctrl to darken.";
         public BrightnessTool()
         {
             ActionDisplay = defaultActionDisplay;
             Toolbar = new BrightnessToolToolbar(CorrectionFactor);
         }
 
-        public override bool UsesShift => false;
-
         public override string Tooltip => "Makes pixels brighter or darker (U). Hold Ctrl to make pixels darker.";
 
         public BrightnessMode Mode { get; set; } = BrightnessMode.Default;
 
-        public override void OnRecordingLeftMouseDown(MouseEventArgs e)
-        {
-            base.OnRecordingLeftMouseDown(e);
-            pixelsVisited.Clear();
-        }
-
-        public override void OnKeyDown(KeyEventArgs e)
+        public override void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown)
         {
-            if (e.Key is Key.LeftCtrl or Key.RightCtrl)
-            {
+            if (!ctrlIsDown)
+                ActionDisplay = defaultActionDisplay;
+            else
                 ActionDisplay = "Draw on pixels to make them darker. Release Ctrl to brighten.";
-            }
         }
 
-        public override void OnKeyUp(KeyEventArgs e)
+        public override void BeforeUse()
         {
-            if (e.Key is Key.LeftCtrl or Key.RightCtrl)
-            {
-                ActionDisplay = defaultActionDisplay;
-            }
+            base.BeforeUse();
+            pixelsVisited.Clear();
         }
 
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
         {
             int toolSize = Toolbar.GetSetting<SizeSetting>("ToolSize").Value;
             float correctionFactor = Toolbar.GetSetting<FloatSetting>("CorrectionFactor").Value;
             Mode = Toolbar.GetEnumSetting<BrightnessMode>("BrightnessMode").Value;
 
-            if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
+            if (Session.IsCtrlDown)
             {
-                ChangeBrightness(layer, coordinates[0], toolSize, -correctionFactor);
+                ChangeBrightness(activeLayer, recordedMouseMovement[^1], toolSize, -correctionFactor);
             }
             else
             {
-                ChangeBrightness(layer, coordinates[0], toolSize, correctionFactor);
+                ChangeBrightness(activeLayer, recordedMouseMovement[^1], toolSize, correctionFactor);
             }
         }
 
-        public void ChangeBrightness(Layer layer, Coordinates coordinates, int toolSize, float correctionFactor)
+        private void ChangeBrightness(Layer layer, Coordinates coordinates, int toolSize, float correctionFactor)
         {
             if (cachedCircleSize != toolSize)
                 UpdateCircleCache(toolSize);
@@ -112,7 +98,7 @@ namespace PixiEditor.Models.Tools.Tools
             layer.InvokeLayerBitmapChange(dirtyRect);
         }
 
-        public void UpdateCircleCache(int newCircleSize)
+        private void UpdateCircleCache(int newCircleSize)
         {
             cachedCircleSize = newCircleSize;
             DoubleCoords rect = CoordinatesCalculator.CalculateThicknessCenter(new Coordinates(0, 0), newCircleSize);

PixiEditor/Models/Tools/Tools/CircleTool.cs

@@ -5,16 +5,44 @@ using PixiEditor.Models.Tools.ToolSettings.Settings;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Windows;
-using System.Windows.Input;
 using System.Windows.Media;
 
 namespace PixiEditor.Models.Tools.Tools
 {
     public class CircleTool : ShapeTool
     {
+        private string defaultActionDisplay = "Click and move mouse to draw a circle. Hold Shift to draw an even one.";
+
+        public CircleTool()
+        {
+            ActionDisplay = defaultActionDisplay;
+        }
+
+        public override string Tooltip => "Draws circle on canvas (C). Hold Shift to draw even circle.";
+
+        public override void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown)
+        {
+            if (shiftIsDown)
+                ActionDisplay = "Click and move mouse to draw an even circle.";
+            else
+                ActionDisplay = defaultActionDisplay;
+        }
+
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
+        {
+            int thickness = Toolbar.GetSetting<SizeSetting>("ToolSize").Value;
+            var hasFillColor = Toolbar.GetSetting<BoolSetting>("Fill").Value;
+            Color temp = Toolbar.GetSetting<ColorSetting>("FillColor").Value;
+            SKColor fill = new SKColor(temp.R, temp.G, temp.B, temp.A);
+
+            var (start, end) = Session.IsShiftDown ?
+                CoordinatesHelper.GetSquareCoordiantes(recordedMouseMovement) :
+                (recordedMouseMovement[0], recordedMouseMovement[^1]);
+
+            DrawEllipseFromCoordinates(previewLayer, start, end, color, fill, thickness, hasFillColor);
+        }
 
         public static void DrawEllipseFromCoordinates(Layer layer, Coordinates first, Coordinates second,
             SKColor color, SKColor fillColor, int thickness, bool hasFillColor)
@@ -92,40 +120,5 @@ namespace PixiEditor.Models.Tools.Tools
                 }
             }
         }
-
-        private string defaultActionDisplay = "Click and move mouse to draw a circle. Hold Shift to draw an even one.";
-
-        public CircleTool()
-        {
-            ActionDisplay = defaultActionDisplay;
-        }
-
-        public override string Tooltip => "Draws circle on canvas (C). Hold Shift to draw even circle.";
-
-        public override void OnKeyDown(KeyEventArgs e)
-        {
-            if (e.Key is Key.LeftShift or Key.RightShift)
-            {
-                ActionDisplay = "Click and move mouse to draw an even circle.";
-            }
-        }
-
-        public override void OnKeyUp(KeyEventArgs e)
-        {
-            if (e.Key is Key.LeftShift or Key.RightShift)
-            {
-                ActionDisplay = defaultActionDisplay;
-            }
-        }
-
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
-        {
-            int thickness = Toolbar.GetSetting<SizeSetting>("ToolSize").Value;
-            var hasFillColor = Toolbar.GetSetting<BoolSetting>("Fill").Value;
-            Color temp = Toolbar.GetSetting<ColorSetting>("FillColor").Value;
-            SKColor fill = new SKColor(temp.R, temp.G, temp.B, temp.A);
-            DrawEllipseFromCoordinates(layer, coordinates[^1], coordinates[0], color, fill, thickness, hasFillColor);
-        }
-
     }
 }

PixiEditor/Models/Tools/Tools/ColorPickerTool.cs

@@ -8,17 +8,14 @@ using PixiEditor.ViewModels;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Windows.Input;
-using static System.Math;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class ColorPickerTool : ReadonlyTool
+    internal class ColorPickerTool : ReadonlyTool
     {
         private readonly DocumentProvider _docProvider;
         private readonly BitmapManager _bitmapManager;
-        private readonly string defaultActionDisplay = "Click to pick colors from the canvas. Hold Ctrl to pick from the reference layer. Hold Ctrl and Alt to blend the reference and canvas color";
+        private readonly string defaultActionDisplay = "Click to pick colors. Hold Ctrl to hide the canvas. Hold Shift to hide the reference layer";
 
         public ColorPickerTool(DocumentProvider documentProvider, BitmapManager bitmapManager)
         {
@@ -29,11 +26,13 @@ namespace PixiEditor.Models.Tools.Tools
 
         public override bool HideHighlight => true;
 
+        public override bool RequiresPreciseMouseData => true;
+
         public override string Tooltip => "Picks the primary color from the canvas. (O)";
 
-        public override void Use(List<Coordinates> coordinates)
+        public override void Use(IReadOnlyList<Coordinates> recordedMouseMovement)
         {
-            var coords = coordinates.First();
+            var coords = recordedMouseMovement[^1];
             var doc = _docProvider.GetDocument();
             if (coords.X < 0 || coords.Y < 0 || coords.X >= doc.Width || coords.Y >= doc.Height)
                 return;
@@ -45,16 +44,16 @@ namespace PixiEditor.Models.Tools.Tools
         {
             Layer referenceLayer = _docProvider.GetReferenceLayer();
 
-            if (referenceLayer != null && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
+            if (referenceLayer != null && referenceLayer.IsVisible)
             {
                 double preciseX = _docProvider.GetDocument().MouseXOnCanvas;
                 double preciseY = _docProvider.GetDocument().MouseYOnCanvas;
 
-                if ((Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt)))
-                {
-                    return GetCombinedColor(x, y, preciseX, preciseY);
-                }
-                return GetReferenceColor(preciseX, preciseY);
+                if (Session.IsCtrlDown)
+                    return GetReferenceColor(preciseX, preciseY);
+                if (Session.IsShiftDown)
+                    return GetCanvasColor(x, y);
+                return GetCombinedColor(x, y, preciseX, preciseY);
             }
 
             return GetCanvasColor(x, y);
@@ -112,47 +111,32 @@ namespace PixiEditor.Models.Tools.Tools
             }
         }
 
-        public override void OnKeyDown(KeyEventArgs e)
-        {
-            UpdateActionDisplay();
-        }
-
-        public override void OnKeyUp(KeyEventArgs e)
-        {
-            UpdateActionDisplay();
-        }
-
-        public override void OnSelected()
-        {
-            UpdateActionDisplay();
-        }
-
-        public override void OnDeselected()
-        {
-            _bitmapManager.OnlyReferenceLayer = false;
-            _bitmapManager.HideReferenceLayer = false;
-        }
-
-        private void UpdateActionDisplay()
+        public override void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown)
         {
-            if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
+            if (!IsActive)
             {
-                if (Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt))
-                {
-                    _bitmapManager.HideReferenceLayer = false;
-                    _bitmapManager.OnlyReferenceLayer = false;
-                    ActionDisplay = "Click to pick colors from both the canvas and the reference layer blended together. Release Ctrl and Alt to pick from the canvas. Release just Alt to pick from the reference layer";
-                    return;
-                }
+                _bitmapManager.HideReferenceLayer = false;
+                _bitmapManager.OnlyReferenceLayer = false;
+                return;
+            }
 
+            if (ctrlIsDown)
+            {
                 _bitmapManager.HideReferenceLayer = false;
                 _bitmapManager.OnlyReferenceLayer = true;
-                ActionDisplay = "Click to pick colors from the reference layer. Release Ctrl to pick from the canvas. Hold Ctrl and Alt to blend the reference and canvas color";
+                ActionDisplay = "Click to pick colors from the reference layer.";
             }
-            else
+            else if (shiftIsDown)
             {
                 _bitmapManager.HideReferenceLayer = true;
                 _bitmapManager.OnlyReferenceLayer = false;
+                ActionDisplay = "Click to pick colors from the canvas.";
+                return;
+            }
+            else
+            {
+                _bitmapManager.HideReferenceLayer = false;
+                _bitmapManager.OnlyReferenceLayer = false;
                 ActionDisplay = defaultActionDisplay;
             }
         }

PixiEditor/Models/Tools/Tools/EraserTool.cs

@@ -8,7 +8,7 @@ using System.Collections.Generic;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class EraserTool : BitmapOperationTool
+    internal class EraserTool : BitmapOperationTool
     {
         private readonly PenTool pen;
 
@@ -18,20 +18,17 @@ namespace PixiEditor.Models.Tools.Tools
             Toolbar = new BasicToolbar();
             pen = new PenTool(bitmapManager);
         }
-
-        public override bool UsesShift => false;
-
         public override string Tooltip => "Erasers color from pixel. (E)";
 
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
         {
-            Erase(layer, coordinates, Toolbar.GetSetting<SizeSetting>("ToolSize").Value);
+            Erase(activeLayer, recordedMouseMovement, Toolbar.GetSetting<SizeSetting>("ToolSize").Value);
         }
 
-        public void Erase(Layer layer, List<Coordinates> coordinates, int toolSize)
+        public void Erase(Layer layer, IReadOnlyList<Coordinates> coordinates, int toolSize)
         {
-            Coordinates startingCords = coordinates.Count > 1 ? coordinates[1] : coordinates[0];
-            pen.Draw(layer, startingCords, coordinates[0], SKColors.Transparent, toolSize, false, null, SKBlendMode.Src);
+            Coordinates startingCords = coordinates.Count > 1 ? coordinates[^2] : coordinates[0];
+            pen.Draw(layer, startingCords, coordinates[^1], SKColors.Transparent, toolSize, false, null, SKBlendMode.Src);
         }
     }
 }

PixiEditor/Models/Tools/Tools/FloodFillTool.cs

@@ -4,12 +4,11 @@ using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using SkiaSharp;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Windows;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class FloodFillTool : BitmapOperationTool
+    internal class FloodFillTool : BitmapOperationTool
     {
         private BitmapManager BitmapManager { get; }
         private SKPaint fillPaint = new SKPaint() { BlendMode = SKBlendMode.Src };
@@ -22,17 +21,17 @@ namespace PixiEditor.Models.Tools.Tools
 
         public override string Tooltip => "Fills area with color. (G)";
 
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
         {
-            if (layer.IsReset)
+            if (activeLayer.IsReset)
             {
-                layer.DynamicResizeAbsolute(new(0, 0, BitmapManager.ActiveDocument.Width, BitmapManager.ActiveDocument.Height));
-                layer.LayerBitmap.SkiaSurface.Canvas.Clear(color);
-                layer.InvokeLayerBitmapChange();
+                activeLayer.DynamicResizeAbsolute(new(0, 0, BitmapManager.ActiveDocument.Width, BitmapManager.ActiveDocument.Height));
+                activeLayer.LayerBitmap.SkiaSurface.Canvas.Clear(color);
+                activeLayer.InvokeLayerBitmapChange();
             }
             else
             {
-                LinearFill(layer, coordinates[0], color);
+                LinearFill(activeLayer, recordedMouseMovement[^1], color);
             }
         }
 

PixiEditor/Models/Tools/Tools/LineTool.cs

@@ -1,4 +1,5 @@
-using PixiEditor.Models.Layers;
+using PixiEditor.Helpers;
+using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings.Settings;
 using PixiEditor.Models.Tools.ToolSettings.Toolbars;
@@ -6,35 +7,96 @@ using SkiaSharp;
 using System;
 using System.Collections.Generic;
 using System.Windows;
-using System.Windows.Input;
 
 namespace PixiEditor.Models.Tools.Tools
 {
     public class LineTool : ShapeTool
     {
-        private readonly CircleTool circleTool;
         private List<Coordinates> linePoints = new List<Coordinates>();
         private SKPaint paint = new SKPaint() { Style = SKPaintStyle.Stroke };
 
         public bool AutomaticallyResizeCanvas { get; set; } = true;
 
-        public static List<Coordinates> GetBresenhamLine(Coordinates start, Coordinates end)
+        private string defaltActionDisplay = "Click and move to draw a line. Hold Shift to draw an even one.";
+
+        public LineTool()
         {
-            List<Coordinates> output = new List<Coordinates>();
-            CalculateBresenhamLine(start, end, output);
-            return output;
+            ActionDisplay = defaltActionDisplay;
+            Toolbar = new BasicToolbar();
         }
 
-        public static void CalculateBresenhamLine(Coordinates start, Coordinates end, List<Coordinates> output)
+        public override string Tooltip => "Draws line on canvas (L). Hold Shift to draw even line.";
+
+        public override void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown)
         {
-            int x1 = start.X;
-            int x2 = end.X;
-            int y1 = start.Y;
-            int y2 = end.Y;
+            if (shiftIsDown)
+                ActionDisplay = "Click and move mouse to draw an even line.";
+            else
+                ActionDisplay = defaltActionDisplay;
+        }
+
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
+        {
+            int thickness = Toolbar.GetSetting<SizeSetting>("ToolSize").Value;
+
+            Coordinates start = recordedMouseMovement[0];
+            Coordinates end = recordedMouseMovement[^1];
+
+            if (Session.IsShiftDown)
+                (start, end) = CoordinatesHelper.GetSquareOrLineCoordinates(recordedMouseMovement);
+
+            DrawLine(previewLayer, start, end, color, thickness, SKBlendMode.Src);
+        }
 
+        public void DrawLine(
+            Layer layer, Coordinates start, Coordinates end, SKColor color, int thickness, SKBlendMode blendMode,
+            SKStrokeCap strokeCap = SKStrokeCap.Butt)
+        {
+            int x = start.X;
+            int y = start.Y;
+            int x1 = end.X;
+            int y1 = end.Y;
+
+            int dirtyX = Math.Min(x, x1) - thickness;
+            int dirtyY = Math.Min(y, y1) - thickness;
+
+            Int32Rect dirtyRect = new Int32Rect(
+                dirtyX,
+                dirtyY,
+                Math.Max(x1, x) + thickness - dirtyX,
+                Math.Max(y1, y) + thickness - dirtyY);
+            if (AutomaticallyResizeCanvas)
+            {
+                layer.DynamicResizeAbsolute(dirtyRect);
+            }
+
+            x -= layer.OffsetX;
+            y -= layer.OffsetY;
+            x1 -= layer.OffsetX;
+            y1 -= layer.OffsetY;
+
+            paint.StrokeWidth = thickness;
+            paint.Color = color;
+            paint.BlendMode = blendMode;
+            paint.StrokeCap = strokeCap;
+
+            if (thickness == 1)
+            {
+                DrawBresenhamLine(layer, x, y, x1, y1, paint);
+            }
+            else
+            {
+                layer.LayerBitmap.SkiaSurface.Canvas.DrawLine(x, y, x1, y1, paint);
+            }
+
+            layer.InvokeLayerBitmapChange(dirtyRect);
+        }
+
+        private void DrawBresenhamLine(Layer layer, int x1, int y1, int x2, int y2, SKPaint paint)
+        {
             if (x1 == x2 && y1 == y2)
             {
-                output.Add(start);
+                layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x1, y1, paint);
                 return;
             }
 
@@ -63,7 +125,7 @@ namespace PixiEditor.Models.Tools.Tools
                 dy = y1 - y2;
             }
 
-            output.Add(new Coordinates(x, y));
+            layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x, y, paint);
 
             if (dx > dy)
             {
@@ -85,7 +147,7 @@ namespace PixiEditor.Models.Tools.Tools
                         x += xi;
                     }
 
-                    output.Add(new Coordinates(x, y));
+                    layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x, y, paint);
                 }
             }
             else
@@ -108,97 +170,29 @@ namespace PixiEditor.Models.Tools.Tools
                         y += yi;
                     }
 
-                    output.Add(new Coordinates(x, y));
+                    layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x, y, paint);
                 }
             }
         }
 
-        private string defaltActionDisplay = "Click and move to draw a line. Hold Shift to draw an even one.";
-
-        public LineTool()
-        {
-            ActionDisplay = defaltActionDisplay;
-            Toolbar = new BasicToolbar();
-            circleTool = new CircleTool();
-        }
-
-        public override string Tooltip => "Draws line on canvas (L). Hold Shift to draw even line.";
-
-        public override void OnKeyDown(KeyEventArgs e)
-        {
-            if (e.Key is Key.LeftShift or Key.RightShift)
-            {
-                ActionDisplay = "Click and move mouse to draw an even line.";
-            }
-        }
-
-        public override void OnKeyUp(KeyEventArgs e)
-        {
-            if (e.Key is Key.LeftShift or Key.RightShift)
-            {
-                ActionDisplay = defaltActionDisplay;
-            }
-        }
 
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
+        public static List<Coordinates> GetBresenhamLine(Coordinates start, Coordinates end)
         {
-            int thickness = Toolbar.GetSetting<SizeSetting>("ToolSize").Value;
-
-            Coordinates start = coordinates[0];
-            Coordinates end = coordinates[^1];
-
-            DrawLine(layer, start, end, color, thickness, SKBlendMode.Src);
+            List<Coordinates> output = new List<Coordinates>();
+            CalculateBresenhamLine(start, end, output);
+            return output;
         }
 
-        public void DrawLine(
-            Layer layer, Coordinates start, Coordinates end, SKColor color, int thickness, SKBlendMode blendMode,
-            SKStrokeCap strokeCap = SKStrokeCap.Butt)
+        public static void CalculateBresenhamLine(Coordinates start, Coordinates end, List<Coordinates> output)
         {
-            int x = start.X;
-            int y = start.Y;
-            int x1 = end.X;
-            int y1 = end.Y;
-
-            int dirtyX = Math.Min(x, x1) - thickness;
-            int dirtyY = Math.Min(y, y1) - thickness;
-
-            Int32Rect dirtyRect = new Int32Rect(
-                dirtyX,
-                dirtyY,
-                Math.Max(x1, x) + thickness - dirtyX,
-                Math.Max(y1, y) + thickness - dirtyY);
-            if (AutomaticallyResizeCanvas)
-            {
-                layer.DynamicResizeAbsolute(dirtyRect);
-            }
-
-            x -= layer.OffsetX;
-            y -= layer.OffsetY;
-            x1 -= layer.OffsetX;
-            y1 -= layer.OffsetY;
-
-            paint.StrokeWidth = thickness;
-            paint.Color = color;
-            paint.BlendMode = blendMode;
-            paint.StrokeCap = strokeCap;
-
-            if (thickness == 1)
-            {
-                DrawBresenhamLine(layer, x, y, x1, y1, paint);
-            }
-            else
-            {
-                layer.LayerBitmap.SkiaSurface.Canvas.DrawLine(x, y, x1, y1, paint);
-            }
-
-            layer.InvokeLayerBitmapChange(dirtyRect);
-        }
+            int x1 = start.X;
+            int x2 = end.X;
+            int y1 = start.Y;
+            int y2 = end.Y;
 
-        private void DrawBresenhamLine(Layer layer, int x1, int y1, int x2, int y2, SKPaint paint)
-        {
             if (x1 == x2 && y1 == y2)
             {
-                layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x1, y1, paint);
+                output.Add(start);
                 return;
             }
 
@@ -227,7 +221,7 @@ namespace PixiEditor.Models.Tools.Tools
                 dy = y1 - y2;
             }
 
-            layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x, y, paint);
+            output.Add(new Coordinates(x, y));
 
             if (dx > dy)
             {
@@ -249,7 +243,7 @@ namespace PixiEditor.Models.Tools.Tools
                         x += xi;
                     }
 
-                    layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x, y, paint);
+                    output.Add(new Coordinates(x, y));
                 }
             }
             else
@@ -272,7 +266,7 @@ namespace PixiEditor.Models.Tools.Tools
                         y += yi;
                     }
 
-                    layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(x, y, paint);
+                    output.Add(new Coordinates(x, y));
                 }
             }
         }

PixiEditor/Models/Tools/Tools/MagicWandTool.cs

@@ -12,11 +12,10 @@ using SkiaSharp;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Windows;
-using System.Windows.Input;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class MagicWandTool : ReadonlyTool, ICachedDocumentTool
+    internal class MagicWandTool : ReadonlyTool, ICachedDocumentTool
     {
         private static Selection ActiveSelection { get => ViewModelMain.Current.BitmapManager.ActiveDocument.ActiveSelection; }
 
@@ -29,12 +28,19 @@ namespace PixiEditor.Models.Tools.Tools
 
         private Layer cachedDocument;
 
-        public override void OnRecordingLeftMouseDown(MouseEventArgs e)
+        public MagicWandTool(BitmapManager manager)
         {
-            if (e.LeftButton != MouseButtonState.Pressed)
-            {
+            BitmapManager = manager;
+
+            Toolbar = new MagicWandToolbar();
+
+            ActionDisplay = "Click to flood the selection.";
+        }
+
+        public override void Use(IReadOnlyList<Coordinates> pixels)
+        {
+            if (pixels.Count > 1)
                 return;
-            }
 
             oldSelection = new ReadOnlyCollection<Coordinates>(ActiveSelection.SelectedPoints);
 
@@ -61,9 +67,7 @@ namespace PixiEditor.Models.Tools.Tools
 
             ToolCalculator.GetLinearFillAbsolute(
                    layer,
-                   new Coordinates(
-                       (int)document.MouseXOnCanvas,
-                       (int)document.MouseYOnCanvas),
+                   pixels[0],
                    BitmapManager.ActiveDocument.Width,
                    BitmapManager.ActiveDocument.Height,
                    SKColors.White,
@@ -74,19 +78,6 @@ namespace PixiEditor.Models.Tools.Tools
             SelectionHelpers.AddSelectionUndoStep(ViewModelMain.Current.BitmapManager.ActiveDocument, oldSelection, selectionType);
         }
 
-        public MagicWandTool(BitmapManager manager)
-        {
-            BitmapManager = manager;
-
-            Toolbar = new MagicWandToolbar();
-
-            ActionDisplay = "Click to flood the selection.";
-        }
-
-        public override void Use(List<Coordinates> pixels)
-        {
-        }
-
         public void DocumentChanged()
         {
             cachedDocument = null;

PixiEditor/Models/Tools/Tools/MoveTool.cs

@@ -3,24 +3,18 @@ using PixiEditor.Models.Controllers;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Enums;
 using PixiEditor.Models.ImageManipulation;
-using PixiEditor.Models.IO;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Undo;
-using PixiEditor.ViewModels;
 using SkiaSharp;
-using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
 using System.Linq;
 using System.Windows;
 using System.Windows.Input;
-using Transform = PixiEditor.Models.ImageManipulation.Transform;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class MoveTool : BitmapOperationTool
+    internal class MoveTool : BitmapOperationTool
     {
         private static readonly SKPaint maskingPaint = new()
         {
@@ -38,7 +32,6 @@ namespace PixiEditor.Models.Tools.Tools
         private Surface previewLayerData;
 
         private List<Coordinates> moveStartSelectedPoints = null;
-        private Coordinates moveStartPos;
         private Int32Rect moveStartRect;
 
         private Coordinates lastDragDelta;
@@ -63,61 +56,21 @@ namespace PixiEditor.Models.Tools.Tools
 
         private BitmapManager BitmapManager { get; }
 
-        public override void OnKeyDown(KeyEventArgs e)
+        public override void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown)
         {
-            if (e.Key is Key.LeftCtrl or Key.RightCtrl)
-            {
+            if (ctrlIsDown)
                 ActionDisplay = "Hold mouse to move all layers.";
-            }
-        }
-
-        public override void OnKeyUp(KeyEventArgs e)
-        {
-            if (e.Key is Key.LeftCtrl or Key.RightCtrl)
-            {
+            else
                 ActionDisplay = defaultActionDisplay;
-            }
         }
 
-        public override void AddUndoProcess(Document document)
-        {
-            var args = new object[] { change.Document };
-            document.UndoManager.AddUndoChange(change.ToChange(UndoProcess, args));
-            if (moveStartSelectedPoints != null)
-            {
-                SelectionHelpers.AddSelectionUndoStep(document, moveStartSelectedPoints, SelectionType.New);
-                document.UndoManager.SquashUndoChanges(3, "Move selected area");
-                moveStartSelectedPoints = null;
-            }
-            change = null;
-        }
-
-        private void UndoProcess(Layer[] layers, UndoLayer[] data, object[] args)
-        {
-            if (args.Length > 0 && args[0] is Document document)
-            {
-                for (int i = 0; i < layers.Length; i++)
-                {
-                    Layer layer = layers[i];
-                    document.Layers.RemoveAt(data[i].LayerIndex);
-
-                    document.Layers.Insert(data[i].LayerIndex, layer);
-                    if (data[i].IsActive)
-                    {
-                        document.SetMainActiveLayer(data[i].LayerIndex);
-                    }
-                }
-
-            }
-        }
-
-        public override void OnStart(Coordinates startPos)
+        public override void BeforeUse()
         {
             Document doc = BitmapManager.ActiveDocument;
             Selection selection = doc.ActiveSelection;
             bool anySelection = selection.SelectedPoints.Any();
 
-            if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
+            if (Session.IsCtrlDown)
             {
                 affectedLayers = doc.Layers.Where(x => x.IsVisible).ToArray();
             }
@@ -129,10 +82,9 @@ namespace PixiEditor.Models.Tools.Tools
             change = new StorageBasedChange(doc, affectedLayers, true);
 
             Layer selLayer = selection.SelectionLayer;
-            moveStartRect = anySelection ? 
+            moveStartRect = anySelection ?
                 new(selLayer.OffsetX, selLayer.OffsetY, selLayer.Width, selLayer.Height) :
-                new (0, 0, doc.Width, doc.Height);
-            moveStartPos = startPos;
+                new(0, 0, doc.Width, doc.Height);
             lastDragDelta = new Coordinates(0, 0);
 
             previewLayerData?.Dispose();
@@ -193,7 +145,7 @@ namespace PixiEditor.Models.Tools.Tools
         {
             using var selSnap = selLayer.LayerBitmap.SkiaSurface.Snapshot();
             Surface[] output = new Surface[draggedLayers.Length];
-            
+
             int count = 0;
             foreach (Layer layer in draggedLayers)
             {
@@ -209,17 +161,18 @@ namespace PixiEditor.Models.Tools.Tools
                 output[count] = portion;
                 count++;
 
-                layer.LayerBitmap.SkiaSurface.Canvas.DrawImage(selSnap, new SKRect(0, 0, selLayer.Width, selLayer.Height), 
-                    new SKRect(selLayer.OffsetX - layer.OffsetX, selLayer.OffsetY - layer.OffsetY, selLayer.OffsetX - layer.OffsetX + selLayer.Width, selLayer.OffsetY - layer.OffsetY + selLayer.Height), 
+                layer.LayerBitmap.SkiaSurface.Canvas.DrawImage(selSnap, new SKRect(0, 0, selLayer.Width, selLayer.Height),
+                    new SKRect(selLayer.OffsetX - layer.OffsetX, selLayer.OffsetY - layer.OffsetY, selLayer.OffsetX - layer.OffsetX + selLayer.Width, selLayer.OffsetY - layer.OffsetY + selLayer.Height),
                     inverseMaskingPaint);
                 layer.InvokeLayerBitmapChange(new Int32Rect(selLayer.OffsetX, selLayer.OffsetY, selLayer.Width, selLayer.Height));
             }
             return output;
         }
 
-        public override void Use(Layer layer, List<Coordinates> mouseMove, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
         {
-            Coordinates newPos = mouseMove[0];
+            Coordinates newPos = recordedMouseMovement[^1];
+            Coordinates moveStartPos = recordedMouseMovement[0];
             int dX = newPos.X - moveStartPos.X;
             int dY = newPos.Y - moveStartPos.Y;
             BitmapManager.ActiveDocument.ActiveSelection.TranslateSelection(dX - lastDragDelta.X, dY - lastDragDelta.Y);
@@ -230,21 +183,22 @@ namespace PixiEditor.Models.Tools.Tools
             int newY = moveStartRect.Y + dY;
 
             Int32Rect dirtyRect = new Int32Rect(newX, newY, moveStartRect.Width, moveStartRect.Height);
-            layer.DynamicResizeAbsolute(dirtyRect);
-            previewLayerData.SkiaSurface.Draw(layer.LayerBitmap.SkiaSurface.Canvas, newX - layer.OffsetX, newY - layer.OffsetY, Surface.ReplacingPaint);
-            layer.InvokeLayerBitmapChange(dirtyRect);
+            previewLayer.DynamicResizeAbsolute(dirtyRect);
+            previewLayerData.SkiaSurface.Draw(previewLayer.LayerBitmap.SkiaSurface.Canvas, newX - previewLayer.OffsetX, newY - previewLayer.OffsetY, Surface.ReplacingPaint);
+            previewLayer.InvokeLayerBitmapChange(dirtyRect);
         }
 
-        public override void OnStoppedRecordingMouseUp(MouseEventArgs e)
+        public override void AfterUse()
         {
-            base.OnStoppedRecordingMouseUp(e);
-
+            base.AfterUse();
             BitmapManager.ActiveDocument.PreviewLayer.ClearCanvas();
 
             ApplySurfacesToLayers(currentlyDragged, currentlyDraggedPositions, affectedLayers, new Coordinates(lastDragDelta.X, lastDragDelta.Y));
             foreach (var surface in currentlyDragged)
                 surface.Dispose();
             currentlyDragged = null;
+
+            SaveUndo(BitmapManager.ActiveDocument);
         }
 
         private static void ApplySurfacesToLayers(Surface[] surfaces, Coordinates[] startPositions, Layer[] layers, Coordinates delta)
@@ -263,5 +217,37 @@ namespace PixiEditor.Models.Tools.Tools
                 count++;
             }
         }
+
+        private void SaveUndo(Document document)
+        {
+            var args = new object[] { change.Document };
+            document.UndoManager.AddUndoChange(change.ToChange(UndoProcess, args));
+            if (moveStartSelectedPoints != null)
+            {
+                SelectionHelpers.AddSelectionUndoStep(document, moveStartSelectedPoints, SelectionType.New);
+                document.UndoManager.SquashUndoChanges(3, "Move selected area");
+                moveStartSelectedPoints = null;
+            }
+            change = null;
+        }
+
+        private void UndoProcess(Layer[] layers, UndoLayer[] data, object[] args)
+        {
+            if (args.Length > 0 && args[0] is Document document)
+            {
+                for (int i = 0; i < layers.Length; i++)
+                {
+                    Layer layer = layers[i];
+                    document.Layers.RemoveAt(data[i].LayerIndex);
+
+                    document.Layers.Insert(data[i].LayerIndex, layer);
+                    if (data[i].IsActive)
+                    {
+                        document.SetMainActiveLayer(data[i].LayerIndex);
+                    }
+                }
+
+            }
+        }
     }
 }

PixiEditor/Models/Tools/Tools/MoveViewportTool.cs

@@ -1,5 +1,4 @@
-using PixiEditor.Models.Controllers;
-using PixiEditor.Models.Position;
+using PixiEditor.Models.Position;
 using PixiEditor.ViewModels.SubViewModels.Main;
 using System.Collections.Generic;
 using System.Windows.Input;
@@ -19,17 +18,9 @@ namespace PixiEditor.Models.Tools.Tools
         }
 
         public override bool HideHighlight => true;
-        public override string Tooltip => "Move viewport. (H)";
-
-        public override void OnMouseUp(MouseEventArgs e)
-        {
-            if (e.MiddleButton == MouseButtonState.Pressed)
-            {
-                ToolsViewModel.SetActiveTool(ToolsViewModel.LastActionTool);
-            }
-        }
+        public override string Tooltip => "Move viewport. (Space)";
 
-        public override void Use(List<Coordinates> pixels)
+        public override void Use(IReadOnlyList<Coordinates> pixels)
         {
             // Implemented inside Zoombox.xaml.cs
         }

PixiEditor/Models/Tools/Tools/PenTool.cs

@@ -13,7 +13,7 @@ using System.Windows.Input;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class PenTool : ShapeTool
+    internal class PenTool : ShapeTool
     {
         public Brush Brush { get; set; }
         public List<Brush> Brushes { get; } = new List<Brush>();
@@ -50,34 +50,33 @@ namespace PixiEditor.Models.Tools.Tools
         }
 
         public override string Tooltip => "Standard brush. (B)";
-        public override bool UsesShift => false;
 
         public bool AutomaticallyResizeCanvas { get; set; } = true;
 
-        public override void OnRecordingLeftMouseDown(MouseEventArgs e)
+        public override void BeforeUse()
         {
-            base.OnRecordingLeftMouseDown(e);
+            base.BeforeUse();
             changedPixelsindex = 0;
             lastChangedPixels = new Coordinates[3];
             confirmedPixels.Clear();
         }
 
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
         {
-            Coordinates startingCords = coordinates.Count > 1 ? coordinates[1] : coordinates[0];
+            Coordinates startingCords = recordedMouseMovement.Count > 1 ? recordedMouseMovement[^2] : recordedMouseMovement[0];
             paint.Color = color;
             if (AutomaticallyResizeCanvas)
             {
-                int maxX = coordinates.Max(x => x.X);
-                int maxY = coordinates.Max(x => x.Y);
-                int minX = coordinates.Min(x => x.X);
-                int minY = coordinates.Min(x => x.Y);
-                layer.DynamicResizeAbsolute(new(minX, minY, maxX - minX + 1, maxX - minX + 1));
+                int maxX = recordedMouseMovement.Max(x => x.X);
+                int maxY = recordedMouseMovement.Max(x => x.Y);
+                int minX = recordedMouseMovement.Min(x => x.X);
+                int minY = recordedMouseMovement.Min(x => x.Y);
+                previewLayer.DynamicResizeAbsolute(new(minX, minY, maxX - minX + 1, maxX - minX + 1));
             }
             Draw(
-                layer,
+                previewLayer,
                 startingCords,
-                coordinates[0],
+                recordedMouseMovement[^1],
                 color,
                 toolSizeSetting.Value,
                 pixelPerfectSetting.Value,

PixiEditor/Models/Tools/Tools/RectangleTool.cs

@@ -1,11 +1,11 @@
-using PixiEditor.Models.Layers;
+using PixiEditor.Helpers;
+using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings.Settings;
 using SkiaSharp;
 using System;
 using System.Collections.Generic;
 using System.Windows;
-using System.Windows.Input;
 
 namespace PixiEditor.Models.Tools.Tools
 {
@@ -21,23 +21,15 @@ namespace PixiEditor.Models.Tools.Tools
 
         public bool Filled { get; set; } = false;
 
-        public override void OnKeyDown(KeyEventArgs e)
+        public override void UpdateActionDisplay(bool ctrlIsDown, bool shiftIsDown, bool altIsDown)
         {
-            if (e.Key is Key.LeftShift or Key.RightShift)
-            {
+            if (shiftIsDown)
                 ActionDisplay = "Click and move to draw a square.";
-            }
-        }
-
-        public override void OnKeyUp(KeyEventArgs e)
-        {
-            if (e.Key is Key.LeftShift or Key.RightShift)
-            {
+            else
                 ActionDisplay = defaultActionDisplay;
-            }
         }
 
-        public override void Use(Layer layer, List<Coordinates> coordinates, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement, SKColor color)
         {
             int thickness = Toolbar.GetSetting<SizeSetting>("ToolSize").Value;
             SKColor? fillColor = null;
@@ -46,12 +38,14 @@ namespace PixiEditor.Models.Tools.Tools
                 var temp = Toolbar.GetSetting<ColorSetting>("FillColor").Value;
                 fillColor = new SKColor(temp.R, temp.G, temp.B, temp.A);
             }
-            CreateRectangle(layer, color, fillColor, coordinates, thickness);
+            CreateRectangle(previewLayer, color, fillColor, recordedMouseMovement, thickness);
         }
 
-        public void CreateRectangle(Layer layer, SKColor color, SKColor? fillColor, List<Coordinates> coordinates, int thickness)
+        private void CreateRectangle(Layer layer, SKColor color, SKColor? fillColor, IReadOnlyList<Coordinates> coordinates, int thickness)
         {
-            DoubleCoords fixedCoordinates = CalculateCoordinatesForShapeRotation(coordinates[^1], coordinates[0]);
+            var (start, end) = Session.IsShiftDown ? CoordinatesHelper.GetSquareCoordiantes(coordinates) : (coordinates[0], coordinates[^1]);
+
+            DoubleCoords fixedCoordinates = CalculateCoordinatesForShapeRotation(start, end);
 
             int halfThickness = (int)Math.Ceiling(thickness / 2.0);
             Int32Rect dirtyRect = new Int32Rect(
@@ -83,10 +77,5 @@ namespace PixiEditor.Models.Tools.Tools
             }
             layer.InvokeLayerBitmapChange(dirtyRect);
         }
-
-        public void CreateRectangle(Layer layer, SKColor color, SKColor? fillColor, Coordinates start, Coordinates end, int thickness)
-        {
-            CreateRectangle(layer, color, fillColor, new() { end, start }, thickness);
-        }
     }
 }

PixiEditor/Models/Tools/Tools/SelectTool.cs

@@ -1,25 +1,19 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Linq;
-using System.Windows.Controls;
-using System.Windows.Input;
-using PixiEditor.Helpers;
+using PixiEditor.Helpers;
 using PixiEditor.Helpers.Extensions;
 using PixiEditor.Models.Controllers;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Enums;
 using PixiEditor.Models.ImageManipulation;
 using PixiEditor.Models.Position;
-using PixiEditor.Models.Tools.ToolSettings.Settings;
 using PixiEditor.Models.Tools.ToolSettings.Toolbars;
-using PixiEditor.Models.Undo;
 using PixiEditor.ViewModels;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class SelectTool : ReadonlyTool
+    internal class SelectTool : ReadonlyTool
     {
         private readonly RectangleTool rectangleTool;
         private readonly CircleTool circleTool;
@@ -43,15 +37,17 @@ namespace PixiEditor.Models.Tools.Tools
 
         public override string Tooltip => "Selects area. (M)";
 
-        public override void OnRecordingLeftMouseDown(MouseEventArgs e)
+        public override void BeforeUse()
         {
+            base.BeforeUse();
             SelectionType = Toolbar.GetEnumSetting<SelectionType>("SelectMode").Value;
 
             oldSelectedPoints = new ReadOnlyCollection<Coordinates>(ActiveSelection.SelectedPoints);
         }
 
-        public override void OnStoppedRecordingMouseUp(MouseEventArgs e)
+        public override void AfterUse()
         {
+            base.AfterUse();
             if (ActiveSelection.SelectedPoints.Count <= 1)
             {
                 // If we have not selected multiple points, clear the selection
@@ -61,7 +57,7 @@ namespace PixiEditor.Models.Tools.Tools
             SelectionHelpers.AddSelectionUndoStep(ViewModelMain.Current.BitmapManager.ActiveDocument, oldSelectedPoints, SelectionType);
         }
 
-        public override void Use(List<Coordinates> pixels)
+        public override void Use(IReadOnlyList<Coordinates> pixels)
         {
             Select(pixels, Toolbar.GetEnumSetting<SelectionShape>("SelectShape").Value);
         }
@@ -100,7 +96,7 @@ namespace PixiEditor.Models.Tools.Tools
             return GetRectangleSelectionForPoints(new Coordinates(0, 0), new Coordinates(document.Width - 1, document.Height - 1));
         }
 
-        private void Select(List<Coordinates> pixels, SelectionShape shape)
+        private void Select(IReadOnlyList<Coordinates> pixels, SelectionShape shape)
         {
             IEnumerable<Coordinates> selection;
 
@@ -126,4 +122,4 @@ namespace PixiEditor.Models.Tools.Tools
             BitmapManager.ActiveDocument.ActiveSelection.SetSelection(selection, SelectionType);
         }
     }
-}
+}

PixiEditor/Models/Tools/Tools/ZoomTool.cs

@@ -5,14 +5,13 @@ using System.Windows.Input;
 
 namespace PixiEditor.Models.Tools.Tools
 {
-    public class ZoomTool : ReadonlyTool
+    internal class ZoomTool : ReadonlyTool
     {
         private BitmapManager BitmapManager { get; }
         private string defaultActionDisplay = "Click and move to zoom. Click to zoom in, hold ctrl and click to zoom out.";
 
         public ZoomTool(BitmapManager bitmapManager)
         {
-            CanStartOutsideCanvas = true;
             ActionDisplay = defaultActionDisplay;
             BitmapManager = bitmapManager;
         }
@@ -21,23 +20,23 @@ namespace PixiEditor.Models.Tools.Tools
 
         public override string Tooltip => "Zooms viewport (Z). Click to zoom in, hold alt and click to zoom out.";
 
-        public override void OnKeyDown(KeyEventArgs e)
+        public override void OnKeyDown(Key key)
         {
-            if (e.Key is Key.LeftCtrl or Key.RightCtrl)
+            if (key is Key.LeftCtrl)
             {
                 ActionDisplay = "Click and move to zoom. Click to zoom out, release ctrl and click to zoom in.";
             }
         }
 
-        public override void OnKeyUp(KeyEventArgs e)
+        public override void OnKeyUp(Key key)
         {
-            if (e.Key is Key.LeftCtrl or Key.RightCtrl)
+            if (key is Key.LeftCtrl)
             {
                 ActionDisplay = defaultActionDisplay;
             }
         }
 
-        public override void Use(List<Coordinates> pixels)
+        public override void Use(IReadOnlyList<Coordinates> pixels)
         {
             // Implemented inside Zoombox.xaml.cs
         }

PixiEditor/Models/Undo/StorageBasedChange.cs

@@ -21,7 +21,6 @@ namespace PixiEditor.Models.Undo
         public UndoLayer[] StoredLayers { get; set; }
 
         private List<Guid> layersToStore;
-
         public Document Document { get; }
 
         public StorageBasedChange(Document doc, IEnumerable<Layer> layers, bool saveOnStartup = true)
@@ -260,9 +259,10 @@ namespace PixiEditor.Models.Undo
                 for (int i = 0; i < layers.Length; i++)
                 {
                     Layer layer = layers[i];
-                    document.Layers.RemoveAt(data[i].LayerIndex);
 
+                    document.RemoveLayer(data[i].LayerIndex, false);
                     document.Layers.Insert(data[i].LayerIndex, layer);
+
                     if (data[i].IsActive)
                     {
                         document.SetMainActiveLayer(data[i].LayerIndex);

PixiEditor/PixiEditor.csproj

@@ -1,273 +1,273 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net6.0-windows10.0.22000.0</TargetFramework>
-    <UseWPF>true</UseWPF>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
-    <AssemblyName>PixiEditor</AssemblyName>
-    <RootNamespace>PixiEditor</RootNamespace>
-    <RepositoryUrl>https://github.com/PixiEditor/PixiEditor</RepositoryUrl>
-    <PackageLicenseFile>LICENSE</PackageLicenseFile>
-    <PackageIcon>icon.ico</PackageIcon>
-    <ApplicationIcon>..\icon.ico</ApplicationIcon>
-    <Authors>Krzysztof Krysiński, Egor Mozgovoy, CPK</Authors>
-    <Configurations>Debug;Release;MSIX;MSIX Debug;Dev Release</Configurations>
-    <Platforms>AnyCPU;x64;x86</Platforms>
-    <SupportedOSPlatformVersion>7.0</SupportedOSPlatformVersion>
-  </PropertyGroup>
+	<PropertyGroup>
+		<OutputType>WinExe</OutputType>
+		<TargetFramework>net6.0-windows10.0.22000.0</TargetFramework>
+		<UseWPF>true</UseWPF>
+		<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+		<AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+		<GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
+		<AssemblyName>PixiEditor</AssemblyName>
+		<RootNamespace>PixiEditor</RootNamespace>
+		<RepositoryUrl>https://github.com/PixiEditor/PixiEditor</RepositoryUrl>
+		<PackageLicenseFile>LICENSE</PackageLicenseFile>
+		<PackageIcon>icon.ico</PackageIcon>
+		<ApplicationIcon>..\icon.ico</ApplicationIcon>
+		<Authors>Krzysztof Krysiński, Egor Mozgovoy, CPK</Authors>
+		<Configurations>Debug;Release;MSIX;MSIX Debug;Dev Release</Configurations>
+		<Platforms>AnyCPU;x64;x86</Platforms>
+		<SupportedOSPlatformVersion>7.0</SupportedOSPlatformVersion>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|AnyCPU'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x86'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x86'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x64'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x64'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;UPDATE</DefineConstants>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;UPDATE</DefineConstants>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Dev Release|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;UPDATE</DefineConstants>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Dev Release|AnyCPU'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;UPDATE;RELEASE</DefineConstants>
+		<Optimize>True</Optimize>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;UPDATE</DefineConstants>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;UPDATE</DefineConstants>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Dev Release|x86'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;UPDATE</DefineConstants>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Dev Release|x86'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;UPDATE</DefineConstants>
+		<Optimize>True</Optimize>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;UPDATE</DefineConstants>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;UPDATE</DefineConstants>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Dev Release|x64'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;UPDATE</DefineConstants>
-    <Optimize>True</Optimize>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Dev Release|x64'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;UPDATE</DefineConstants>
+		<Optimize>True</Optimize>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;RELEASE</DefineConstants>
-    <Optimize>true</Optimize>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|AnyCPU'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;RELEASE</DefineConstants>
+		<Optimize>true</Optimize>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x86'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;RELEASE</DefineConstants>
-    <Optimize>true</Optimize>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x86'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;RELEASE</DefineConstants>
+		<Optimize>true</Optimize>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x64'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DefineConstants>TRACE;RELEASE</DefineConstants>
-    <Optimize>true</Optimize>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX|x64'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DefineConstants>TRACE;RELEASE</DefineConstants>
+		<Optimize>true</Optimize>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DebugType>full</DebugType>
-    <DebugSymbols>true</DebugSymbols>
-    <WarningLevel>0</WarningLevel>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DebugType>full</DebugType>
+		<DebugSymbols>true</DebugSymbols>
+		<WarningLevel>0</WarningLevel>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x86'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DebugType>full</DebugType>
-    <DebugSymbols>true</DebugSymbols>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x86'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DebugType>full</DebugType>
+		<DebugSymbols>true</DebugSymbols>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DebugType>full</DebugType>
-    <DebugSymbols>true</DebugSymbols>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DebugType>full</DebugType>
+		<DebugSymbols>true</DebugSymbols>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX Debug|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DebugType>full</DebugType>
-    <DebugSymbols>true</DebugSymbols>
-    <Optimize>false</Optimize>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX Debug|AnyCPU'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DebugType>full</DebugType>
+		<DebugSymbols>true</DebugSymbols>
+		<Optimize>false</Optimize>
+		<DefineConstants>DEBUG;TRACE</DefineConstants>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX Debug|x86'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DebugType>full</DebugType>
-    <DebugSymbols>true</DebugSymbols>
-    <Optimize>false</Optimize>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX Debug|x86'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DebugType>full</DebugType>
+		<DebugSymbols>true</DebugSymbols>
+		<Optimize>false</Optimize>
+		<DefineConstants>DEBUG;TRACE</DefineConstants>
+	</PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX Debug|x64'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DebugType>full</DebugType>
-    <DebugSymbols>true</DebugSymbols>
-    <Optimize>false</Optimize>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='MSIX Debug|x64'">
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+		<DebugType>full</DebugType>
+		<DebugSymbols>true</DebugSymbols>
+		<Optimize>false</Optimize>
+		<DefineConstants>DEBUG;TRACE</DefineConstants>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <Compile Remove="Styles\AvalonDock\Images\**" />
-    <EmbeddedResource Remove="Styles\AvalonDock\Images\**" />
-    <None Remove="Styles\AvalonDock\Images\**" />
-    <Page Remove="Styles\AvalonDock\Images\**" />
-  </ItemGroup>
+	<ItemGroup>
+		<Compile Remove="Styles\AvalonDock\Images\**" />
+		<EmbeddedResource Remove="Styles\AvalonDock\Images\**" />
+		<None Remove="Styles\AvalonDock\Images\**" />
+		<Page Remove="Styles\AvalonDock\Images\**" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <None Remove="Images\AnchorDot.png" />
-    <None Remove="Images\CheckerTile.png" />
-    <None Remove="Images\ChevronDown.png" />
-    <None Remove="Images\DiagonalRed.png" />
-    <None Remove="Images\Eye-off.png" />
-    <None Remove="Images\Eye.png" />
-    <None Remove="Images\Folder-add.png" />
-    <None Remove="Images\Folder.png" />
-    <None Remove="Images\Layer-add.png" />
-    <None Remove="Images\MoveImage.png" />
-    <None Remove="Images\MoveViewportImage.png" />
-    <None Remove="Images\penMode.png" />
-    <None Remove="Images\PixiBotLogo.png" />
-    <None Remove="Images\PixiEditorLogo.png" />
-    <None Remove="Images\PixiParserLogo.png" />
-    <None Remove="Images\Placeholder.png" />
-    <None Remove="Images\SelectImage.png" />
-    <None Remove="Images\SocialMedia\DiscordIcon.png" />
-    <None Remove="Images\SocialMedia\DonateIcon.png" />
-    <None Remove="Images\SocialMedia\GitHubIcon.png" />
-    <None Remove="Images\SocialMedia\RedditIcon.png" />
-    <None Remove="Images\SocialMedia\WebsiteIcon.png" />
-    <None Remove="Images\SocialMedia\YouTubeIcon.png" />
-    <None Remove="Images\Tools\BrightnessImage.png" />
-    <None Remove="Images\Tools\CircleImage.png" />
-    <None Remove="Images\Tools\ColorPickerImage.png" />
-    <None Remove="Images\Tools\EraserImage.png" />
-    <None Remove="Images\Tools\FloodFillImage.png" />
-    <None Remove="Images\Tools\LineImage.png" />
-    <None Remove="Images\Tools\MagicWandImage.png" />
-    <None Remove="Images\Tools\MoveImage.png" />
-    <None Remove="Images\Tools\MoveViewportImage.png" />
-    <None Remove="Images\Tools\PenImage.png" />
-    <None Remove="Images\Tools\RectangleImage.png" />
-    <None Remove="Images\Tools\SelectImage.png" />
-    <None Remove="Images\Tools\ZoomImage.png" />
-    <None Remove="Images\Trash.png" />
-    <None Remove="Images\UnknownFile.png" />
-    <None Remove="Images\ZoomImage.png" />
-    <None Include="..\icon.ico">
-      <Pack>True</Pack>
-      <PackagePath></PackagePath>
-    </None>
-    <None Include="..\LICENSE">
-      <Pack>True</Pack>
-      <PackagePath></PackagePath>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Dirkster.AvalonDock" Version="4.60.0" />
-    <PackageReference Include="DiscordRichPresence" Version="1.0.175" />
-    <PackageReference Include="Expression.Blend.Sdk">
-      <Version>1.0.2</Version>
-      <NoWarn>NU1701</NoWarn>
-    </PackageReference>
-    <PackageReference Include="MessagePack" Version="2.3.85" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
-    <PackageReference Include="MvvmLightLibs" Version="5.4.1.1">
-      <NoWarn>NU1701</NoWarn>
-    </PackageReference>
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="PixiEditor.ColorPicker" Version="3.1.0" />
-    <PackageReference Include="PixiEditor.Parser" Version="2.0.0" />
-    <PackageReference Include="PixiEditor.Parser.Skia" Version="2.0.0" />
-    <PackageReference Include="SkiaSharp" Version="2.80.3" />
-    <PackageReference Include="System.Drawing.Common" Version="6.0.0" />
-    <PackageReference Include="WriteableBitmapEx">
-      <Version>1.6.8</Version>
-    </PackageReference>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="Images\AnchorDot.png" />
-    <Resource Include="Images\CheckerTile.png" />
-    <Resource Include="Images\ChevronDown.png" />
-    <Resource Include="Images\DiagonalRed.png" />
-    <Resource Include="Images\Eye-off.png" />
-    <Resource Include="Images\Eye.png" />
-    <Resource Include="Images\Folder-add.png" />
-    <Resource Include="Images\Folder.png" />
-    <Resource Include="Images\Layer-add.png" />
-    <Resource Include="Images\penMode.png" />
-    <Resource Include="Images\PixiBotLogo.png" />
-    <Resource Include="Images\PixiEditorLogo.png" />
-    <Resource Include="Images\PixiParserLogo.png" />
-    <Resource Include="Images\Placeholder.png" />
-    <Resource Include="Images\SocialMedia\DiscordIcon.png" />
-    <Resource Include="Images\SocialMedia\DonateIcon.png" />
-    <Resource Include="Images\SocialMedia\GitHubIcon.png" />
-    <Resource Include="Images\SocialMedia\RedditIcon.png" />
-    <Resource Include="Images\SocialMedia\WebsiteIcon.png" />
-    <Resource Include="Images\SocialMedia\YouTubeIcon.png" />
-    <Resource Include="Images\Tools\BrightnessImage.png" />
-    <Resource Include="Images\Tools\CircleImage.png" />
-    <Resource Include="Images\Tools\ColorPickerImage.png" />
-    <Resource Include="Images\Tools\EraserImage.png" />
-    <Resource Include="Images\Tools\FloodFillImage.png" />
-    <Resource Include="Images\Tools\LineImage.png" />
-    <Resource Include="Images\Tools\MagicWandImage.png" />
-    <Resource Include="Images\Tools\MoveImage.png" />
-    <Resource Include="Images\Tools\MoveViewportImage.png" />
-    <Resource Include="Images\Tools\PenImage.png" />
-    <Resource Include="Images\Tools\RectangleImage.png" />
-    <Resource Include="Images\Tools\SelectImage.png" />
-    <Resource Include="Images\Tools\ZoomImage.png" />
-    <Resource Include="Images\Trash.png" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="..\LICENSE">
-      <Pack>True</Pack>
-      <PackagePath></PackagePath>
-    </None>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\PixiEditor.UpdateModule\PixiEditor.UpdateModule.csproj" />
-  </ItemGroup>
-  <ItemGroup>
-    <Reference Include="PixiParser">
-      <HintPath>..\..\PixiParser\src\PixiParser.Skia\bin\Debug\net5.0\PixiParser.dll</HintPath>
-    </Reference>
-    <Reference Include="PixiParser.Skia">
-      <HintPath>..\..\PixiParser\src\PixiParser.Skia\bin\Debug\net5.0\PixiParser.Skia.dll</HintPath>
-    </Reference>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Update="Properties\Settings.Designer.cs">
-      <DesignTimeSharedInput>True</DesignTimeSharedInput>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Settings.settings</DependentUpon>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <None Update="Properties\Settings.settings">
-      <Generator>SettingsSingleFileGenerator</Generator>
-      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
-    </None>
-  </ItemGroup>
+	<ItemGroup>
+		<None Remove="Images\AnchorDot.png" />
+		<None Remove="Images\CheckerTile.png" />
+		<None Remove="Images\ChevronDown.png" />
+		<None Remove="Images\DiagonalRed.png" />
+		<None Remove="Images\Eye-off.png" />
+		<None Remove="Images\Eye.png" />
+		<None Remove="Images\Folder-add.png" />
+		<None Remove="Images\Folder.png" />
+		<None Remove="Images\Layer-add.png" />
+		<None Remove="Images\MoveImage.png" />
+		<None Remove="Images\MoveViewportImage.png" />
+		<None Remove="Images\penMode.png" />
+		<None Remove="Images\PixiBotLogo.png" />
+		<None Remove="Images\PixiEditorLogo.png" />
+		<None Remove="Images\PixiParserLogo.png" />
+		<None Remove="Images\Placeholder.png" />
+		<None Remove="Images\SelectImage.png" />
+		<None Remove="Images\SocialMedia\DiscordIcon.png" />
+		<None Remove="Images\SocialMedia\DonateIcon.png" />
+		<None Remove="Images\SocialMedia\GitHubIcon.png" />
+		<None Remove="Images\SocialMedia\RedditIcon.png" />
+		<None Remove="Images\SocialMedia\WebsiteIcon.png" />
+		<None Remove="Images\SocialMedia\YouTubeIcon.png" />
+		<None Remove="Images\Tools\BrightnessImage.png" />
+		<None Remove="Images\Tools\CircleImage.png" />
+		<None Remove="Images\Tools\ColorPickerImage.png" />
+		<None Remove="Images\Tools\EraserImage.png" />
+		<None Remove="Images\Tools\FloodFillImage.png" />
+		<None Remove="Images\Tools\LineImage.png" />
+		<None Remove="Images\Tools\MagicWandImage.png" />
+		<None Remove="Images\Tools\MoveImage.png" />
+		<None Remove="Images\Tools\MoveViewportImage.png" />
+		<None Remove="Images\Tools\PenImage.png" />
+		<None Remove="Images\Tools\RectangleImage.png" />
+		<None Remove="Images\Tools\SelectImage.png" />
+		<None Remove="Images\Tools\ZoomImage.png" />
+		<None Remove="Images\Trash.png" />
+		<None Remove="Images\UnknownFile.png" />
+		<None Remove="Images\ZoomImage.png" />
+		<None Include="..\icon.ico">
+			<Pack>True</Pack>
+			<PackagePath></PackagePath>
+		</None>
+		<None Include="..\LICENSE">
+			<Pack>True</Pack>
+			<PackagePath></PackagePath>
+		</None>
+	</ItemGroup>
+	<ItemGroup>
+		<PackageReference Include="Dirkster.AvalonDock" Version="4.60.0" />
+		<PackageReference Include="DiscordRichPresence" Version="1.0.175" />
+		<PackageReference Include="Expression.Blend.Sdk">
+			<Version>1.0.2</Version>
+			<NoWarn>NU1701</NoWarn>
+		</PackageReference>
+		<PackageReference Include="MessagePack" Version="2.3.85" />
+		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+		<PackageReference Include="MvvmLightLibs" Version="5.4.1.1">
+			<NoWarn>NU1701</NoWarn>
+		</PackageReference>
+		<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+		<PackageReference Include="PixiEditor.ColorPicker" Version="3.1.0" />
+		<PackageReference Include="PixiEditor.Parser" Version="2.0.0" />
+		<PackageReference Include="PixiEditor.Parser.Skia" Version="2.0.0" />
+		<PackageReference Include="SkiaSharp" Version="2.80.3" />
+		<PackageReference Include="System.Drawing.Common" Version="6.0.0" />
+		<PackageReference Include="WriteableBitmapEx">
+			<Version>1.6.8</Version>
+		</PackageReference>
+	</ItemGroup>
+	<ItemGroup>
+		<Resource Include="Images\AnchorDot.png" />
+		<Resource Include="Images\CheckerTile.png" />
+		<Resource Include="Images\ChevronDown.png" />
+		<Resource Include="Images\DiagonalRed.png" />
+		<Resource Include="Images\Eye-off.png" />
+		<Resource Include="Images\Eye.png" />
+		<Resource Include="Images\Folder-add.png" />
+		<Resource Include="Images\Folder.png" />
+		<Resource Include="Images\Layer-add.png" />
+		<Resource Include="Images\penMode.png" />
+		<Resource Include="Images\PixiBotLogo.png" />
+		<Resource Include="Images\PixiEditorLogo.png" />
+		<Resource Include="Images\PixiParserLogo.png" />
+		<Resource Include="Images\Placeholder.png" />
+		<Resource Include="Images\SocialMedia\DiscordIcon.png" />
+		<Resource Include="Images\SocialMedia\DonateIcon.png" />
+		<Resource Include="Images\SocialMedia\GitHubIcon.png" />
+		<Resource Include="Images\SocialMedia\RedditIcon.png" />
+		<Resource Include="Images\SocialMedia\WebsiteIcon.png" />
+		<Resource Include="Images\SocialMedia\YouTubeIcon.png" />
+		<Resource Include="Images\Tools\BrightnessImage.png" />
+		<Resource Include="Images\Tools\CircleImage.png" />
+		<Resource Include="Images\Tools\ColorPickerImage.png" />
+		<Resource Include="Images\Tools\EraserImage.png" />
+		<Resource Include="Images\Tools\FloodFillImage.png" />
+		<Resource Include="Images\Tools\LineImage.png" />
+		<Resource Include="Images\Tools\MagicWandImage.png" />
+		<Resource Include="Images\Tools\MoveImage.png" />
+		<Resource Include="Images\Tools\MoveViewportImage.png" />
+		<Resource Include="Images\Tools\PenImage.png" />
+		<Resource Include="Images\Tools\RectangleImage.png" />
+		<Resource Include="Images\Tools\SelectImage.png" />
+		<Resource Include="Images\Tools\ZoomImage.png" />
+		<Resource Include="Images\Trash.png" />
+	</ItemGroup>
+	<ItemGroup>
+		<None Include="..\LICENSE">
+			<Pack>True</Pack>
+			<PackagePath></PackagePath>
+		</None>
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\PixiEditor.UpdateModule\PixiEditor.UpdateModule.csproj" />
+	</ItemGroup>
+	<ItemGroup>
+		<Reference Include="PixiParser">
+			<HintPath>..\..\PixiParser\src\PixiParser.Skia\bin\Debug\net5.0\PixiParser.dll</HintPath>
+		</Reference>
+		<Reference Include="PixiParser.Skia">
+			<HintPath>..\..\PixiParser\src\PixiParser.Skia\bin\Debug\net5.0\PixiParser.Skia.dll</HintPath>
+		</Reference>
+	</ItemGroup>
+	<ItemGroup>
+		<Compile Update="Properties\Settings.Designer.cs">
+			<DesignTimeSharedInput>True</DesignTimeSharedInput>
+			<AutoGen>True</AutoGen>
+			<DependentUpon>Settings.settings</DependentUpon>
+		</Compile>
+	</ItemGroup>
+	<ItemGroup>
+		<None Update="Properties\Settings.settings">
+			<Generator>SettingsSingleFileGenerator</Generator>
+			<LastGenOutput>Settings.Designer.cs</LastGenOutput>
+		</None>
+	</ItemGroup>
 
 </Project>

PixiEditor/Properties/AssemblyInfo.cs

@@ -17,29 +17,29 @@ using System.Windows;
 // Setting ComVisible to false makes the types in this assembly not visible
 // to COM components.  If you need to access a type in this assembly from
 // COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
-
-// In order to begin building localizable applications, set
-// <UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
-// inside a <PropertyGroup>.  For example, if you are using US english
-// in your source files, set the <UICulture> to en-US.  Then uncomment
-// the NeutralResourceLanguage attribute below.  Update the "en-US" in
-// the line below to match the UICulture setting in the project file.
-
-// [assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
-
-// ResourceDictionaryLocation.None where theme specific resource dictionaries are located
-// (used if a resource is not found in the page,
-// or application resource dictionaries)
-
-// ResourceDictionaryLocation.SourceAssembly where the generic resource dictionary is located
-// (used if a resource is not found in the page,
-// app, or any theme specific resource dictionaries)
+[assembly: ComVisible(false)]
+
+// In order to begin building localizable applications, set
+// <UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
+// inside a <PropertyGroup>.  For example, if you are using US english
+// in your source files, set the <UICulture> to en-US.  Then uncomment
+// the NeutralResourceLanguage attribute below.  Update the "en-US" in
+// the line below to match the UICulture setting in the project file.
+
+// [assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+// ResourceDictionaryLocation.None where theme specific resource dictionaries are located
+// (used if a resource is not found in the page,
+// or application resource dictionaries)
+
+// ResourceDictionaryLocation.SourceAssembly where the generic resource dictionary is located
+// (used if a resource is not found in the page,
+// app, or any theme specific resource dictionaries)
 [assembly: ThemeInfo(
-    ResourceDictionaryLocation.None,
-    ResourceDictionaryLocation.SourceAssembly)
+    ResourceDictionaryLocation.None,
+    ResourceDictionaryLocation.SourceAssembly)
 ]
-
+
 // Version information for an assembly consists of the following four values:
 //
 //      Major Version
@@ -50,5 +50,5 @@ using System.Windows;
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.1.6.4")]
-[assembly: AssemblyFileVersion("0.1.6.4")]
+[assembly: AssemblyVersion("0.1.6.5")]
+[assembly: AssemblyFileVersion("0.1.6.5")]

PixiEditor/Styles/DarkCheckboxStyle.xaml

@@ -11,13 +11,18 @@
                 <ControlTemplate TargetType="CheckBox">
                     <BulletDecorator Background="Transparent">
                         <BulletDecorator.Bullet>
-                            <Border x:Name="Border" Width="20" Height="20" CornerRadius="2" Background="#FF1B1B1B" BorderThickness="0">
+                            <Border x:Name="Border" Width="20" Height="20" CornerRadius="2" Background="#FF1B1B1B"
+                                    BorderThickness="1">
                                 <Path Width="9" Height="9" x:Name="CheckMark" SnapsToDevicePixels="False" Stroke="#FF0077C9" StrokeThickness="2" Data="M 0 4 L 3 8 8 0" />
                             </Border>
                         </BulletDecorator.Bullet>
                         <ContentPresenter Margin="4,0,0,0" VerticalAlignment="Center" HorizontalAlignment="Left" RecognizesAccessKey="True"/>
                     </BulletDecorator>
                     <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="False">
+                            <Setter TargetName="Border" Property="Background" Value="#252525" />
+                            <Setter TargetName="Border" Property="BorderBrush" Value="#3F3F46"/>
+                        </Trigger>
                         <Trigger Property="IsChecked" Value="false">
                             <Setter TargetName="CheckMark" Property="Visibility" Value="Collapsed"/>
                         </Trigger>
@@ -25,11 +30,13 @@
                             <Setter TargetName="CheckMark" Property="Data" Value="M 0 8 L 8 0" />
                         </Trigger>
                         <Trigger Property="IsMouseOver" Value="true">
-                            <Setter TargetName="Border" Property="Background" Value="#FF131313" />
+                            <Setter TargetName="Border" Property="Background" Value="#202020" />
+                            <Setter TargetName="Border" Property="BorderBrush" Value="#4F4F4F"/>
                         </Trigger>
                         <Trigger Property="IsEnabled" Value="false">
                             <Setter TargetName="CheckMark" Property="Stroke" Value="#FF6C6C6C"/>
                             <Setter Property="Foreground" Value="Gray"/>
+                            <Setter TargetName="Border" Property="BorderBrush" Value="#202020"/>
                         </Trigger>
                     </ControlTemplate.Triggers>
                 </ControlTemplate>

PixiEditor/Styles/ThemeColors.xaml

@@ -1,8 +1,10 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
+    <SolidColorBrush x:Key="PixiRed" Color="#e3002d" />
     <SolidColorBrush x:Key="MainColor" Color="#2D2D30" />
     <SolidColorBrush x:Key="AccentColor" Color="#252525" />
     <SolidColorBrush x:Key="DarkerAccentColor" Color="#202020" />
     <SolidColorBrush x:Key="BrighterAccentColor" Color="#3F3F46" />
+    <SolidColorBrush x:Key="AlmostLightModeAccentColor" Color="#4F4F4F" />
 </ResourceDictionary>

PixiEditor/Styles/ThemeStyle.xaml

@@ -138,13 +138,40 @@
             </Trigger>
         </Style.Triggers>
     </Style>
-    
+
 
     <Style TargetType="TextBox" x:Key="DarkTextBoxStyle">
-        <Setter Property="Background" Value="#202020" />
         <Setter Property="BorderThickness" Value="1" />
-        <Setter Property="BorderBrush" Value="#404040" />
         <Setter Property="Foreground" Value="Snow" />
+
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="TextBox">
+                    <Border Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}">
+                        <ScrollViewer Name="PART_ContentHost"/>
+                    </Border>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+
+        <Style.Resources>
+            <Style TargetType="Border">
+                <Setter Property="CornerRadius" Value="5"/>
+            </Style>
+        </Style.Resources>
+
+        <Style.Triggers>
+            <Trigger Property="IsMouseOver" Value="False">
+                <Setter Property="Background" Value="{StaticResource AccentColor}"/>
+                <Setter Property="BorderBrush" Value="{StaticResource BrighterAccentColor}"/>
+            </Trigger>
+            <Trigger Property="IsMouseOver" Value="True">
+                <Setter Property="Background" Value="{StaticResource DarkerAccentColor}"/>
+                <Setter Property="BorderBrush" Value="{StaticResource AlmostLightModeAccentColor}"/>
+            </Trigger>
+        </Style.Triggers>
     </Style>
 
     <Style TargetType="Button" x:Key="OpacityButtonStyle">

PixiEditor/ViewModels/SubViewModels/Main/DocumentViewModel.cs

@@ -1,9 +1,8 @@
-using System;
-using System.Linq;
-using PixiEditor.Helpers;
+using PixiEditor.Helpers;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Dialogs;
 using PixiEditor.Models.Enums;
+using System.Linq;
 
 namespace PixiEditor.ViewModels.SubViewModels.Main
 {
@@ -39,7 +38,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             {
                 Owner.BitmapManager.ActiveDocument?.FlipActiveDocument(FlipType.Horizontal);
             }
-            else if(parameter is "Vertical")
+            else if (parameter is "Vertical")
             {
                 Owner.BitmapManager.ActiveDocument?.FlipActiveDocument(FlipType.Vertical);
             }
@@ -66,6 +65,8 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                 if (result == ConfirmationType.Yes)
                 {
                     Owner.FileSubViewModel.SaveDocument(false);
+                    if (!document.ChangesSaved)
+                        return;
                 }
                 else if (result == ConfirmationType.Canceled)
                 {
@@ -109,4 +110,4 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             Owner.BitmapManager.ActiveDocument.CenterContent();
         }
     }
-}
+}

PixiEditor/ViewModels/SubViewModels/Main/IoViewModel.cs

@@ -1,9 +1,8 @@
 using PixiEditor.Helpers;
 using PixiEditor.Models.Controllers;
 using PixiEditor.Models.Controllers.Shortcuts;
-using PixiEditor.Models.Position;
+using PixiEditor.Models.Tools.Tools;
 using System;
-using System.Windows;
 using System.Windows.Input;
 
 namespace PixiEditor.ViewModels.SubViewModels.Main
@@ -14,121 +13,124 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
 
         public RelayCommand MouseDownCommand { get; set; }
 
+        public RelayCommand PreviewMouseMiddleButtonCommand { get; set; }
+
+        public RelayCommand MouseUpCommand { get; set; }
+
         public RelayCommand KeyDownCommand { get; set; }
 
         public RelayCommand KeyUpCommand { get; set; }
 
         private bool restoreToolOnKeyUp = false;
 
+        private MouseInputFilter filter = new();
+
         public IoViewModel(ViewModelMain owner)
             : base(owner)
         {
-            MouseMoveCommand = new RelayCommand(MouseMove);
-            MouseDownCommand = new RelayCommand(MouseDown);
-            KeyDownCommand = new RelayCommand(KeyDown);
-            KeyUpCommand = new RelayCommand(KeyUp);
+            MouseDownCommand = new RelayCommand(filter.MouseDown);
+            MouseMoveCommand = new RelayCommand(filter.MouseMove);
+            MouseUpCommand = new RelayCommand(filter.MouseUp);
+            PreviewMouseMiddleButtonCommand = new RelayCommand(OnPreviewMiddleMouseButton);
+            GlobalMouseHook.OnMouseUp += filter.MouseUp;
+            KeyDownCommand = new RelayCommand(OnKeyDown);
+            KeyUpCommand = new RelayCommand(OnKeyUp);
+
+            filter.OnMouseDown += OnMouseDown;
+            filter.OnMouseMove += OnMouseMove;
+            filter.OnMouseUp += OnMouseUp;
         }
 
-        public void MouseHook_OnMouseUp(object sender, Point p, MouseButton button)
+        private void OnKeyDown(object parameter)
         {
-            GlobalMouseHook.OnMouseUp -= MouseHook_OnMouseUp;
-            if (button == MouseButton.Left)
+            KeyEventArgs args = (KeyEventArgs)parameter;
+            var key = args.Key;
+            if (key == Key.System)
+                key = args.SystemKey;
+
+            ProcessShortcutDown(args.IsRepeat, key);
+
+            if (Owner.BitmapManager.ActiveDocument != null)
             {
-                Owner.BitmapManager.MouseController.StopRecordingMouseMovementChanges();
+                Owner.BitmapManager.InputTarget.OnKeyDown(key);
             }
-
-            Owner.BitmapManager.MouseController.MouseUp(new MouseEventArgs(
-                Mouse.PrimaryDevice,
-                (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds()));
         }
 
-        public void KeyDown(object parameter)
+        private void ProcessShortcutDown(bool isRepeat, Key key)
         {
-            KeyEventArgs args = (KeyEventArgs)parameter;
-            if (args.IsRepeat && !restoreToolOnKeyUp && Owner.ShortcutController.LastShortcut != null &&
+            if (isRepeat && !restoreToolOnKeyUp && Owner.ShortcutController.LastShortcut != null &&
                 Owner.ShortcutController.LastShortcut.Command == Owner.ToolsSubViewModel.SelectToolCommand)
             {
                 restoreToolOnKeyUp = true;
                 ShortcutController.BlockShortcutExecution = true;
             }
 
-            Owner.ShortcutController.KeyPressed(args.Key, Keyboard.Modifiers);
-            Owner.ToolsSubViewModel.ActiveTool.OnKeyDown(args);
+            Owner.ShortcutController.KeyPressed(key, Keyboard.Modifiers);
         }
 
-        private void MouseDown(object parameter)
+        private void OnKeyUp(object parameter)
         {
-            if (Owner.BitmapManager.ActiveDocument == null || Owner.BitmapManager.ActiveDocument.Layers.Count == 0)
+            KeyEventArgs args = (KeyEventArgs)parameter;
+            var key = args.Key;
+            if (key == Key.System)
+                key = args.SystemKey;
+
+            ProcessShortcutUp(key);
+
+            if (Owner.BitmapManager.ActiveDocument != null)
+                Owner.BitmapManager.InputTarget.OnKeyUp(key);
+        }
+
+        private void ProcessShortcutUp(Key key)
+        {
+            if (restoreToolOnKeyUp && Owner.ShortcutController.LastShortcut != null &&
+                Owner.ShortcutController.LastShortcut.ShortcutKey == key)
             {
-                return;
+                restoreToolOnKeyUp = false;
+                Owner.ToolsSubViewModel.SetActiveTool(Owner.ToolsSubViewModel.LastActionTool);
+                ShortcutController.BlockShortcutExecution = false;
             }
+        }
 
-            if (Mouse.LeftButton == MouseButtonState.Pressed)
+        private void OnMouseDown(object sender, MouseButton button)
+        {
+            if (button == MouseButton.Left)
             {
                 BitmapManager bitmapManager = Owner.BitmapManager;
                 var activeDocument = bitmapManager.ActiveDocument;
-                if (!bitmapManager.MouseController.IsRecordingChanges)
-                {
-                    bool clickedOnCanvas = activeDocument.MouseXOnCanvas >= 0 &&
-                        activeDocument.MouseXOnCanvas <= activeDocument.Width &&
-                        activeDocument.MouseYOnCanvas >= 0 &&
-                        activeDocument.MouseYOnCanvas <= activeDocument.Height;
-                    bitmapManager.MouseController.StartRecordingMouseMovementChanges(clickedOnCanvas);
-                    bitmapManager.MouseController.RecordMouseMovementChange(MousePositionConverter.CurrentCoordinates);
-                }
-            }
+                if (activeDocument == null)
+                    return;
 
-            Owner.BitmapManager.MouseController.MouseDown(new MouseEventArgs(
-                Mouse.PrimaryDevice,
-                (int)DateTimeOffset.UtcNow.ToUnixTimeSeconds()));
+                bitmapManager.InputTarget.OnLeftMouseButtonDown(activeDocument.MouseXOnCanvas, activeDocument.MouseYOnCanvas);
+            }
+        }
 
-            Coordinates cords = new Coordinates(
-                (int)Owner.BitmapManager.ActiveDocument.MouseXOnCanvas,
-                (int)Owner.BitmapManager.ActiveDocument.MouseYOnCanvas);
-            Owner.BitmapManager.MouseController.MouseDownCoordinates(cords);
+        private void OnPreviewMiddleMouseButton(object sender)
+        {
+            Owner.ToolsSubViewModel.SetActiveTool<MoveViewportTool>();
+        }
 
-            // Mouse down is guaranteed to only be raised from within this application, so by subscribing here we
-            // only listen for mouse up events that occurred as a result of a mouse down within this application.
-            // This seems better than maintaining a global listener indefinitely.
-            GlobalMouseHook.OnMouseUp += MouseHook_OnMouseUp;
+        private void OnMouseMove(object sender, EventArgs args)
+        {
+            var activeDocument = Owner.BitmapManager.ActiveDocument;
+            if (activeDocument == null)
+                return;
+            Owner.BitmapManager.InputTarget.OnMouseMove(activeDocument.MouseXOnCanvas, activeDocument.MouseYOnCanvas);
         }
 
-        /// <summary>
-        ///     Method connected with command, it executes tool "activity".
-        /// </summary>
-        /// <param name="parameter">CommandParameter.</param>
-        private void MouseMove(object parameter)
+        private void OnMouseUp(object sender, MouseButton button)
         {
             if (Owner.BitmapManager.ActiveDocument == null)
-            {
                 return;
-            }
-
-            Coordinates cords = new Coordinates(
-                (int)Owner.BitmapManager.ActiveDocument.MouseXOnCanvas,
-                (int)Owner.BitmapManager.ActiveDocument.MouseYOnCanvas);
-            MousePositionConverter.CurrentCoordinates = cords;
-
-            if (Owner.BitmapManager.MouseController.IsRecordingChanges && Mouse.LeftButton == MouseButtonState.Pressed)
+            if (button == MouseButton.Left)
             {
-                Owner.BitmapManager.MouseController.RecordMouseMovementChange(cords);
+                Owner.BitmapManager.InputTarget.OnLeftMouseButtonUp();
             }
-
-            Owner.BitmapManager.MouseController.MouseMoved(cords);
-        }
-
-        private void KeyUp(object parameter)
-        {
-            KeyEventArgs args = (KeyEventArgs)parameter;
-            if (restoreToolOnKeyUp && Owner.ShortcutController.LastShortcut != null &&
-                Owner.ShortcutController.LastShortcut.ShortcutKey == args.Key)
+            else if (button == MouseButton.Middle)
             {
-                restoreToolOnKeyUp = false;
-                Owner.ToolsSubViewModel.SetActiveTool(Owner.ToolsSubViewModel.LastActionTool);
-                ShortcutController.BlockShortcutExecution = false;
+                if (Owner.ToolsSubViewModel.LastActionTool != null)
+                    Owner.ToolsSubViewModel.SetActiveTool(Owner.ToolsSubViewModel.LastActionTool);
             }
-
-            Owner.ToolsSubViewModel.ActiveTool.OnKeyUp(args);
         }
     }
 }

PixiEditor/ViewModels/SubViewModels/Main/LayersViewModel.cs

@@ -1,7 +1,7 @@
 using PixiEditor.Helpers;
 using PixiEditor.Models.Controllers;
 using PixiEditor.Models.Layers;
-using PixiEditor.Views.UserControls;
+using PixiEditor.Models.Undo;
 using PixiEditor.Views.UserControls.Layers;
 using System;
 using System.Linq;
@@ -73,7 +73,11 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
 
         public bool CanDeleteSelected(object parameter)
         {
-            return (parameter is not null and (Layer or LayerGroup)) || (Owner.BitmapManager?.ActiveDocument?.ActiveLayer != null);
+            return (
+                (
+                    parameter is not null and (Layer or LayerGroup)) || (Owner.BitmapManager?.ActiveDocument?.ActiveLayer != null)
+                )
+                && Owner.BitmapManager.ActiveDocument != null;
         }
 
         public void DeleteSelected(object parameter)
@@ -170,14 +174,18 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
 
             Guid lastActiveLayerGuid = doc.ActiveLayerGuid;
 
+
             doc.AddNewLayer($"New Layer {Owner.BitmapManager.ActiveDocument.Layers.Count}");
 
+            var oldGroups = doc.LayerStructure.CloneGroups();
+
             if (doc.Layers.Count > 1)
             {
                 doc.MoveLayerInStructure(doc.Layers[^1].LayerGuid, lastActiveLayerGuid, true);
                 Guid? parent = parameter is Layer or LayerStructureItemContainer ? activeLayerParent?.GroupGuid : activeLayerParent.Parent?.GroupGuid;
                 doc.LayerStructure.AssignParent(doc.ActiveLayerGuid, parent);
-                doc.UndoManager.UndoStack.Pop();
+                doc.AddLayerStructureToUndo(oldGroups);
+                doc.UndoManager.SquashUndoChanges(3, "Add New Layer");
             }
             if (control != null)
             {

PixiEditor/ViewModels/SubViewModels/Main/StylusViewModel.cs

@@ -1,10 +1,8 @@
-using System.Windows;
-using System.Windows.Input;
-using GalaSoft.MvvmLight.CommandWpf;
-using PixiEditor.Models.Position;
+using GalaSoft.MvvmLight.CommandWpf;
 using PixiEditor.Models.Tools;
 using PixiEditor.Models.Tools.Tools;
 using PixiEditor.Models.UserPreferences;
+using System.Windows.Input;
 
 namespace PixiEditor.ViewModels.SubViewModels.Main
 {
@@ -75,7 +73,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
 
         private void StylusOutOfRange(StylusEventArgs e)
         {
-            Owner.BitmapManager.HighlightPixels(new Coordinates(-1, -1));
+            Owner.BitmapManager.UpdateHighlightIfNecessary(true);
         }
 
         private void StylusSystemGesture(StylusSystemGestureEventArgs e)
@@ -110,4 +108,4 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             }
         }
     }
-}
+}

PixiEditor/ViewModels/SubViewModels/Main/ToolsViewModel.cs

@@ -1,19 +1,14 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Reflection;
-using System.Windows.Input;
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using PixiEditor.Helpers;
-using PixiEditor.Models.Controllers;
 using PixiEditor.Models.Enums;
 using PixiEditor.Models.Events;
-using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools;
 using PixiEditor.Models.Tools.Tools;
 using PixiEditor.Models.Tools.ToolSettings.Settings;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Input;
 
 namespace PixiEditor.ViewModels.SubViewModels.Main
 {
@@ -41,7 +36,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
         public Tool ActiveTool
         {
             get => activeTool;
-            set => SetProperty(ref activeTool, value);
+            private set => SetProperty(ref activeTool, value);
         }
 
         public int ToolSize
@@ -54,7 +49,7 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
                 if (ActiveTool.Toolbar.GetSetting<SizeSetting>("ToolSize") is SizeSetting toolSize)
                 {
                     toolSize.Value = value;
-                    Owner.BitmapManager.HighlightPixels(MousePositionConverter.CurrentCoordinates);
+                    Owner.BitmapManager.UpdateHighlightIfNecessary();
                 }
             }
         }
@@ -90,15 +85,23 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             if (ActiveTool != null)
             {
                 activeTool.IsActive = false;
-                ActiveTool.OnDeselected();
             }
 
             LastActionTool = ActiveTool;
+
+
             ActiveTool = tool;
-            SelectedToolChanged?.Invoke(this, new SelectedToolEventArgs(LastActionTool, ActiveTool));
+
+            if (LastActionTool != ActiveTool)
+                SelectedToolChanged?.Invoke(this, new SelectedToolEventArgs(LastActionTool, ActiveTool));
+
+            //update old tool
+            Owner.BitmapManager.UpdateActionDisplay(LastActionTool);
+            //update new tool
+            Owner.BitmapManager.UpdateActionDisplay(ActiveTool);
+            Owner.BitmapManager.UpdateHighlightIfNecessary();
 
             tool.IsActive = true;
-            ActiveTool.OnSelected();
             SetToolCursor(tool.GetType());
 
             if (Owner.StylusSubViewModel != null)
@@ -188,4 +191,4 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             }
         }
     }
-}
+}

PixiEditor/ViewModels/SubViewModels/Main/UndoViewModel.cs

@@ -1,11 +1,6 @@
-using System;
-using System.IO;
-using System.Linq;
-using PixiEditor.Helpers;
-using PixiEditor.Models.Controllers;
-using PixiEditor.Models.DataHolders;
-using PixiEditor.Models.Tools;
+using PixiEditor.Helpers;
 using PixiEditor.Models.Undo;
+using System.IO;
 
 namespace PixiEditor.ViewModels.SubViewModels.Main
 {
@@ -28,14 +23,6 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             ClearUndoTempDirectory();
         }
 
-        public void TriggerNewUndoChange(Tool selectedTool)
-        {
-            var activeDoc = Owner.BitmapManager.ActiveDocument;
-            if (activeDoc is null) return;
-
-            selectedTool.AddUndoProcess(activeDoc);
-        }
-
         /// <summary>
         ///     Redo last action.
         /// </summary>
@@ -86,4 +73,4 @@ namespace PixiEditor.ViewModels.SubViewModels.Main
             return Owner.BitmapManager.ActiveDocument?.UndoManager.CanRedo ?? false;
         }
     }
-}
+}

PixiEditor/ViewModels/SubViewModels/UserPreferences/Settings/FileSettings.cs

@@ -1,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using PixiEditor.Models.Dialogs;
 
 namespace PixiEditor.ViewModels.SubViewModels.UserPreferences.Settings
 {
@@ -16,9 +12,9 @@ namespace PixiEditor.ViewModels.SubViewModels.UserPreferences.Settings
             set => RaiseAndUpdatePreference(ref showStartupWindow, value);
         }
 
-        private long defaultNewFileWidth = GetPreference("DefaultNewFileWidth", 16L);
+        private int defaultNewFileWidth = GetPreference("DefaultNewFileWidth", NewFileDialog.defaultSize);
 
-        public long DefaultNewFileWidth
+        public int DefaultNewFileWidth
         {
             get => defaultNewFileWidth;
             set
@@ -29,9 +25,9 @@ namespace PixiEditor.ViewModels.SubViewModels.UserPreferences.Settings
             }
         }
 
-        private long defaultNewFileHeight = GetPreference("DefaultNewFileHeight", 16L);
+        private int defaultNewFileHeight = GetPreference("DefaultNewFileHeight", NewFileDialog.defaultSize);
 
-        public long DefaultNewFileHeight
+        public int DefaultNewFileHeight
         {
             get => defaultNewFileHeight;
             set

PixiEditor/ViewModels/ViewModelMain.cs

@@ -132,7 +132,6 @@ namespace PixiEditor.ViewModels
             Preferences.Init();
             BitmapManager = services.GetRequiredService<BitmapManager>();
             BitmapManager.BitmapOperations.BitmapChanged += BitmapUtility_BitmapChanged;
-            BitmapManager.MouseController.StoppedRecordingChanges += MouseController_StoppedRecordingChanges;
             BitmapManager.DocumentChanged += BitmapManager_DocumentChanged;
 
             SelectionSubViewModel = services.GetService<SelectionViewModel>();
@@ -142,6 +141,7 @@ namespace PixiEditor.ViewModels
 
             FileSubViewModel = services.GetService<FileViewModel>();
             ToolsSubViewModel = services.GetService<ToolsViewModel>();
+            ToolsSubViewModel.SelectedToolChanged += BitmapManager_SelectedToolChanged;
             ToolsSubViewModel?.SetupTools(services);
 
             IoSubViewModel = services.GetService<IoViewModel>();
@@ -174,7 +174,7 @@ namespace PixiEditor.ViewModels
                         CreateToolShortcut<MoveTool>(Key.V, "Select Move Tool"),
                         CreateToolShortcut<SelectTool>(Key.M, "Select Select Tool"),
                         CreateToolShortcut<ZoomTool>(Key.Z, "Select Zoom Tool"),
-                        CreateToolShortcut<MoveViewportTool>(Key.H, "Select Viewport Move Tool"),
+                        CreateToolShortcut<MoveViewportTool>(Key.Space, "Select Viewport Move Tool"),
                         CreateToolShortcut<MagicWandTool>(Key.W, "Select Magic Wand Tool"),
                         new Shortcut(Key.OemPlus, ViewportSubViewModel.ZoomCommand, "Zoom in", 1),
                         new Shortcut(Key.OemMinus, ViewportSubViewModel.ZoomCommand, "Zoom out", -1),
@@ -218,8 +218,6 @@ namespace PixiEditor.ViewModels
                         new Shortcut(Key.F1, MiscSubViewModel.OpenShortcutWindowCommand, "Open the shortcut window", true)));
 
             BitmapManager.PrimaryColor = ColorsSubViewModel.PrimaryColor;
-
-            ToolsSubViewModel.SelectedToolChanged += BitmapManager_SelectedToolChanged;
         }
 
         /// <summary>
@@ -249,10 +247,12 @@ namespace PixiEditor.ViewModels
 
         private void BitmapManager_SelectedToolChanged(object sender, SelectedToolEventArgs e)
         {
-            e.OldTool.PropertyChanged -= SelectedTool_PropertyChanged;
+            if (e.OldTool != null)
+                e.OldTool.PropertyChanged -= SelectedTool_PropertyChanged;
             e.NewTool.PropertyChanged += SelectedTool_PropertyChanged;
 
             NotifyToolActionDisplayChanged();
+            BitmapManager.InputTarget.OnToolChange(e.NewTool);
         }
 
         private void SelectedTool_PropertyChanged(object sender, PropertyChangedEventArgs e)
@@ -360,11 +360,6 @@ namespace PixiEditor.ViewModels
             BitmapManager.ActiveDocument.CenterViewportTrigger.Execute(this, new Size(BitmapManager.ActiveDocument.Width, BitmapManager.ActiveDocument.Height));
         }
 
-        private void MouseController_StoppedRecordingChanges(object sender, EventArgs e)
-        {
-            UndoSubViewModel.TriggerNewUndoChange(ToolsSubViewModel.ActiveTool);
-        }
-
         private void BitmapUtility_BitmapChanged(object sender, BitmapChangedEventArgs e)
         {
             BitmapManager.ActiveDocument.ChangesSaved = false;

PixiEditor/Views/Dialogs/NewFilePopup.xaml

@@ -5,6 +5,7 @@
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:local="clr-namespace:PixiEditor.Views"
         xmlns:vm="clr-namespace:PixiEditor.ViewModels"
+        xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity" xmlns:behaviors="clr-namespace:PixiEditor.Helpers.Behaviours"
         mc:Ignorable="d"
         d:DesignHeight="600" Topmost="True" ShowInTaskbar="False" d:DesignWidth="450"
         DataContext="{DynamicResource NewFileMenuViewModel}" WindowStyle="None" WindowStartupLocation="CenterScreen" MinHeight="300" MinWidth="400" Height="600" Width="450" Name="newFilePopup" BorderBrush="Black" BorderThickness="1">
@@ -21,11 +22,14 @@
                         Executed="CommandBinding_Executed_Close" />
     </Window.CommandBindings>
 
-    <Grid Background="{StaticResource AccentColor}">
+    <Grid Background="{StaticResource AccentColor}" Focusable="True">
         <Grid.RowDefinitions>
             <RowDefinition Height="35" />
             <RowDefinition />
         </Grid.RowDefinitions>
+        <i:Interaction.Behaviors>
+            <behaviors:ClearFocusOnClickBehavior/>
+        </i:Interaction.Behaviors>
 
         <DockPanel Grid.Row="0" Background="{StaticResource MainColor}">
             <Button DockPanel.Dock="Right" HorizontalAlignment="Right" Style="{StaticResource CloseButtonStyle}"
@@ -37,12 +41,15 @@
         <StackPanel HorizontalAlignment="Center" Margin="0,60,0,0" Background="{StaticResource MainColor}"
                         VerticalAlignment="Top" Grid.Row="1" Width="350" Height="150">
             <local:SizePicker Margin="0,20" HorizontalAlignment="Center" Height="110"
-                                  ChosenHeight="{Binding FileHeight,Mode=TwoWay, ElementName=newFilePopup}"
-                                  ChosenWidth="{Binding FileWidth,Mode=TwoWay, ElementName=newFilePopup}" />
+                              ChosenHeight="{Binding FileHeight, Mode=TwoWay, ElementName=newFilePopup}"
+                              ChosenWidth="{Binding FileWidth, Mode=TwoWay, ElementName=newFilePopup}" 
+                              x:Name="sizePicker"
+                              NextControl="{Binding ElementName=createButton}"/>
         </StackPanel>
-        <Button VerticalAlignment="Bottom" HorizontalAlignment="Right" FontSize="20" Height="30" Width="60"
-                    Style="{StaticResource DarkRoundButton}" Content="OK" Margin="0,0,10,10" Grid.Row="1"
-                    Command="{Binding OkCommand}"
-                    CommandParameter="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}}" />
+        <Button VerticalAlignment="Bottom" HorizontalAlignment="Right" FontSize="20" Height="30" Width="120"
+                Style="{StaticResource DarkRoundButton}" Content="Create" Margin="0,0,10,10" Grid.Row="1"
+                Command="{Binding OkCommand}"
+                CommandParameter="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type Window}}}" 
+                x:Name="createButton"/>
     </Grid>
-</Window>
+</Window>

PixiEditor/Views/Dialogs/NewFilePopup.xaml.cs

@@ -8,18 +8,17 @@ namespace PixiEditor.Views
     /// </summary>
     public partial class NewFilePopup : Window
     {
-        // Using a DependencyProperty as the backing store for FileHeight.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty FileHeightProperty =
-            DependencyProperty.Register("FileHeight", typeof(int), typeof(NewFilePopup), new PropertyMetadata(16));
+            DependencyProperty.Register(nameof(FileHeight), typeof(int), typeof(NewFilePopup));
 
-        // Using a DependencyProperty as the backing store for FileWidth.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty FileWidthProperty =
-            DependencyProperty.Register("FileWidth", typeof(int), typeof(NewFilePopup), new PropertyMetadata(16));
+            DependencyProperty.Register(nameof(FileWidth), typeof(int), typeof(NewFilePopup));
 
         public NewFilePopup()
         {
             InitializeComponent();
             Owner = Application.Current.MainWindow;
+            sizePicker.FocusWidthPicker();
         }
 
         public int FileHeight

PixiEditor/Views/Dialogs/SettingsWindow.xaml

@@ -64,14 +64,16 @@
                                   IsChecked="{Binding SettingsSubViewModel.File.ShowStartupWindow}"/>
                         <StackPanel Orientation="Horizontal" Margin="0,10,0,0">
                             <Label Content="Max Saved Opened Recently:" ToolTip="How many documents are shown under File > Recent. Default: 8" Style="{StaticResource BaseLabel}"/>
-                            <views:NumberInput FontSize="16" Value="{Binding SettingsSubViewModel.File.MaxOpenedRecently, Mode=TwoWay}" Width="40"/>
+                            <views:NumberInput Min="0" FontSize="16" Value="{Binding SettingsSubViewModel.File.MaxOpenedRecently, Mode=TwoWay}" Width="40"/>
                         </StackPanel>
                         <Label Content="Default new file size:" Style="{StaticResource Header2}" Margin="0 20 0 20"/>
                         <StackPanel Orientation="Horizontal" Margin="40,0,0,0">
                             <Label Content="Width:" Style="{StaticResource BaseLabel}"/>
-                            <views:SizeInput FontSize="16" Size="{Binding SettingsSubViewModel.File.DefaultNewFileWidth, Mode=TwoWay}" Width="60" Height="25"/>
+                            <views:SizeInput FontSize="16" Size="{Binding SettingsSubViewModel.File.DefaultNewFileWidth, Mode=TwoWay}" 
+                                             Width="70" Height="25" MaxSize="9999"/>
                             <Label Content="Height:" Style="{StaticResource BaseLabel}"/>
-                            <views:SizeInput FontSize="16" Size="{Binding SettingsSubViewModel.File.DefaultNewFileHeight, Mode=TwoWay}" Width="60" Height="25"/>
+                            <views:SizeInput FontSize="16" Size="{Binding SettingsSubViewModel.File.DefaultNewFileHeight, Mode=TwoWay}" 
+                                             Width="70" Height="25" MaxSize="9999"/>
                         </StackPanel>
                     </StackPanel>
                 </StackPanel>

PixiEditor/Views/MainWindow.xaml

@@ -63,7 +63,7 @@
             <cmd:EventToCommand Command="{Binding CloseWindowCommand}" PassEventArgsToCommand="True" />
         </i:EventTrigger>
     </i:Interaction.Triggers>
-    <Grid Name="mainGrid" Margin="5" Focusable="True">
+    <Grid Name="mainGrid" Margin="5" Focusable="True" >
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="45" />
             <ColumnDefinition Width="1*" />
@@ -149,7 +149,7 @@
                     <MenuItem Header="_Flip Horizontal" Command="{Binding DocumentSubViewModel.FlipCommand}" CommandParameter="Horizontal"/>
                     <MenuItem Header="_Flip Vertical" Command="{Binding DocumentSubViewModel.FlipCommand}" CommandParameter="Vertical"/>
                 -->
-                    </MenuItem> 
+                </MenuItem>
                 <MenuItem Header="_View">
                     <MenuItem Header="_Show Grid Lines" IsChecked="{Binding ViewportSubViewModel.GridLinesEnabled, Mode=TwoWay}"
                               IsCheckable="True" InputGestureText="Ctrl+`"/>
@@ -256,13 +256,14 @@
                 </ItemsControl.ItemTemplate>
             </ItemsControl>
         </StackPanel>
-        <Grid Grid.Column="1" Grid.Row="2" Background="#303030">
+        <Grid Grid.Column="1" Grid.Row="2" Background="#303030" >
             <Grid AllowDrop="True" Drop="MainWindow_Drop">
-                <DockingManager ActiveContent="{Binding BitmapManager.ActiveDocument, Mode=TwoWay, Converter={StaticResource DockingManagerActiveContentConverter}}" 
+                <DockingManager ActiveContent="{Binding BitmapManager.ActiveDocument, Mode=TwoWay, Converter={StaticResource DockingManagerActiveContentConverter}}"
                                            DocumentsSource="{Binding BitmapManager.Documents}">
                     <DockingManager.Theme>
                         <avalonDockTheme:PixiEditorDockTheme />
                     </DockingManager.Theme>
+
                     <avalondock:DockingManager.LayoutItemContainerStyleSelector>
                         <ui:PanelsStyleSelector>
                             <ui:PanelsStyleSelector.DocumentTabStyle>
@@ -282,9 +283,10 @@
                                         ZoomViewportTrigger="{Binding ZoomViewportTrigger}"
                                         GridLinesVisible="{Binding XamlAccesibleViewModel.ViewportSubViewModel.GridLinesEnabled}"
                                         Cursor="{Binding XamlAccesibleViewModel.ToolsSubViewModel.ToolCursor}"
-                                        MiddleMouseClickedCommand="{Binding XamlAccesibleViewModel.ToolsSubViewModel.SelectToolCommand}"
+                                        MiddleMouseClickedCommand="{Binding XamlAccesibleViewModel.IoSubViewModel.PreviewMouseMiddleButtonCommand}"
                                         MouseMoveCommand="{Binding XamlAccesibleViewModel.IoSubViewModel.MouseMoveCommand}"
                                         MouseDownCommand="{Binding XamlAccesibleViewModel.IoSubViewModel.MouseDownCommand}"
+                                        MouseUpCommand="{Binding XamlAccesibleViewModel.IoSubViewModel.MouseUpCommand}"
                                         MouseXOnCanvas="{Binding MouseXOnCanvas, Mode=TwoWay}"
                                         MouseYOnCanvas="{Binding MouseYOnCanvas, Mode=TwoWay}"
                                         StylusButtonDownCommand="{Binding XamlAccesibleViewModel.StylusSubViewModel.StylusDownCommand}"

PixiEditor/Views/MainWindow.xaml.cs

@@ -60,6 +60,8 @@ namespace PixiEditor
                     UpdateTaskbarIcon(null);
                 }
             });
+
+            OnReleaseBuild();
         }
 
         protected override void OnClosing(CancelEventArgs e)
@@ -80,6 +82,12 @@ namespace PixiEditor
             Application.Current.Windows.OfType<HelloTherePopup>().ToList().ForEach(x => { if (!x.IsClosing) x.Close(); });
         }
 
+        [Conditional("RELEASE")]
+        private void OnReleaseBuild()
+        {
+            rawLayerAnchorable.Hide();
+        }
+
         private void BitmapManager_DocumentChanged(object sender, Models.Events.DocumentChangedEventArgs e)
         {
             if (preferences.GetPreference("ImagePreviewInTaskbar", false))

PixiEditor/Views/UserControls/DrawingViewPort.xaml

@@ -24,10 +24,13 @@
                    UseTouchGestures="{Binding UseTouchGestures, ElementName=uc}">
         <i:Interaction.Triggers>
             <i:EventTrigger EventName="MouseMove">
-                <i:InvokeCommandAction Command="{Binding MouseMoveCommand, ElementName=uc}" />
+                <cmd:EventToCommand Command="{Binding MouseMoveCommand, ElementName=uc}" PassEventArgsToCommand="True" />
             </i:EventTrigger>
             <i:EventTrigger EventName="MouseDown">
-                <i:InvokeCommandAction Command="{Binding MouseDownCommand, ElementName=uc}"/>
+                <cmd:EventToCommand Command="{Binding MouseDownCommand, ElementName=uc}" PassEventArgsToCommand="True" />
+            </i:EventTrigger>
+            <i:EventTrigger EventName="MouseUp">
+                <cmd:EventToCommand Command="{Binding MouseUpCommand, ElementName=uc}" PassEventArgsToCommand="True" />
             </i:EventTrigger>
             <i:EventTrigger EventName="PreviewMouseDown">
                 <i:InvokeCommandAction Command="{Binding PreviewMouseDownCommand, ElementName=uc}"/>
@@ -85,14 +88,14 @@
                 <Image VerticalAlignment="Top" HorizontalAlignment="Left" Source="{Binding Renderer.FinalBitmap}"
                        RenderOptions.BitmapScalingMode="NearestNeighbor" Stretch="Uniform" 
                        Visibility="{Binding XamlAccesibleViewModel.BitmapManager.OnlyReferenceLayer, Converter={InverseBoolToVisibilityConverter}}"/>
-                
+
                 <local:PlainLayerView TargetLayer="{Binding ActiveSelection.SelectionLayer}"
                                       VerticalAlignment="Top" HorizontalAlignment="Left"
                                       Width="{Binding ActiveSelection.SelectionLayer.Width}"
                                       Height="{Binding ActiveSelection.SelectionLayer.Height}"
                                       Margin="{Binding ActiveSelection.SelectionLayer.Offset}"
                                       Opacity="0.5"/>
-                
+
                 <Grid ShowGridLines="True" Width="{Binding Width}" Height="{Binding Height}" Panel.ZIndex="10" 
                       Visibility="{Binding GridLinesVisible, Converter={StaticResource BoolToVisibilityConverter}, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:DrawingViewPort}}}">
                     <Rectangle Focusable="False">

PixiEditor/Views/UserControls/DrawingViewPort.xaml.cs

@@ -1,5 +1,4 @@
 using PixiEditor.Helpers;
-using PixiEditor.Models.Tools.Tools;
 using System;
 using System.Windows;
 using System.Windows.Controls;
@@ -20,7 +19,10 @@ namespace PixiEditor.Views.UserControls
 
         public static readonly DependencyProperty MouseDownCommandProperty =
             DependencyProperty.Register(nameof(MouseDownCommand), typeof(ICommand), typeof(DrawingViewPort), new PropertyMetadata(default(ICommand)));
-        
+
+        public static readonly DependencyProperty MouseUpCommandProperty =
+            DependencyProperty.Register(nameof(MouseUpCommand), typeof(ICommand), typeof(DrawingViewPort), new PropertyMetadata(default(ICommand)));
+
         public static readonly DependencyProperty StylusButtonDownCommandProperty =
             DependencyProperty.Register(nameof(StylusButtonDownCommand), typeof(ICommand), typeof(DrawingViewPort), new PropertyMetadata(default(ICommand)));
 
@@ -77,6 +79,12 @@ namespace PixiEditor.Views.UserControls
             set => SetValue(MouseDownCommandProperty, value);
         }
 
+        public ICommand MouseUpCommand
+        {
+            get => (ICommand)GetValue(MouseUpCommandProperty);
+            set => SetValue(MouseUpCommandProperty, value);
+        }
+
         public ICommand StylusButtonDownCommand
         {
             get => (ICommand)GetValue(StylusButtonDownCommandProperty);
@@ -195,8 +203,8 @@ namespace PixiEditor.Views.UserControls
 
         private void ProcessMouseDown(object parameter)
         {
-            if (Mouse.MiddleButton == MouseButtonState.Pressed && MiddleMouseClickedCommand.CanExecute(typeof(MoveViewportTool)))
-                MiddleMouseClickedCommand.Execute(typeof(MoveViewportTool));
+            if (Mouse.MiddleButton == MouseButtonState.Pressed && MiddleMouseClickedCommand.CanExecute(null))
+                MiddleMouseClickedCommand.Execute(null);
         }
 
         private void OnCanvasLoaded(object sender, EventArgs e)

PixiEditor/Views/UserControls/Layers/LayerGroupControl.xaml.cs

@@ -61,12 +61,12 @@ namespace PixiEditor.Views.UserControls.Layers
             LayerGroupControl control = (LayerGroupControl)d;
             if (e.OldValue is LayersViewModel oldVm && oldVm != e.NewValue)
             {
-                oldVm.Owner.BitmapManager.MouseController.StoppedRecordingChanges -= control.MouseController_StoppedRecordingChanges;
+                oldVm.Owner.BitmapManager.StopUsingTool -= control.MouseController_StoppedRecordingChanges;
             }
 
             if (e.NewValue is LayersViewModel vm)
             {
-                vm.Owner.BitmapManager.MouseController.StoppedRecordingChanges += control.MouseController_StoppedRecordingChanges;
+                vm.Owner.BitmapManager.StopUsingTool += control.MouseController_StoppedRecordingChanges;
             }
         }
 
@@ -100,7 +100,12 @@ namespace PixiEditor.Views.UserControls.Layers
 
         private static void GroupDataChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
-            ((LayerGroupControl)d).GeneratePreviewImage();
+            LayerGroupControl control = (LayerGroupControl)d;
+            control.GeneratePreviewImage();
+            foreach (var layer in control.LayersViewModel.Owner.BitmapManager.ActiveDocument.Layers)
+            {
+                layer.IsVisible = layer.IsVisible;
+            }
         }
 
         public WriteableBitmap PreviewImage

PixiEditor/Views/UserControls/Layers/LayersManager.xaml.cs

@@ -1,5 +1,4 @@
-using PixiEditor.Helpers;
-using PixiEditor.Models.Controllers;
+using PixiEditor.Models.Controllers;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Undo;
@@ -125,6 +124,9 @@ namespace PixiEditor.Views.UserControls.Layers
             {
                 var doc = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument;
 
+                if (group.Opacity == value)
+                    return;
+
                 var processArgs = new object[] { group.GroupGuid, value };
                 var reverseProcessArgs = new object[] { group.GroupGuid, group.Opacity };
 
@@ -198,6 +200,8 @@ namespace PixiEditor.Views.UserControls.Layers
         private void HandleLayerOpacityChange(float val, Layer layer)
         {
             float oldOpacity = layer.Opacity;
+            if (oldOpacity == val)
+                return;
 
             var doc = LayerCommandsViewModel.Owner.BitmapManager.ActiveDocument;
 

PixiEditor/Views/UserControls/NumberInput.xaml

@@ -8,7 +8,7 @@
              mc:Ignorable="d"
              d:DesignHeight="20" d:DesignWidth="40" x:Name="numberInput">
     <TextBox TextAlignment="Center" Style="{StaticResource DarkTextBoxStyle}" Focusable="True"
-             InputScope="Number"
+             InputScope="Number" MouseWheel="TextBox_MouseWheel"
              PreviewTextInput="TextBox_PreviewTextInput" Text="{Binding ElementName=numberInput, Path=Value}">
         <i:Interaction.Behaviors>
             <behaviours:TextBoxFocusBehavior/>

PixiEditor/Views/UserControls/NumberInput.xaml.cs

@@ -15,7 +15,7 @@ namespace PixiEditor.Views
         // Using a DependencyProperty as the backing store for Value.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty ValueProperty =
             DependencyProperty.Register(
-                "Value",
+                nameof(Value),
                 typeof(float),
                 typeof(NumberInput),
                 new PropertyMetadata(0f, OnValueChanged));
@@ -23,7 +23,7 @@ namespace PixiEditor.Views
         // Using a DependencyProperty as the backing store for Min.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty MinProperty =
             DependencyProperty.Register(
-                "Min",
+                nameof(Min),
                 typeof(float),
                 typeof(NumberInput),
                 new PropertyMetadata(float.NegativeInfinity));
@@ -31,12 +31,12 @@ namespace PixiEditor.Views
         // Using a DependencyProperty as the backing store for Max.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty MaxProperty =
             DependencyProperty.Register(
-                "Max",
+                nameof(Max),
                 typeof(float),
                 typeof(NumberInput),
                 new PropertyMetadata(float.PositiveInfinity));
 
-        private Regex regex = new Regex("^[.][0-9]+$|^[0-9]*[.]{0,1}[0-9]*$");
+        private readonly Regex regex = new Regex("^[.][0-9]+$|^[0-9]*[.]{0,1}[0-9]*$", RegexOptions.Compiled);
 
         public NumberInput()
         {
@@ -71,5 +71,24 @@ namespace PixiEditor.Views
         {
             e.Handled = !regex.IsMatch((sender as TextBox).Text.Insert((sender as TextBox).SelectionStart, e.Text));
         }
+
+        private void TextBox_MouseWheel(object sender, MouseWheelEventArgs e)
+        {
+            int step = e.Delta / 100;
+
+            if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
+            {
+                float multiplier = (Max - Min) * 0.1f;
+                Value += step * multiplier;
+            }
+            else if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
+            {
+                Value += step / 2f;
+            }
+            else
+            {
+                Value += step;
+            }
+        }
     }
 }

PixiEditor/Views/UserControls/PlainLayerView.xaml.cs

@@ -40,9 +40,15 @@ namespace PixiEditor.Views.UserControls
             var view = (PlainLayerView)sender;
             if (args.OldValue != null)
                 ((Layer)args.OldValue).LayerBitmapChanged -= view.OnLayerBitmapChanged;
+
             if (args.NewValue != null)
             {
                 var layer = ((Layer)args.NewValue);
+                if (layer.LayerBitmap.Disposed)
+                {
+                    view.TargetLayer = null;
+                    return;
+                }
                 layer.LayerBitmapChanged += view.OnLayerBitmapChanged;
                 view.Resize(layer.Width, layer.Height);
             }

PixiEditor/Views/UserControls/SizeInput.xaml

@@ -7,22 +7,49 @@
              xmlns:behaviors="clr-namespace:PixiEditor.Helpers.Behaviours"
              xmlns:converters="clr-namespace:PixiEditor.Helpers.Converters"
              xmlns:validators="clr-namespace:PixiEditor.Helpers.Validators"
-             mc:Ignorable="d"
+             mc:Ignorable="d" Foreground="White" Focusable="True"
              d:DesignHeight="30" d:DesignWidth="160" Name="uc" LayoutUpdated="UserControlLayoutUpdated">
-    <TextBox IsEnabled="{Binding IsEnabled, ElementName=uc}" HorizontalContentAlignment="Center"
-             Style="{StaticResource DarkTextBoxStyle}" MaxLength="4" InputScope="Number">
-        <TextBox.Text>
-            <Binding ElementName="uc"
-                     Path="Size" Mode="TwoWay"
-                     Converter="{converters:ToolSizeToIntConverter}">
-                <Binding.ValidationRules>
-                    <validators:SizeValidationRule ValidatesOnTargetUpdated="True" />
-                </Binding.ValidationRules>
-            </Binding>
-        </TextBox.Text>
-        <i:Interaction.Behaviors>
-            <behaviors:GlobalShortcutFocusBehavior/>
-            <behaviors:TextBoxFocusBehavior FillSize="True" />
-        </i:Interaction.Behaviors>
-    </TextBox>
-</UserControl>
+
+    <Border BorderThickness="1" CornerRadius="3.5"
+            x:Name="border"
+            Cursor="IBeam" MouseLeftButtonDown="Border_MouseLeftButtonDown"
+            MouseWheel="Border_MouseWheel">
+        <Border.Style>
+            <Style TargetType="Border">
+                <Style.Triggers>
+                    <Trigger Property="IsMouseOver" Value="False">
+                        <Setter Property="Background" Value="{StaticResource AccentColor}"/>
+                        <Setter Property="BorderBrush" Value="{StaticResource BrighterAccentColor}"/>
+                    </Trigger>
+                    <Trigger Property="IsMouseOver" Value="True">
+                        <Setter Property="Background" Value="{StaticResource DarkerAccentColor}"/>
+                        <Setter Property="BorderBrush" Value="{StaticResource AlmostLightModeAccentColor}"/>
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+        </Border.Style>
+        <Grid>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition/>
+                <ColumnDefinition Width="2"/>
+                <ColumnDefinition Width="Auto"/>
+            </Grid.ColumnDefinitions>
+            <TextBox IsEnabled="{Binding IsEnabled, ElementName=uc}" HorizontalContentAlignment="Right"
+                     InputScope="Number" BorderThickness="0" Background="Transparent"
+                     Foreground="{Binding Foreground, ElementName=uc}" Focusable="True" CaretBrush="{Binding Foreground, ElementName=uc}"
+                     Margin="0,0,5,0" VerticalAlignment="Center"
+                     x:Name="textBox"
+                     Text="{Binding Size, ElementName=uc, Converter={converters:ToolSizeToIntConverter}}"
+                     d:Text="22">
+                <i:Interaction.Behaviors>
+                    <behaviors:GlobalShortcutFocusBehavior/>
+                    <behaviors:TextBoxFocusBehavior SelectOnFocus="{Binding SelectOnFocus, ElementName=uc}" NextControl="{Binding NextControl, ElementName=uc}"/>
+                </i:Interaction.Behaviors>
+            </TextBox>
+            <Grid Grid.Column="1" Background="{Binding BorderBrush, ElementName=border}"
+                  d:Background="{StaticResource BrighterAccentColor}"/>
+            <TextBlock Text="px" TextAlignment="Right"
+                       Grid.Column="2" Margin="5,0" VerticalAlignment="Center"/>
+        </Grid>
+    </Border>
+</UserControl>

PixiEditor/Views/UserControls/SizeInput.xaml.cs

@@ -1,7 +1,7 @@
 using System;
-using System.Diagnostics;
 using System.Windows;
 using System.Windows.Controls;
+using System.Windows.Input;
 
 namespace PixiEditor.Views
 {
@@ -10,22 +10,18 @@ namespace PixiEditor.Views
     /// </summary>
     public partial class SizeInput : UserControl
     {
-        // Using a DependencyProperty as the backing store for Size.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty SizeProperty =
-            DependencyProperty.Register("Size", typeof(int), typeof(SizeInput), new PropertyMetadata(1, InputSizeChanged));
+            DependencyProperty.Register(nameof(Size), typeof(int), typeof(SizeInput), new PropertyMetadata(1, InputSizeChanged));
 
-        // Using a DependencyProperty as the backing store for PreserveAspectRatio.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty PreserveAspectRatioProperty =
             DependencyProperty.Register(
-                "PreserveAspectRatio",
+                nameof(PreserveAspectRatio),
                 typeof(bool),
-                typeof(SizeInput),
-                new PropertyMetadata(false));
+                typeof(SizeInput));
 
-        // Using a DependencyProperty as the backing store for AspectRatioValue.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty AspectRatioValueProperty =
             DependencyProperty.Register(
-                "AspectRatioValue",
+                nameof(AspectRatioValue),
                 typeof(int),
                 typeof(SizeInput),
                 new PropertyMetadata(1));
@@ -36,26 +32,52 @@ namespace PixiEditor.Views
             set { SetValue(AspectRatioControlProperty, value); }
         }
 
-        // Using a DependencyProperty as the backing store for AspectRatioControl.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty AspectRatioControlProperty =
-            DependencyProperty.Register("AspectRatioControl", typeof(SizeInput), typeof(SizeInput), new PropertyMetadata(default));
+            DependencyProperty.Register(nameof(AspectRatioControl), typeof(SizeInput), typeof(SizeInput), new PropertyMetadata(default));
+
+        public static readonly DependencyProperty MaxSizeProperty =
+            DependencyProperty.Register(nameof(MaxSize), typeof(int), typeof(SizeInput), new PropertyMetadata(int.MaxValue));
+
+        public static readonly DependencyProperty SelectOnFocusProperty =
+            DependencyProperty.Register(nameof(SelectOnFocus), typeof(bool), typeof(SizeInput), new PropertyMetadata(true));
 
         private int loadedAspectRatioSize = -1;
 
         private int loadedSize = -1;
         private bool blockUpdate = false;
 
+        public static readonly DependencyProperty NextControlProperty =
+            DependencyProperty.Register(nameof(NextControl), typeof(FrameworkElement), typeof(SizeInput));
+
         public SizeInput()
         {
+            GotKeyboardFocus += SizeInput_GotKeyboardFocus;
             InitializeComponent();
         }
 
+        public bool SelectOnFocus
+        {
+            get => (bool)GetValue(SelectOnFocusProperty);
+            set => SetValue(SelectOnFocusProperty, value);
+        }
+
+        private void SizeInput_GotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
+        {
+            textBox.Focus();
+        }
+
         public int Size
         {
             get => (int)GetValue(SizeProperty);
             set => SetValue(SizeProperty, value);
         }
 
+        public int MaxSize
+        {
+            get => (int)GetValue(MaxSizeProperty);
+            set => SetValue(MaxSizeProperty, value);
+        }
+
         public bool PreserveAspectRatio
         {
             get => (bool)GetValue(PreserveAspectRatioProperty);
@@ -68,8 +90,30 @@ namespace PixiEditor.Views
             set => SetValue(AspectRatioValueProperty, value);
         }
 
+        public FrameworkElement NextControl
+        {
+            get => (FrameworkElement)GetValue(NextControlProperty);
+            set => SetValue(NextControlProperty, value);
+        }
+
         private static void InputSizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
+            int newValue = (int)e.NewValue;
+            int maxSize = (int)d.GetValue(MaxSizeProperty);
+
+            if (newValue > maxSize)
+            {
+                d.SetValue(SizeProperty, maxSize);
+
+                return;
+            }
+            else if (newValue <= 0)
+            {
+                d.SetValue(SizeProperty, 1);
+
+                return;
+            }
+
             SizeInput input = ((SizeInput)d).AspectRatioControl;
             if (input == null)
             {
@@ -99,5 +143,36 @@ namespace PixiEditor.Views
                 loadedAspectRatioSize = AspectRatioValue;
             }
         }
+
+        private void Border_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
+        {
+            textBox.Focus();
+            e.Handled = true;
+        }
+
+        private void Border_MouseWheel(object sender, System.Windows.Input.MouseWheelEventArgs e)
+        {
+            int step = e.Delta / 100;
+
+            if (Keyboard.IsKeyDown(Key.LeftShift))
+            {
+                Size += step * 2;
+            }
+            else if (Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                if (step < 0)
+                {
+                    Size /= 2;
+                }
+                else
+                {
+                    Size *= 2;
+                }
+            }
+            else
+            {
+                Size += step;
+            }
+        }
     }
-}
+}

PixiEditor/Views/UserControls/SizePicker.xaml

@@ -6,30 +6,41 @@
              xmlns:local="clr-namespace:PixiEditor.Views"
              mc:Ignorable="d"
              d:DesignHeight="110" d:DesignWidth="215" Name="uc">
+    <UserControl.Resources>
+        <Style TargetType="local:SizeInput">
+            <Setter Property="HorizontalAlignment" Value="Left"/>
+            <Setter Property="MaxSize" Value="9999"/>
+            <Setter Property="SelectOnFocus" Value="False"/>
+            <Setter Property="FontSize" Value="16"/>
+            <Setter Property="Margin" Value="10,0,0,0"/>
+            <Setter Property="Width" Value="150"/>
+            <Setter Property="Height" Value="30"/>
+        </Style>
+    </UserControl.Resources>
     <StackPanel Background="{StaticResource MainColor}">
         <DockPanel Margin="5,10,0,0" HorizontalAlignment="Center" VerticalAlignment="Center">
-            <TextBlock Height="30" Foreground="Snow" Text="Width:" TextAlignment="Center" FontSize="16"
+            <TextBlock Height="20" Foreground="Snow" Text="Width:" TextAlignment="Center" FontSize="16"
                        HorizontalAlignment="Center" VerticalAlignment="Center" />
-            <local:SizeInput x:Name="WidthPicker" IsEnabled="{Binding EditingEnabled, ElementName=uc}" Width="150" Height="30"
+            <local:SizeInput x:Name="WidthPicker"
+                             IsEnabled="{Binding EditingEnabled, ElementName=uc}"
                              PreserveAspectRatio="{Binding Path=IsChecked, ElementName=aspectRatio}"
                              AspectRatioValue="{Binding Path=ChosenHeight, ElementName=uc}"
                              AspectRatioControl="{Binding ElementName=HeightPicker}"
-                             HorizontalAlignment="Left" Margin="10,0,0,0"
-                             FontSize="16"
+                             NextControl="{Binding ElementName=HeightPicker}"
                              Size="{Binding Path=ChosenWidth, ElementName=uc, Mode=TwoWay}" />
         </DockPanel>
         <DockPanel Margin="5,10,0,0" HorizontalAlignment="Center" VerticalAlignment="Center">
-            <TextBlock Height="30" Foreground="Snow" Text="Height:" TextAlignment="Center" FontSize="16"
+            <TextBlock Height="20" Foreground="Snow" Text="Height:" TextAlignment="Center" FontSize="16"
                        HorizontalAlignment="Center" VerticalAlignment="Center" />
-            <local:SizeInput x:Name="HeightPicker" IsEnabled="{Binding EditingEnabled, ElementName=uc}" Margin="5,0,0,0"
+            <local:SizeInput x:Name="HeightPicker" 
+                             IsEnabled="{Binding EditingEnabled, ElementName=uc}"
+                             Margin="5,0,0,0"
                              PreserveAspectRatio="{Binding Path=IsChecked, ElementName=aspectRatio}"
                              AspectRatioValue="{Binding Path=ChosenWidth, ElementName=uc}"
                              AspectRatioControl="{Binding ElementName=WidthPicker}"
-                             HorizontalAlignment="Left" Width="150" Height="30"
-                             FontSize="16"
+                             NextControl="{Binding NextControl, ElementName=uc}"
                              Size="{Binding ChosenHeight, ElementName=uc, Mode=TwoWay}" />
         </DockPanel>
-        <CheckBox Name="aspectRatio" Content="Preserve aspect ratio" Foreground="White" HorizontalAlignment="Left"
-                  IsChecked="True" Margin="50,10,0,0" />
+        <CheckBox Name="aspectRatio" Content="Preserve aspect ratio" Foreground="White" HorizontalAlignment="Left" Margin="50,10,0,0" />
     </StackPanel>
-</UserControl>
+</UserControl>

PixiEditor/Views/UserControls/SizePicker.xaml.cs

@@ -8,17 +8,17 @@ namespace PixiEditor.Views
     /// </summary>
     public partial class SizePicker : UserControl
     {
-        // Using a DependencyProperty as the backing store for EditingEnabled.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty EditingEnabledProperty =
-            DependencyProperty.Register("EditingEnabled", typeof(bool), typeof(SizePicker), new PropertyMetadata(true));
+            DependencyProperty.Register(nameof(EditingEnabled), typeof(bool), typeof(SizePicker), new PropertyMetadata(true));
 
-        // Using a DependencyProperty as the backing store for ChosenWidth.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty ChosenWidthProperty =
-            DependencyProperty.Register("ChosenWidth", typeof(int), typeof(SizePicker), new PropertyMetadata(1));
+            DependencyProperty.Register(nameof(ChosenWidth), typeof(int), typeof(SizePicker), new PropertyMetadata(1));
 
-        // Using a DependencyProperty as the backing store for ChosenHeight.  This enables animation, styling, binding, etc...
         public static readonly DependencyProperty ChosenHeightProperty =
-            DependencyProperty.Register("ChosenHeight", typeof(int), typeof(SizePicker), new PropertyMetadata(1));
+            DependencyProperty.Register(nameof(ChosenHeight), typeof(int), typeof(SizePicker), new PropertyMetadata(1));
+
+        public static readonly DependencyProperty NextControlProperty =
+            DependencyProperty.Register(nameof(NextControl), typeof(FrameworkElement), typeof(SizePicker));
 
         public SizePicker()
         {
@@ -42,5 +42,16 @@ namespace PixiEditor.Views
             get => (int)GetValue(ChosenHeightProperty);
             set => SetValue(ChosenHeightProperty, value);
         }
+
+        public FrameworkElement NextControl
+        {
+            get => (FrameworkElement)GetValue(NextControlProperty);
+            set => SetValue(NextControlProperty, value);
+        }
+
+        public void FocusWidthPicker()
+        {
+            WidthPicker.Focus();
+        }
     }
 }

PixiEditorTests/ModelsTests/ControllersTests/MockedSinglePixelPenTool.cs

@@ -12,9 +12,11 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
     {
         public override string Tooltip => "";
 
-        public override void Use(Layer layer, List<Coordinates> mouseMove, SKColor color)
+        public override void Use(Layer activeLayer, Layer previewLayer, IEnumerable<Layer> allLayers, IReadOnlyList<Coordinates> recordedMouseMovement,
+            SKColor color)
         {
-            layer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(mouseMove[0].ToSKPoint(), color);
+            activeLayer.LayerBitmap.SkiaSurface.Canvas.DrawPoint(recordedMouseMovement[0].ToSKPoint(), color);
+
         }
     }
 }

PixiEditorTests/ModelsTests/ControllersTests/MouseMovementControllerTests.cs

@@ -6,11 +6,11 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
 {
     public class MouseMovementControllerTests
     {
-        [Fact]
+        /*[Fact]
         public void TestThatStartRecordingMouseMovChangesStartsRecordingAndInvokesEvent()
         {
             bool eventInvoked = false;
-            MouseMovementController controller = new MouseMovementController();
+            ToolSessionController controller = new ToolSessionController();
             controller.StartedRecordingChanges += (sender, e) => eventInvoked = true;
 
             controller.StartRecordingMouseMovementChanges(false);
@@ -23,7 +23,7 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
         [Fact]
         public void TestThatRecordMouseMovementChangeRecordsMouseMovementChange()
         {
-            MouseMovementController controller = new MouseMovementController();
+            ToolSessionController controller = new ToolSessionController();
             controller.StartRecordingMouseMovementChanges(false);
             controller.RecordMouseMovementChange(new Coordinates(5, 5));
 
@@ -39,14 +39,14 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
             Coordinates position = new Coordinates(5, 5);
             MouseMovementEventArgs args = new MouseMovementEventArgs(default(Coordinates));
 
-            MouseMovementController controller = new MouseMovementController();
-            controller.MousePositionChanged += (s, e) =>
+            ToolSessionController controller = new ToolSessionController();
+            controller.PreciseMousePositionChanged += (s, e) =>
             {
                 eventRaised = true;
                 args = e;
             };
 
-            controller.MouseMoved(position);
+            controller.OnMouseMove(position);
 
             Assert.True(eventRaised);
             Assert.Equal(position, args.NewPosition);
@@ -55,7 +55,7 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
         [Fact]
         public void TestStopRecordingChangesStopsRecording()
         {
-            MouseMovementController controller = new MouseMovementController();
+            ToolSessionController controller = new ToolSessionController();
 
             controller.StartRecordingMouseMovementChanges(true);
             controller.StopRecordingMouseMovementChanges();
@@ -67,11 +67,11 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
         [Fact]
         public void TestThatRecordChangesNotRecords()
         {
-            MouseMovementController controller = new MouseMovementController();
+            ToolSessionController controller = new ToolSessionController();
             controller.RecordMouseMovementChange(new Coordinates(5, 10));
 
             Assert.False(controller.IsRecordingChanges);
             Assert.Empty(controller.LastMouseMoveCoordinates);
-        }
+        }*/
     }
 }

PixiEditorTests/ModelsTests/ControllersTests/ReadonlyUtilityTests.cs

@@ -1,13 +1,13 @@
 using PixiEditor.Models.Controllers;
 using PixiEditor.Models.Position;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using Xunit;
 
 namespace PixiEditorTests.ModelsTests.ControllersTests
 {
     public class ReadonlyUtilityTests
     {
-        [Fact]
+        /*[Fact]
         public void TestThatExecuteToolExecutesTool()
         {
             bool toolUsed = false;
@@ -15,6 +15,6 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
             ReadonlyToolUtility util = new ReadonlyToolUtility();
             util.ExecuteTool(new List<Coordinates> { new Coordinates(0, 0) }, new TestReadonlyTool(() => toolUsed = true));
             Assert.True(toolUsed);
-        }
+        }*/
     }
 }

PixiEditorTests/ModelsTests/ControllersTests/TestReadonlyTool.cs

@@ -8,7 +8,7 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
     public class TestReadonlyTool : ReadonlyTool
     {
         public override string Tooltip => "";
-    
+
         public TestReadonlyTool(Action toolAction)
         {
             ToolAction = toolAction;
@@ -16,7 +16,7 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
 
         public Action ToolAction { get; set; }
 
-        public override void Use(List<Coordinates> pixels)
+        public override void Use(IReadOnlyList<Coordinates> pixels)
         {
             ToolAction();
         }

PixiEditorTests/ModelsTests/UndoTests/StorageBasedChangeTests.cs

@@ -31,7 +31,7 @@ namespace PixiEditorTests.ModelsTests.UndoTests
             testBitmap.SetSRGBPixel(0, 0, SKColors.Black);
             testBitmap2.SetSRGBPixel(4, 4, SKColors.Blue);
             Random random = new Random();
-            testDocument.Layers = new ObservableCollection<Layer>()
+            testDocument.Layers = new WpfObservableRangeCollection<Layer>()
             {
                 new Layer("Test layer" + random.Next(int.MinValue, int.MaxValue), testBitmap),
                 new Layer("Test layer 2" + random.Next(int.MinValue, int.MaxValue), testBitmap2) { Offset = new System.Windows.Thickness(2, 3, 0, 0) }