Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-2d

Source of release 0.5.1

0.5.1 / src / style_dialog.luc

## Layer › Layer Style…: the selected layer's effects, after Compositor's
## Effects panel — Drop Shadow, Stroke (outside, centered or inside), Outer
## Glow, Color Overlay, Inner Shadow — each a checkbox heading with its color
## swatch (the color picker opens on it) over its sliders. Styles never touch
## the pixels: every change writes the layer's style (luce-image's numbered
## style fields) and the compositor draws it live; Cancel puts back what the
## layer had when the dialog opened.
from luce_ui.ui import Text, HStack, Spacer, Widget, Dialog, Checkbox, Menu, Command
from luce_gpu.gpu import Color
from workspace import Workspace
from kit import Kit, SliderField
from luce_std import math
from hex_color import hex_of_linear, linear_of_hex
from swatch import Swatch
from preview_session import PreviewDialogSession

## One slider: the style field it sets, and the factor from what it shows to
## what the field holds (percent to 0..1).
class StyleSlider:
    pub let field: int
    pub let scale: float
    pub let pair: SliderField

    pub func init(self, field: int, scale: float, pair: SliderField):
        self.field = field
        self.scale = scale
        self.pair = pair

## An effect: its on-off field, its color's first field, and its checkbox and swatch.
class Effect:
    pub let on_field: int
    pub let color_field: int
    pub let name: str
    pub let box: Checkbox
    pub let swatch: Swatch

    pub func init(self, on_field: int, color_field: int, name: str, box: Checkbox, swatch: Swatch):
        self.on_field = on_field
        self.color_field = color_field
        self.name = name
        self.box = box
        self.swatch = swatch

## How many numbered style settings a layer has (luce-image's style fields).
let style_fields: int = 40

