public void TestThatConstructorGeneratesUndoLayersProperly()
{
using Document testDocument = GenerateTestDocument();
using StorageBasedChange change = new StorageBasedChange(testDocument, testDocument.Layers, UndoStoreLocation);
Assert.Equal(testDocument.Layers.Count, change.StoredLayers.Length);
for (int i = 0; i < change.StoredLayers.Length; i++)
{
Layer testLayer = testDocument.Layers[i];
UndoLayer layer = change.StoredLayers[i];
Assert.Equal(testLayer.Name, layer.Name);
Assert.Equal(testLayer.Width, layer.Width);
Assert.Equal(testLayer.Height, layer.Height);
Assert.Equal(testLayer.IsActive, layer.IsActive);
Assert.Equal(testLayer.IsVisible, layer.IsVisible);
Assert.Equal(testLayer.OffsetX, layer.OffsetX);
Assert.Equal(testLayer.OffsetY, layer.OffsetY);
Assert.Equal(testLayer.MaxWidth, layer.MaxWidth);
Assert.Equal(testLayer.MaxHeight, layer.MaxHeight);
Assert.Equal(testLayer.Opacity, layer.Opacity);
}
}
private void InitializeStorageBasedChange(SKRectI toolSessionRect)
{
Document doc = ViewModels.ViewModelMain.Current.BitmapManager.ActiveDocument;
var toolSize = Toolbar.GetSetting <SizeSetting>("ToolSize");
SKRectI finalRect = toolSessionRect;
if (toolSize != null && toolSize.Value > 1)
{
int halfSize = (int)Math.Ceiling(toolSize.Value / 2f);
finalRect.Inflate(halfSize, halfSize);
}
if (toolSessionRect.IsEmpty)
{
finalRect = SKRectI.Create(doc.ActiveLayer.OffsetX, doc.ActiveLayer.OffsetY, doc.ActiveLayer.Width, doc.ActiveLayer.Height);
}
if (UseDocumentRectForUndo)
{
finalRect = SKRectI.Create(0, 0, doc.Width, doc.Height);
}
if (_customRectReported)
{
_customRectReported = false;
finalRect = _rectReportedByTool;
_rectReportedByTool = SKRectI.Empty;
}
_change = new StorageBasedChange(doc, new[] { new LayerChunk(doc.ActiveLayer, finalRect) });
}
public void TestThatRedoInvokesSaveToDeviceAndExecutesProcess()
{
using Document document = GenerateTestDocument();
using StorageBasedChange change = new StorageBasedChange(document, document.Layers, UndoStoreLocation);
bool redoInvoked = false;
Action <Layer[], UndoLayer[]> testUndoProcess = (layers, data) => { };
Action <object[]> testRedoProcess = parameters =>
{
redoInvoked = true;
foreach (var undoLayer in change.StoredLayers)
{
Assert.True(File.Exists(undoLayer.StoredPngLayerName));
Assert.NotNull(parameters);
Assert.Single(parameters);
Assert.IsType <int>(parameters[0]);
Assert.Equal(2, parameters[0]);
}
};
Change undoChange = change.ToChange(testUndoProcess, testRedoProcess, new object[] { 2 });
using UndoManager manager = new UndoManager(this);
manager.AddUndoChange(undoChange);
manager.Undo();
manager.Redo();
Assert.True(redoInvoked);
}
public void TestThatUndoInvokesLoadFromDeviceAndExecutesProcess()
{
using Document document = GenerateTestDocument();
using StorageBasedChange change = new StorageBasedChange(document, document.Layers, UndoStoreLocation);
bool undoInvoked = false;
Action <Layer[], UndoLayer[]> testUndoProcess = (layers, data) =>
{
undoInvoked = true;
Assert.Equal(document.Layers.Count, layers.Length);
Assert.Equal(document.Layers.Count, data.Length);
foreach (var undoLayer in data)
{
Assert.False(File.Exists(undoLayer.StoredPngLayerName));
}
};
Action <object[]> testRedoProcess = parameters => { };
Change undoChange = change.ToChange(testUndoProcess, testRedoProcess, null);
using UndoManager manager = new UndoManager(this);
manager.AddUndoChange(undoChange);
manager.Undo();
Assert.True(undoInvoked);
}
/// <summary>
/// Pastes image from clipboard into new layer.
/// </summary>
public static void PasteFromClipboard(Document document)
{
Layer[] layers;
try
{
layers = GetLayersFromClipboard(document).ToArray();
}
catch
{
return;
}
int resizedCount = 0;
Guid[] guids = layers.Select(x => x.GuidValue).ToArray();
var undoArgs = new object[] { guids, document, new PixelSize(document.Width, document.Height) };
foreach (var layer in layers)
{
document.Layers.Add(layer);
if (layer.Width > document.Width || layer.Height > document.Height)
{
ResizeToLayer(document, layer);
resizedCount++;
}
}
StorageBasedChange change = new StorageBasedChange(document, layers, false);
document.UndoManager.AddUndoChange(change.ToChange(RemoveLayersProcess, undoArgs,
RestoreLayersProcess, new object[] { document }, "Paste from clipboard"));
}
public void TestThatSaveLayersOnDeviceSavesLayers()
{
using Document document = GenerateTestDocument();
using StorageBasedChange change = new StorageBasedChange(document, document.Layers, UndoStoreLocation);
foreach (var layer in change.StoredLayers)
{
Assert.True(File.Exists(layer.StoredPngLayerName));
File.Delete(layer.StoredPngLayerName);
}
}
public override void BeforeUse()
{
Document doc = BitmapManager.ActiveDocument;
Selection selection = doc.ActiveSelection;
bool anySelection = selection.SelectedPoints.Any();
if (Session.IsCtrlDown)
{
affectedLayers = doc.Layers.Where(x => x.IsVisible).ToArray();
}
else
{
affectedLayers = doc.Layers.Where(x => x.IsActive && doc.GetFinalLayerIsVisible(x)).ToArray();
}
change = new StorageBasedChange(doc, affectedLayers, true, true);
Layer selLayer = selection.SelectionLayer;
moveStartRect = anySelection ?
new(selLayer.OffsetX, selLayer.OffsetY, selLayer.Width, selLayer.Height) :
new(0, 0, doc.Width, doc.Height);
lastDragDelta = new Coordinates(0, 0);
previewLayerData?.Dispose();
previewLayerData = CreateCombinedPreview(anySelection ? selLayer : null, affectedLayers);
if (currentlyDragged != null)
{
foreach (var surface in currentlyDragged)
{
surface.Dispose();
}
}
if (anySelection)
{
currentlyDragged = BitmapUtils.ExtractSelectedPortions(selLayer, affectedLayers, true);
currentlyDraggedPositions = Enumerable.Repeat(new Coordinates(selLayer.OffsetX, selLayer.OffsetY), affectedLayers.Length).ToArray();
}
else
{
(currentlyDraggedPositions, currentlyDragged) = CutDraggedLayers(affectedLayers);
}
if (anySelection)
{
moveStartSelectedPoints = selection.SelectedPoints.ToList();
}
}
/// <summary>
/// Resizes all document layers using NearestNeighbor interpolation.
/// </summary>
/// <param name="newWidth">New document width.</param>
/// <param name="newHeight">New document height.</param>
public void Resize(int newWidth, int newHeight)
{
object[] reverseArgs = { Width, Height };
object[] args = { newWidth, newHeight };
StorageBasedChange change = new StorageBasedChange(this, Layers);
ResizeDocument(newWidth, newHeight);
UndoManager.AddUndoChange(
change.ToChange(
RestoreDocumentLayersProcess,
reverseArgs,
ResizeDocumentProcess,
args,
"Resize document"));
}
public void TestThatLoadLayersFromDeviceLoadsLayers()
{
using Document document = GenerateTestDocument();
using StorageBasedChange change = new StorageBasedChange(document, document.Layers, UndoStoreLocation);
Layer[] layers = change.LoadLayersFromDevice();
Assert.Equal(document.Layers.Count, layers.Length);
for (int i = 0; i < document.Layers.Count; i++)
{
Layer expected = document.Layers[i];
Layer actual = layers[i];
LayersTestHelper.LayersAreEqual(expected, actual);
}
}
/// <summary>
/// Executes undo adding procedure.
/// </summary>
/// <remarks>When overriding, set UseDefaultUndoMethod to false.</remarks>
public override void AfterUse(SKRectI sessionRect)
{
if (!UseDefaultUndoMethod)
{
return;
}
if (RequiresPreviewLayer)
{
InitializeStorageBasedChange(sessionRect);
}
var document = ViewModels.ViewModelMain.Current.BitmapManager.ActiveDocument;
var args = new object[] { _change.Document };
document.UndoManager.AddUndoChange(_change.ToChange(StorageBasedChange.BasicUndoProcess, args));
_change = null;
}
public void DeletePixels(Layer[] layers, Coordinates[] pixels)
{
if (Manager.ActiveDocument == null)
{
return;
}
StorageBasedChange change = new StorageBasedChange(Manager.ActiveDocument, layers, true);
BitmapPixelChanges changes = BitmapPixelChanges.FromSingleColoredArray(pixels, SKColors.Empty);
for (int i = 0; i < layers.Length; i++)
{
Guid guid = layers[i].GuidValue;
layers[i].SetPixels(changes);
}
var args = new object[] { change.Document };
Manager.ActiveDocument.UndoManager.AddUndoChange(change.ToChange(StorageBasedChange.BasicUndoProcess, args, "Delete selected pixels"));
}