dymokomi/luced-2d
Source of release 0.5.0
0.5.0 / src / layer_commands.luc
## Edits to the layer stack, each on the selected layer (or every selected
## one): new, delete, reorder, duplicate and merge; copy and paste; the
## appearance (visibility, opacity, blend, clipping); masks; and moves.
from luce_image.canvas import Canvas
from system_hooks import copy_picture, clipboard_picture
from live import Live
from layer_picking import LayerPicking
from luce_std import math
from luce_ui import ui
pub class LayerCommands:
let live: Live
let layers: LayerPicking
## The number the next new layer's name takes ("Layer 2"), and the next group's.
pub var next_name: int = 1
pub var next_group: int = 1
## The layer whose mask Copy Mask took, 0 for none.
pub var mask_source: int = 0
pub func init(self, live: Live, layers: LayerPicking):
self.live = live
self.layers = layers
## Make `change` one undo step named `name`, however many changes it makes.
pub func as_one(self, name: str, change: func() -> unit!) -> unit!:
self.live.canvas.begin_edit(name)
change() catch failure:
self.live.canvas.end_edit()
error(failure.code, failure.message)
self.live.canvas.end_edit()
## A new empty layer just above the selected one, in its group, selected.
pub func add_layer(self) -> unit!:
self.next_name += 1
self.as_one("New Layer", func () -> unit!:
self.place_above_selected(self.live.canvas.add_layer(f"Layer {self.next_name}")))
## Put the new layer `id` just above the selected layer, in the same group,
## and select it — or, above a group, just above the whole group.
pub func place_above_selected(self, id: int) -> unit!:
let canvas = self.live.canvas
let selected = self.layers.selected
let created = self.layers.index_of(id)
if selected != created and selected < canvas.layer_count():
let parent = canvas.layer_parent(selected)
let position = canvas.layer_position(selected)
canvas.move_into(id, parent, position + 1)
self.layers.select_id(id)
## Delete every selected layer (a group with all it holds), keeping one.
pub func delete_layer(self) -> unit!:
let canvas = self.live.canvas
let at = self.layers.selected
for id in self.layers.selected_ids():
let index = self.layers.index_of(id)
# One layer always stays; a group going takes its layers, so check each time.
if index >= 0 and canvas.layer_count() > 1:
canvas.remove_layer(id)
self.layers.picked = []
self.layers.selected = at if at < canvas.layer_count() else canvas.layer_count() - 1
self.live.touch()
## Take layer `id` away (a group with all it holds), keeping a selection.
pub func remove_layer_id(self, id: int) -> unit!:
let canvas = self.live.canvas
canvas.remove_layer(id)
self.layers.picked = []
if self.layers.selected >= canvas.layer_count():
self.layers.selected = canvas.layer_count() - 1
self.live.touch()
## Move the selected layer one place up among its group's layers (negative:
## down); a group goes with everything in it.
pub func reorder(self, step: int) -> unit!:
let id = self.layers.selected_id()
self.live.canvas.reorder_layer(id, step)
self.layers.selected = self.layers.index_of(id)
self.live.touch()
pub func duplicate(self) -> unit!:
let canvas = self.live.canvas
let name = canvas.layer_name(self.layers.selected) + " copy"
let copy = canvas.duplicate_layer(self.layers.selected_id(), name)
self.layers.select_id(copy)
pub func merge_down(self) -> unit!:
if self.layers.selected == 0:
return
let below = self.live.canvas.layer_id(self.layers.selected - 1)
self.live.canvas.merge_down(self.layers.selected_id())
self.layers.select_id(below)
## Rename the selected layer.
pub func rename(self, name: str) -> unit!:
self.live.canvas.rename_layer(self.layers.selected_id(), name)
self.live.touch()
# -- The clipboard.
## Copy the selected layer's selected pixels (all of them without a
## selection) to the system clipboard, or the whole picture's with
## `merged`; with `cut` they leave the layer.
pub func copy_selection(self, merged: bool, cut: bool) -> unit!:
copy_picture(self.live.canvas.copy_selection(self.layers.selected_id(), merged, cut))
self.live.touch()
## The clipboard's image on a new layer just above the selected one, centred
## on a document point, and selected.
pub func paste(self, x: float, y: float) -> unit!:
let canvas = self.live.canvas
let parent = canvas.layer_parent(self.layers.selected)
let position = canvas.layer_position(self.layers.selected)
self.as_one("Paste", func () -> unit!:
let id = canvas.paste(clipboard_picture(), int(x), int(y))
canvas.move_into(id, parent, position + 1)
self.layers.select_id(id))
## The clipboard's image where it was copied from, above the selected layer.
pub func paste_in_place(self) -> unit!:
let canvas = self.live.canvas
let parent = canvas.layer_parent(self.layers.selected)
let position = canvas.layer_position(self.layers.selected)
self.as_one("Paste in Place", func () -> unit!:
let id = canvas.paste_in_place(clipboard_picture())
canvas.move_into(id, parent, position + 1)
self.layers.select_id(id))
## Layer via Copy (via Cut with `cut`): a new layer of the selected pixels, selected.
pub func layer_via_copy(self, cut: bool) -> unit!:
let id = self.live.canvas.layer_via_copy(self.layers.selected_id(), cut)
self.layers.select_id(id)
# -- Appearance.
## The blend mode's name of the layer at stack index `index`.
pub func blend_name(self, index: int) -> str!:
return Canvas.blend_mode_name(self.live.canvas.layer_blend(index))
## Set the selected layer's visibility, opacity and blend mode together, as
## the canvas takes them.
func set_appearance(self, visible: bool, opacity: float, blend: int) -> unit!:
self.live.canvas.set_layer(self.layers.selected_id(), visible, math.max(0.0, math.min(1.0, opacity)), blend)
self.live.touch()
pub func toggle_visibility(self) -> unit!:
let canvas = self.live.canvas
let at = self.layers.selected
self.set_appearance(not canvas.layer_visible(at), canvas.layer_opacity(at), canvas.layer_blend(at))
pub func set_opacity(self, opacity: float) -> unit!:
let canvas = self.live.canvas
let at = self.layers.selected
self.set_appearance(canvas.layer_visible(at), opacity, canvas.layer_blend(at))
pub func set_blend(self, mode: int) -> unit!:
let canvas = self.live.canvas
let at = self.layers.selected
self.set_appearance(canvas.layer_visible(at), canvas.layer_opacity(at), mode)
## Step the selected layer's blend mode `step` places through Photoshop's list, wrapping.
pub func cycle_blend(self, step: int) -> unit!:
let count = Canvas.blend_mode_count()
self.set_blend((self.live.canvas.layer_blend(self.layers.selected) + step % count + count) % count)
pub func toggle_clipped(self) -> unit!:
let canvas = self.live.canvas
canvas.set_clipped(self.layers.selected_id(), not canvas.layer_clipped(self.layers.selected))
self.live.touch()
# -- Masks.
## Add a mask — revealing the selection when there is one, as Photoshop's
## button does, else everything; `hide` hides everything instead — or
## remove the mask the layer has. A new mask is what painting targets
## next, as in Photoshop.
pub func toggle_mask(self, hide: bool = false) -> unit!:
let canvas = self.live.canvas
if canvas.layer_masked(self.layers.selected):
canvas.set_mask(self.layers.selected_id(), false)
canvas.edit_mask(false)
else:
canvas.set_mask(self.layers.selected_id(), true, 1 if hide else (2 if canvas.has_selection() else 0))
canvas.edit_mask(true)
self.live.touch()
## Link the selected layer's mask to its pixels, or unlink it (it stays put
## when they move).
pub func toggle_mask_link(self) -> unit!:
let canvas = self.live.canvas
canvas.link_mask(self.layers.selected_id(), not canvas.layer_mask_linked(self.layers.selected))
self.live.touch()
## Remember the selected layer's mask for Paste Mask.
pub func copy_mask(self) -> unit!:
if not self.live.canvas.layer_masked(self.layers.selected):
error(ui.invalid, "the layer has no mask to copy")
self.mask_source = self.layers.selected_id()
## Give the selected layer a copy of the mask Copy Mask remembered.
pub func paste_mask(self) -> unit!:
if not self.mask_source_present():
error(ui.invalid, "copy a layer's mask first")
self.live.canvas.copy_mask(self.mask_source, self.layers.selected_id())
self.live.canvas.edit_mask(true)
self.live.touch()
## Whether the layer Copy Mask remembered is still here with its mask.
pub func mask_source_present(self) -> bool!:
let index = self.layers.index_of(self.mask_source)
return self.mask_source != 0 and index >= 0 and self.live.canvas.layer_masked(index)
## Keep the selected layer's mask but stop it hiding anything, or bring it back.
pub func toggle_mask_enabled(self) -> unit!:
let canvas = self.live.canvas
if canvas.layer_masked(self.layers.selected):
canvas.enable_mask(self.layers.selected_id(), not canvas.layer_mask_enabled(self.layers.selected))
self.live.touch()
## The selected layer's transparency becomes the selection.
pub func load_transparency(self) -> unit!:
self.live.canvas.select_from_layer(self.layers.selected_id(), false, 0)
self.live.touch()
## \: paint on the selected layer's mask, or back on its pixels.
pub func toggle_mask_editing(self) -> unit!:
let canvas = self.live.canvas
canvas.edit_mask(canvas.layer_masked(self.layers.selected) and not canvas.editing_mask())
self.live.touch()
# -- Moving.
## Move every selected layer by whole pixels, as one undo step; a group
## moves what it holds.
pub func move_layer(self, dx: int, dy: int) -> unit!:
var first = true
for id in self.layers.moving_ids():
if not first:
self.live.canvas.join_next_edit()
self.live.canvas.move_layer(id, dx, dy)
first = false
self.live.touch()