Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-2d

Source of release 0.5.1

0.5.1 / src / properties.luc

## The Properties pane: what the selected layer is, one compact row each after
## Houdini's parameter pane — its name (edited in place), blend mode, opacity,
## flags and styles, one ParameterPanel. The flags, the blend modes and the
## style editor are the window's commands; opacity and the name write to the
## workspace directly. An adjustment layer shows its settings below, as
## Photoshop's Properties panel does — Levels with its histogram — and every
## change adjusts the picture live.
from luce_ui.ui import Text, VStack, Size, Spacer, Command, Panel, ScrollView, ParameterPanel, ParameterSpec, ParameterKind
from workspace import Workspace
from kit import Kit
from adjustment_controls import AdjustmentControls
from adjustments import curves_adjustment, gradient_map

## The rows of the layer's panel, by index.
let name_row: int = 0
let blend_row: int = 1
let opacity_row: int = 2
let visible_row: int = 3
let clipped_row: int = 4
let mask_row: int = 5
let styles_row: int = 6
let edit_row: int = 7

pub class Properties:
    pub let panel: Panel
    ## The layer's rows: name, blend, opacity, the three flags, styles.
    pub let layer: ParameterPanel
    ## The selected adjustment layer's settings, and which layer they show (by id, or -1).
    pub let adjustment: AdjustmentControls
    let adjustment_title: Text
    let adjustment_section: VStack
    var adjustment_layer: int = -1
    ## The layer's pixels changed in a way the layer list shows (its opacity).
    pub var changed: func() -> unit!? = none
    pub var refreshed: func() -> unit!? = none
    let workspace: Workspace
    let blends: list[Command]
    let toggles: list[func() -> unit!]
    let layer_style: func() -> unit!

    ## `blends` are the blend-mode commands; the other callbacks toggle a flag
    ## of the selected layer or open its Layer Style.
    pub func init(self, workspace: Workspace, kit: Kit, blends: list[Command], toggle_visibility: func() -> unit!,
                  toggle_clipped: func() -> unit!, toggle_mask: func() -> unit!, layer_style: func() -> unit!) -> unit!:
        self.workspace = workspace
        self.blends = blends
        self.toggles = [toggle_visibility, toggle_clipped, toggle_mask]
        self.layer_style = layer_style
        let font = kit.font
        var modes: list[str] = []
        for command in blends:
            modes.append(command.text())
        self.layer = ParameterPanel([ParameterSpec(name = "name", label = "Layer", kind = ParameterKind.text, resettable = false, doc = "The layer's name; Enter renames it."),
                                     ParameterSpec(name = "blend", label = "Blend", kind = ParameterKind.menu, items = modes.join("|"), doc = "How the layer mixes with what is below it."),
                                     ParameterSpec(name = "opacity", label = "Opacity", value = 100.0, minimum = 0.0, maximum = 100.0, step = 1.0, decimals = 0, suffix = "%", slider = true,
                                                   doc = "How much of the layer shows."),
                                     ParameterSpec(name = "visible", label = "Visible", kind = ParameterKind.toggle, value = 1.0, join = true, doc = "Show the layer."),
                                     ParameterSpec(name = "clip", label = "Clip", kind = ParameterKind.toggle, join = true, doc = "Clip the layer to the one below it."),
                                     ParameterSpec(name = "mask", label = "Mask", kind = ParameterKind.toggle, doc = "Use the layer's mask."),
                                     ParameterSpec(name = "styles", label = "Styles", kind = ParameterKind.info, text = "None", join = true),
                                     ParameterSpec(name = "edit_styles", label = "Edit…", kind = ParameterKind.button, doc = "Open the Layer Style dialog.")], font = font)
        kit.keep(self.layer.on_change(self.layer_changed))
        kit.keep(self.layer.on_action(func (index: int) -> unit!:
            let open = self.layer_style
            open()))
        self.adjustment = AdjustmentControls(workspace, kit)
        self.adjustment.changed = self.adjustment_changed
        self.adjustment_title = Text("", font = font)
        self.adjustment_section = VStack([self.adjustment_title, self.adjustment.view], spacing = 6.0, padding = 8.0)
        self.adjustment_section.layout().set_visible(false)
        let rows = VStack([self.layer, self.adjustment_section, Spacer()], spacing = 0.0, padding = 0.0)
        # An adjustment layer's settings can be taller than the pane: it scrolls.
        self.panel = Panel("Properties", ScrollView(rows), minimum = Size(220.0, 100.0), id = "properties")

    ## A row of the layer's panel changed: the name renames the layer, a blend
    ## mode or flag runs its command, the opacity writes to the layer.
    func layer_changed(self, index: int) -> unit!:
        if index == name_row:
            let value = self.layer.text(name_row).trim()
            if value != "":
                self.workspace.edits.rename(value)
            self.refresh()
        elif index == blend_row:
            let mode = int(self.layer.value(blend_row))
            if mode >= 0 and mode < self.blends.length:
                self.blends[mode].trigger()
        elif index == opacity_row:
            self.workspace.edits.set_opacity(self.layer.value(opacity_row) / 100.0)
            self.notify()
        elif index >= visible_row and index <= mask_row:
            let toggle = self.toggles[index - visible_row]
            toggle()

    ## Show the selected layer.
    pub func show(self) -> unit!:
        let workspace = self.workspace
        let canvas = workspace.canvas
        let selected = workspace.layers.selected
        self.layer.set_text(name_row, canvas.layer_name(selected))
        self.layer.set_value(blend_row, float(canvas.layer_blend(selected)))
        self.layer.set_value(visible_row, 1.0 if canvas.layer_visible(selected) else 0.0)
        self.layer.set_value(clipped_row, 1.0 if canvas.layer_clipped(selected) else 0.0)
        self.layer.set_value(mask_row, 1.0 if canvas.layer_masked(selected) else 0.0)
        var styled: list[str] = []
        if canvas.layer_styled(selected):
            if workspace.previews.style_value(0) != 0.0:
                styled.append("Shadow")
            if workspace.previews.style_value(8) != 0.0:
                styled.append("Stroke")
            if workspace.previews.style_value(14) != 0.0:
                styled.append("Glow")
            if workspace.previews.style_value(21) != 0.0:
                styled.append("Overlay")
            if workspace.previews.style_value(26) != 0.0:
                styled.append("Inner")
        self.layer.set_text(styles_row, styled.join(" ") if styled.length > 0 else "None")
        self.layer.set_value(opacity_row, canvas.layer_opacity(selected) * 100.0)
        self.show_adjustment(selected)

    ## The selected adjustment layer's settings, loaded when the selection
    ## moves to it; hidden for a layer with pixels or a group.
    func show_adjustment(self, selected: int) -> unit!:
        let canvas = self.workspace.canvas
        let kind = canvas.layer_adjustment(selected)
        self.adjustment_section.layout().set_visible(kind >= 0)
        self.layer.set_hidden(styles_row, kind >= 0)
        self.layer.set_hidden(edit_row, kind >= 0)
        if kind < 0:
            self.adjustment_layer = -1
            return
        let id = canvas.layer_id(selected)
        if id == self.adjustment_layer and kind == self.adjustment.kind:
            return
        self.adjustment_layer = id
        let spec = self.adjustment.spec(kind)
        var numbers: list[float] = []
        var parameter = 0
        while parameter < spec.value_count():
            numbers.append(canvas.adjustment_value(selected, parameter))
            parameter += 1
        self.adjustment.below = id
        # A Curves layer brings its own curves to edit.
        let own_curves = kind == curves_adjustment
        if own_curves:
            canvas.stage_layer_curves(id)
        # A Gradient Map layer's colors come after its values.
        var map_colors: list[float] = []
        if kind == gradient_map:
            var component = 0
            while component < 6:
                map_colors.append(canvas.adjustment_value(selected, spec.value_count() + component))
                component += 1
        self.adjustment.show(kind, spec.shown_of(numbers), own_curves, map_colors)
        self.adjustment_title.set_text(spec.name)

    ## A setting changed: the layer takes it at once.
    func adjustment_changed(self) -> unit!:
        if self.adjustment_layer < 0:
            return
        self.workspace.previews.update_adjustment_layer(self.adjustment_layer, self.adjustment.numbers(self.adjustment.kind))
        self.notify()

    func notify(self) -> unit!:
        if let changed = self.changed:
            changed()

    func refresh(self) -> unit!:
        if let refreshed = self.refreshed:
            refreshed()