Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / canvas / history_tests.lucb

#==============================================================================================
#
#   canvas/history_tests - The history: step names, undo of everything, the saved state and the budget
#
#==============================================================================================

test "the history lists its steps by name, undo side oldest first and redo side next first":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(64, 64)
    defer canvas.close()
    let base = try canvas.add_layer("Base")
    var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer target.destroy()
    _ = try shown_at(&canvas, &target, 0, 0)
    let first = canvas.history_steps()
    try canvas.select_rectangle(4, 4, 8, 8, 0)
    try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    try canvas.fill(base, false)
    let extra = try canvas.add_layer("Extra")
    _ = extra
    let steps = canvas.history_steps()
    assert(steps == first + 3)
    assert(canvas.history_step_name(steps - 3) == "Select" and canvas.history_step_name(steps - 2) == "Fill")
    assert(canvas.history_step_name(steps - 1) == canvas.undo_name() and canvas.history_step_name(steps) == "")
    try canvas.undo()
    try canvas.undo()
    assert(canvas.history_steps() == steps - 2 and canvas.future_steps() == 2)
    assert(canvas.future_step_name(0) == "Fill" and canvas.future_step_name(1) == "New Layer" and canvas.future_step_name(2) == "")
    try canvas.redo()
    assert(canvas.undo_name() == "Fill" and canvas.future_steps() == 1)

test "everything undoes: layers, properties, styles, masks, selections and the canvas size, each a named step":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(64, 64)
    defer canvas.close()
    let base = try canvas.add_layer("Base")
    var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer target.destroy()
    _ = try shown_at(&canvas, &target, 0, 0)
    # A new layer, then undone and redone.
    let extra = try canvas.add_layer("Extra")
    assert(canvas.layer_count() == 2 and canvas.undo_name() == "New Layer")
    try canvas.undo()
    assert(canvas.layer_count() == 1)
    try canvas.redo()
    assert(canvas.layer_count() == 2 and (try canvas.layer_id(1)) == extra)
    # An opacity dragged is one step, back to where it began.
    try canvas.set_layer(extra, true, 0.8)
    try canvas.set_layer(extra, true, 0.5)
    try canvas.set_layer(extra, true, 0.2)
    try canvas.undo()
    assert(math.abs((try canvas.layer_opacity(1)) - 1.0) < 0.001 and canvas.undo_name() == "New Layer")
    # Rename, a style, a mask and a selection each come back.
    try canvas.rename_layer(extra, "Renamed")
    try canvas.set_style_value(extra, 21, 1.0)
    try canvas.set_mask(extra, true)
    try canvas.select_rectangle(4, 4, 8, 8, 0)
    assert(canvas.has_selection() and canvas.undo_name() == "Select")
    try canvas.undo()
    assert(not canvas.has_selection())
    try canvas.undo()
    assert(not (try canvas.layer_masked(1)))
    try canvas.undo()
    assert((try canvas.style_value(1, 21)) == 0.0)
    try canvas.undo()
    assert((try canvas.layer_name(1)) == "Extra")
    # The canvas size, and a pixel edit made after it, go back in order.
    try canvas.resize_canvas(96, 80, 0, 0)
    try canvas.set_brush(10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    try canvas.select_all()
    try canvas.fill(base, false)
    assert(canvas.undo_name() == "Fill")
    try canvas.undo()
    try canvas.undo()
    assert(canvas.width() == 96)
    try canvas.undo()
    assert(canvas.width() == 64 and canvas.height() == 64 and canvas.layer_count() == 2)
    try canvas.redo()
    assert(canvas.width() == 96 and canvas.height() == 80)
    # Deleting a group takes its layers; one undo brings all back.
    try canvas.undo()
    let folder = try canvas.add_group("Folder")
    try canvas.begin_edit("Group Layers")
    try canvas.move_into(base, folder, -1)
    try canvas.move_into(extra, folder, -1)
    canvas.end_edit()
    assert(canvas.undo_name() == "Group Layers")
    try canvas.remove_layer(folder)
    assert(canvas.layer_count() == 0)
    try canvas.undo()
    assert(canvas.layer_count() == 3 and (try canvas.layer_parent(0)) == folder)
    try canvas.undo()
    assert((try canvas.layer_parent(0)) == 0 and canvas.undo_name() == "New Group")

test "the document knows whether it is as saved; exports leave that alone":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(32, 32)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    var target = try gpu.Texture.create(device, 32, 32, gpu.Format.rgba8_linear)
    defer target.destroy()
    _ = try shown_at(&canvas, &target, 0, 0)
    assert(not canvas.modified())
    try canvas.set_layer(layer, true, 0.5)
    assert(canvas.modified())
    try canvas.save_package("build/canvas-saved.l2d")
    assert(not canvas.modified())
    # A change after saving is its own step, even the same kind on the same layer.
    try canvas.set_layer(layer, true, 0.25)
    assert(canvas.modified())
    try canvas.undo()
    assert(not canvas.modified() and math.abs((try canvas.layer_opacity(0)) - 0.5) < 0.001)
    # An export under a white matte writes an opaque JPEG and changes nothing.
    try canvas.set_layer(layer, true, 0.75)
    try canvas.save("build/canvas-export.jpg", 80, 1.0, 1.0, 1.0)
    assert(canvas.modified())

test "the history keeps within its budget by dropping its oldest steps, keeping the last":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(1024, 1024)
    defer canvas.close()
    let layer = try canvas.add_layer("Paint")
    var target = try gpu.Texture.create(device, 64, 64, gpu.Format.rgba8_linear)
    defer target.destroy()
    _ = try shown_at(&canvas, &target, 0, 0)
    # Each gradient gives all sixteen cells tiles of their own; its step holds the last ones.
    try canvas.set_history_limit(40 * 524288)
    for step in 0..<(i64)6:
        let shade = (f64)step / 6.0
        try canvas.fill_gradient(layer, 0.0, 0.0, 1024.0, 1024.0 - (f64)step * 50.0, shade, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0)
    let steps = canvas.undo_steps()
    assert(steps >= 1 and steps < 6)
    # What is kept undoes.
    try canvas.undo()
    assert(canvas.undo_steps() == steps - 1)
    # A budget of nothing still keeps the last step.
    try canvas.set_history_limit(0)
    try canvas.fill_gradient(layer, 0.0, 0.0, 10.0, 10.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0)
    assert(canvas.undo_steps() == 1 and canvas.can_undo())