Create tight transform for move tool on select

src/PixiEditor.AvaloniaUI/Models/DocumentModels/Public/DocumentOperationsModule.cs

@@ -35,12 +35,17 @@ internal class DocumentOperationsModule : IDocumentOperations
     /// <summary>
     /// Creates a new selection with the size of the document
     /// </summary>
-    public void SelectAll()
+    public void SelectAll() => Select(new RectI(VecI.Zero, Document.SizeBindable), SelectionMode.Add);
+
+    /// <summary>
+    /// Creates a new selection with the size of the document
+    /// </summary>
+    public void Select(RectI rect, SelectionMode mode = SelectionMode.New)
     {
         if (Internals.ChangeController.IsChangeActive)
             return;
         Internals.ActionAccumulator.AddFinishedActions(
-            new SelectRectangle_Action(new RectI(VecI.Zero, Document.SizeBindable), SelectionMode.Add),
+            new SelectRectangle_Action(rect, mode),
             new EndSelectRectangle_Action());
     }
 

src/PixiEditor.AvaloniaUI/Models/Handlers/IStructureMemberHandler.cs

@@ -1,6 +1,7 @@
 using Avalonia.Media.Imaging;
 using ChunkyImageLib;
 using PixiEditor.AvaloniaUI.Models.Layers;
+using PixiEditor.DrawingApi.Core.Numerics;
 using PixiEditor.DrawingApi.Core.Surface;
 using BlendMode = PixiEditor.ChangeableDocument.Enums.BlendMode;
 
@@ -18,6 +19,7 @@ internal interface IStructureMemberHandler : IHandler
     public float OpacityBindable { get; set; }
     public IDocument Document { get; }
     public bool IsVisibleBindable { get; set; }
+    public RectI? TightBounds { get; }
     public void SetMaskIsVisible(bool infoIsVisible);
     public void SetClipToMemberBelowEnabled(bool infoClipToMemberBelow);
     public void SetBlendMode(BlendMode infoBlendMode);

src/PixiEditor.AvaloniaUI/ViewModels/Dock/LayoutManager.cs

@@ -51,7 +51,7 @@ internal class LayoutManager
                     Id = "DocumentArea",
                     FallbackContent = new CreateDocumentFallbackView()
                 },
-                FirstSize = 0.75,
+                FirstSize = 0.8,
                 SplitDirection = DockingDirection.Right,
                 Second = new DockableTree
                 {
@@ -68,7 +68,7 @@ internal class LayoutManager
                                 DockContext.CreateDockable(paletteViewerDockViewModel)
                             ]
                         },
-                        FirstSize = 0.5,
+                        FirstSize = 0.6,
                         SplitDirection = DockingDirection.Bottom,
                         Second = new DockableArea
                         {

src/PixiEditor.AvaloniaUI/ViewModels/Document/DocumentViewModel.cs

@@ -582,6 +582,11 @@ internal partial class DocumentViewModel : PixiObservableObject, IDocument
         return layerGuids;
     }
 
+    /// <summary>
+    ///     Gets all selected layers extracted from selected folders.
+    /// </summary>
+    /// <param name="includeFoldersWithMask">Should folders with mask be included</param>
+    /// <returns>A list of GUIDs of selected layers</returns>
     public List<Guid> ExtractSelectedLayers(bool includeFoldersWithMask = false)
     {
         var result = new List<Guid>();

src/PixiEditor.AvaloniaUI/ViewModels/Document/StructureMemberViewModel.cs

@@ -51,6 +51,8 @@ internal abstract class StructureMemberViewModel : ObservableObject, IStructureM
     }
 
     private bool maskIsVisible;
