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