pub class StyleDialog:
    pub let dialog: Dialog
    ## The dialog's lifecycle (preview_session.luc): the style shows live as
    ## it is set, so there is no preview to show, only one to end.
    pub let session: PreviewDialogSession
    let sliders: list[StyleSlider]
    ## The drop shadow's direction (the light's angle, Photoshop's) and distance,
    ## which set its x and y offsets together.
    let shadow_angle: SliderField
    let shadow_distance: SliderField
    let effects: list[Effect]
    let position_menu: Menu
    ## The layer's style fields when the dialog opened, for Cancel.
    var before: list[float]
    pub var changed: func() -> unit!? = none
    ## Open the color picker on a color: its title, the hex to start from, and
    ## what to do with each change.
    pub var pick_color: func(str, str, func(str) -> unit!) -> unit!? = none
    let workspace: Workspace
    let kit: Kit

    pub func init(self, workspace: Workspace, kit: Kit) -> unit!:
        self.workspace = workspace
        self.kit = kit
        self.sliders = []
        self.effects = []
        self.before = []
        let outside = Command("Outside", id = "stroke_outside")
        let centered = Command("Center", id = "stroke_center")
        let inside = Command("Inside", id = "stroke_inside")
        kit.bind(outside, func () -> unit!:
            self.set_field(20, 0.0))
        kit.bind(centered, func () -> unit!:
            self.set_field(20, 1.0))
        kit.bind(inside, func () -> unit!:
            self.set_field(20, 2.0))
        self.position_menu = Menu("Outside ▾", [outside, centered, inside], font = kit.font)
        var items: list[Widget] = [Text("Layer Style", font = kit.font)]
        self.shadow_angle = kit.slider_field(-180.0, 180.0, 120.0, 0, "°", func (moved: float) -> unit!:
            self.set_shadow_offset())
        self.shadow_distance = kit.slider_field(0.0, 100.0, 5.0, 0, " px", func (moved: float) -> unit!:
            self.set_shadow_offset())
        self.section(items, 0, 4, "Drop Shadow", [kit.dialog_row("Angle", self.shadow_angle.row, 80.0), kit.dialog_row("Distance", self.shadow_distance.row, 80.0),
                                                  self.slider(3, "Blur", 0.0, 100.0, 1.0, " px"), self.slider(7, "Opacity", 0.0, 100.0, 0.01, "%")])
        self.section(items, 8, 10, "Stroke", [self.slider(9, "Size", 0.0, 100.0, 1.0, " px"), self.slider(13, "Opacity", 0.0, 100.0, 0.01, "%"),
                                              kit.dialog_row("Position", self.position_menu, 80.0)])
        self.section(items, 14, 16, "Outer Glow", [self.slider(15, "Size", 0.0, 100.0, 1.0, " px"), self.slider(19, "Opacity", 0.0, 100.0, 0.01, "%")])
        self.section(items, 21, 22, "Color Overlay", [self.slider(25, "Opacity", 0.0, 100.0, 0.01, "%")])
        self.section(items, 26, 30, "Inner Shadow", [self.slider(27, "X", -100.0, 100.0, 1.0, " px"), self.slider(28, "Y", -100.0, 100.0, 1.0, " px"),
                                                     self.slider(29, "Blur", 0.0, 100.0, 1.0, " px"), self.slider(33, "Opacity", 0.0, 100.0, 0.01, "%")])
        self.section(items, 34, 36, "Inner Glow", [self.slider(35, "Size", 0.0, 100.0, 1.0, " px"), self.slider(39, "Opacity", 0.0, 100.0, 0.01, "%")])
        items.append(HStack([Spacer(), kit.button("Cancel", self.cancel), kit.button("Apply", self.apply)], spacing = 8.0))
        self.dialog = Dialog(items, width = 440.0)
        self.session = PreviewDialogSession(self.dialog, kit, "Layer Style")
        self.session.begin = self.begin
        self.session.finish = self.finish
        kit.dialog_keys(self.dialog, self.cancel, self.apply)

    ## A slider for style field `field`; every change writes it.
    func slider(self, field: int, label: str, minimum: float, maximum: float, scale: float, suffix: str) -> Widget!:
        let pair = self.kit.slider_field(minimum, maximum, minimum, 0, suffix, func (moved: float) -> unit!:
            self.set_field(field, moved * scale))
        self.sliders.append(StyleSlider(field, scale, pair))
        return self.kit.dialog_row(label, pair.row, 80.0)

    ## An effect: its checkbox heading and color swatch, then its rows.
    func section(self, items: list[Widget], on_field: int, color_field: int, name: str, rows: list[Widget]) -> unit!:
        let box = Checkbox(name, font = self.kit.font)
        let effect_index = self.effects.length
        self.kit.keep(box.on_change(func (value: bool) -> unit!:
            self.set_field(on_field, 1.0 if value else 0.0)))
        let swatch = Swatch()
        swatch.on_click = func () -> unit!:
            self.edit_color(effect_index)
        self.effects.append(Effect(on_field, color_field, name, box, swatch))
        items.append(HStack([box, Spacer(), swatch], spacing = 8.0))
        for row in rows:
            items.append(row)

    ## Open on the selected layer's styles.
    pub func open(self) -> unit!:
        if not self.session.open():
            return
        self.show()
        self.dialog.open()
        self.session.refresh()

    ## The session's start: a preview under way dropped, and the layer's
    ## style kept for Cancel.
    func begin(self) -> unit!:
        if self.workspace.previews.previewing():
            self.workspace.previews.end_preview(false)
        self.before = []
        var field = 0
        while field < style_fields:
            self.before.append(self.workspace.previews.style_value(field))
            field += 1

    ## The controls as the layer's style is now.
    func show(self) -> unit!:
        for slider in self.sliders:
            slider.pair.set_value(self.workspace.previews.style_value(slider.field) / slider.scale)
        for effect in self.effects:
            effect.box.set_checked(self.workspace.previews.style_value(effect.on_field) != 0.0)
            effect.swatch.color = Color(self.workspace.previews.style_value(effect.color_field), self.workspace.previews.style_value(effect.color_field + 1),
                                        self.workspace.previews.style_value(effect.color_field + 2))
            effect.swatch.layout().invalidate()
        # The shadow's offsets as the angle the light comes from and a distance.
        let dx = self.workspace.previews.style_value(1)
        let dy = self.workspace.previews.style_value(2)
        self.shadow_distance.set_value(math.hypot(dx, dy))
        if dx != 0.0 or dy != 0.0:
            self.shadow_angle.set_value(math.round(math.atan2(dy, -dx) * 180.0 / math.pi))
        let position = int(self.workspace.previews.style_value(20))
        self.position_menu.set_text(["Outside ▾", "Center ▾", "Inside ▾"][position])

    ## The shadow falls away from the light: at the angle's opposite, `distance` away.
    func set_shadow_offset(self) -> unit!:
        let radians = self.shadow_angle.value() * math.pi / 180.0
        let distance = self.shadow_distance.value()
        self.set_field(1, -math.cos(radians) * distance)
        self.set_field(2, math.sin(radians) * distance)

    ## One field of the selected layer's style, live.
    func set_field(self, field: int, value: float) -> unit!:
        self.workspace.previews.set_style_value(field, value)
        if field == 20:
            self.show()
        if let changed = self.changed:
            changed()

    ## The picker on effect `index`'s color; each change goes to the layer.
    func edit_color(self, index: int) -> unit!:
        let effect = self.effects[index]
        let first = effect.color_field
        let hex = hex_of_linear(self.workspace.previews.style_value(first), self.workspace.previews.style_value(first + 1), self.workspace.previews.style_value(first + 2))
        if let pick = self.pick_color:
            pick(effect.name + " Color", hex, func (chosen: str) -> unit!:
                self.take_color(index, chosen))

    func take_color(self, index: int, hex: str) -> unit!:
        let linear = linear_of_hex(hex) else return
        let first = self.effects[index].color_field
        self.set_field(first, linear[0])
        self.set_field(first + 1, linear[1])
        self.set_field(first + 2, linear[2])
        self.show()

    pub func apply(self) -> unit!:
        self.session.close(true)

    pub func cancel(self) -> unit!:
        self.session.close(false)

    ## The session's end: Cancel puts the style back as it was when the dialog opened.
    func finish(self, keep: bool) -> unit!:
        if keep or self.before.length != style_fields:
            return
        var field = 0
        for value in self.before:
            self.workspace.previews.set_style_value(field, value)
            field += 1