+    public RectI? TightBounds => Internals.Tracker.Document.FindMember(GuidValue)?.GetTightBounds();
+
     public void SetMaskIsVisible(bool maskIsVisible)
     {
         this.maskIsVisible = maskIsVisible;

src/PixiEditor.AvaloniaUI/ViewModels/Tools/Tools/MoveToolViewModel.cs

@@ -1,9 +1,13 @@
 using Avalonia.Input;
+using ChunkyImageLib.DataHolders;
 using PixiEditor.AvaloniaUI.Models.Commands.Attributes.Commands;
+using PixiEditor.AvaloniaUI.Models.DocumentModels;
+using PixiEditor.AvaloniaUI.Models.Handlers;
 using PixiEditor.AvaloniaUI.Models.Handlers.Tools;
 using PixiEditor.AvaloniaUI.ViewModels.Tools.ToolSettings.Toolbars;
 using PixiEditor.AvaloniaUI.Views.Overlays.BrushShapeOverlay;
 using PixiEditor.DrawingApi.Core.Numerics;
+using PixiEditor.DrawingApi.Core.Surface.Vector;
 using PixiEditor.Extensions.Common.Localization;
 
 namespace PixiEditor.AvaloniaUI.ViewModels.Tools.Tools;
@@ -18,6 +22,8 @@ internal class MoveToolViewModel : ToolViewModel, IMoveToolHandler
     private bool transformingSelectedArea = false;
     public bool MoveAllLayers { get; set; }
 
+    private bool removeSelection = false;
+
     public MoveToolViewModel()
     {
         ActionDisplay = defaultActionDisplay;
@@ -54,7 +60,7 @@ internal class MoveToolViewModel : ToolViewModel, IMoveToolHandler
         {
             return;
         }
-        
+
         if (ctrlIsDown)
         {
             ActionDisplay = new LocalizedString("MOVE_TOOL_ACTION_DISPLAY_CTRL");
@@ -69,6 +75,57 @@ internal class MoveToolViewModel : ToolViewModel, IMoveToolHandler
 
     public override void OnSelected()
     {
+        RectI? bounds = GetSelectedLayersBounds();
+        bool? isEmpty = ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument?.SelectionPathBindable
+            ?.IsEmpty;
+        if ((!isEmpty.HasValue || isEmpty.Value) && bounds.HasValue)
+        {
+            ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument.Operations.Select(bounds.Value);
+            VectorPath path = new VectorPath();
+            path.AddRect(bounds.Value);
+            ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument.UpdateSelectionPath(path);
+            removeSelection = true;
+        }
+
         ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument?.Operations.TransformSelectedArea(true);
     }
+
+    public override void OnDeselecting()
+    {
+        ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument?.Operations.TryStopToolLinkedExecutor();
+
+        if (removeSelection)
+        {
+            ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument?.Operations.ClearSelection();
+            removeSelection = false;
+        }
+    }
+
+    private static RectI? GetSelectedLayersBounds()
+    {
+        var layers = ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument?.ExtractSelectedLayers();
+        RectI? bounds = null;
+        if (layers != null)
+        {
+            foreach (var layer in layers)
+            {
+                var foundLayer =
+                    ViewModelMain.Current.DocumentManagerSubViewModel.ActiveDocument.StructureHelper.Find(layer);
+                RectI? layerBounds = foundLayer?.TightBounds;
+                if (layerBounds != null)
+                {
+                    if (bounds == null)
+                    {
+                        bounds = layerBounds;
+                    }
+                    else
+                    {
+                        bounds = bounds.Value.Union(layerBounds.Value);
+                    }
+                }
+            }
+        }
+
+        return bounds;
+    }
 }

src/PixiEditor.ChangeableDocument/Changeables/Folder.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using PixiEditor.ChangeableDocument.Changeables.Interfaces;
+using PixiEditor.DrawingApi.Core.Numerics;
 
 namespace PixiEditor.ChangeableDocument.Changeables;
 
@@ -12,6 +13,35 @@ internal class Folder : StructureMember, IReadOnlyFolder
     public ImmutableList<StructureMember> Children { get; set; } = ImmutableList<StructureMember>.Empty;
     IReadOnlyList<IReadOnlyStructureMember> IReadOnlyFolder.Children => Children;
 
+    public override RectI? GetTightBounds()
+    {
+        if (Children.Count == 0)
+        {
+            return null;
+        }
+
+        var bounds = Children[0].GetTightBounds();
+        for (var i = 1; i < Children.Count; i++)
+        {
+            var childBounds = Children[i].GetTightBounds();
+            if (childBounds == null)
+            {
+                continue;
+            }
+
+            if (bounds == null)
+            {
+                bounds = childBounds;
+            }
+            else
+            {
+                bounds = bounds.Value.Union(childBounds.Value);
+            }
+        }
+
+        return bounds;
+    }
+
     /// <summary>
     /// Creates a clone of the folder, its mask and all of its children
     /// </summary>

src/PixiEditor.ChangeableDocument/Changeables/Interfaces/IReadOnlyLayer.cs

@@ -5,5 +5,4 @@ namespace PixiEditor.ChangeableDocument.Changeables.Interfaces;
 public interface IReadOnlyLayer : IReadOnlyStructureMember
 {
     public ChunkyImage Rasterize();
-    public RectI? GetTightBounds();
 }

src/PixiEditor.ChangeableDocument/Changeables/Interfaces/IReadOnlyStructureMember.cs

@@ -1,4 +1,5 @@
 using PixiEditor.ChangeableDocument.Enums;
+using PixiEditor.DrawingApi.Core.Numerics;
 
 namespace PixiEditor.ChangeableDocument.Changeables.Interfaces;
 
@@ -8,29 +9,41 @@ public interface IReadOnlyStructureMember
     /// Is the member visible. Defaults to true
     /// </summary>
     bool IsVisible { get; }
+
     /// <summary>
     /// The opacity of the member (Ranging from 0f to 1f)
     /// </summary>
     float Opacity { get; }
     bool ClipToMemberBelow { get; }
+
     /// <summary>
     /// The name of the member. Defaults to "Unnamed"
     /// </summary>
     string Name { get; }
+
     /// <summary>
     /// The guid of the member
     /// </summary>
     Guid GuidValue { get; }
+
     /// <summary>
     /// The blend mode of the member
     /// </summary>
     BlendMode BlendMode { get; }
+
     /// <summary>
     /// Is the mask of the member visible. Defaults to true
     /// </summary>
     bool MaskIsVisible { get; }
+
     /// <summary>
     /// The mask of the member
     /// </summary>
     IReadOnlyChunkyImage? Mask { get; }
+
+    /// <summary>
+    ///     The tight bounds of the member. The bounds are the smallest rectangle that contains all the pixels of the member.
+    /// </summary>
+    /// <returns>The tight bounds of the member</returns>
+    public RectI? GetTightBounds();
 }

src/PixiEditor.ChangeableDocument/Changeables/Layer.cs

@@ -6,5 +6,4 @@ namespace PixiEditor.ChangeableDocument.Changeables;
 internal abstract class Layer : StructureMember, IReadOnlyLayer
 {
     public abstract ChunkyImage Rasterize();
-    public abstract RectI? GetTightBounds();
 }

src/PixiEditor.ChangeableDocument/Changeables/RasterLayer.cs

@@ -36,7 +36,7 @@ internal class RasterLayer : Layer, IReadOnlyRasterLayer
 
     public override RectI? GetTightBounds()
     {
-        return LayerImage.FindChunkAlignedMostUpToDateBounds();
+        return LayerImage.FindTightCommittedBounds();
     }
 
     /// <summary>

src/PixiEditor.ChangeableDocument/Changeables/StructureMember.cs

@@ -1,5 +1,6 @@
 using PixiEditor.ChangeableDocument.Changeables.Interfaces;
 using PixiEditor.ChangeableDocument.Enums;
+using PixiEditor.DrawingApi.Core.Numerics;
 
 namespace PixiEditor.ChangeableDocument.Changeables;
 
@@ -14,6 +15,8 @@ internal abstract class StructureMember : IChangeable, IReadOnlyStructureMember,
     public BlendMode BlendMode { get; set; } = BlendMode.Normal;
     public Guid GuidValue { get; set; }
     public ChunkyImage? Mask { get; set; } = null;
+    public abstract RectI? GetTightBounds();
+
     public bool MaskIsVisible { get; set; } = true;
     IReadOnlyChunkyImage? IReadOnlyStructureMember.Mask => Mask;
     internal abstract StructureMember Clone();