Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-2d

Source of release 0.5.1

0.5.1 / src / tool_header.luc

## The contextual tool header across the top, after Compositor's: the active
## tool's name and only its options — the brush's preset, size, hardness,
## opacity, flow and spacing (eleusis scrubbers: drag to change, click to
## type), the wand's tolerance, the text size, the Move tool's Auto-Select,
## the Clone Stamp's Aligned and Sample, the Smudge tool's mode,
## Cancel and Apply while a free transform or the Crop tool's box is up — and
## the tool's hint, shown at the right of the status line.
from luce_ui import ui
from luce_ui.ui import default_spacing, Text, HStack, Toolbar, Size, Spacer, Menu, Command, Slider, NumberField, Checkbox
from workspace import Workspace
from shape_tool import restyle_selected, selected_shape_options
from kit import Kit
from brush import preset_names, max_brush
from tools import tool_by_id
from transform_controls import TransformControls
from type_controls import TypeControls
from selection_controls import SelectionControls
from crop_controls import CropControls
from warp_controls import WarpControls

pub class ToolHeader:
    pub let bar: Toolbar
    pub let title: Text
    pub let hint: Text
    pub let size_field: NumberField
    pub let hardness_field: NumberField
    pub let opacity_field: NumberField
    pub let flow_field: NumberField
    pub let spacing_field: NumberField
    pub let preset_menu: Menu
    pub let brush_controls: HStack
    pub let tolerance_slider: Slider
    pub let contiguous_button: Checkbox
    pub let wand_controls: HStack
    pub let text_controls: HStack
    pub let auto_select_box: Checkbox
    pub let move_controls: HStack
    pub let aligned_box: Checkbox
    pub let sample_menu: Menu
    pub let clone_controls: HStack
    pub let smear_menu: Menu
    pub let gradient_menu: Menu
    pub let reverse_box: Checkbox
    pub let transparent_box: Checkbox
    pub let gradient_controls: HStack
    ## The Line tool's weight and the Polygon tool's sides.
    pub let weight_row: HStack
    ## Dodge and Burn's range and exposure.
    pub let tone_row: HStack
    let range_menu: Menu
    pub let sides_row: HStack
    ## The shapes' fill and stroke, and a rectangle's corner radius.
    pub let paint_row: HStack
    pub let radius_row: HStack
    let fill_box: Checkbox
    let stroke_box: Checkbox
    let weight_field: NumberField
    let sides_field: NumberField
    let stroke_width_field: NumberField
    let radius_field: NumberField
    ## The selected shape layer's values the header last took, so it takes them once.
    var adopted: str = ""
    pub let box_controls: HStack
    pub let transform_controls: TransformControls
    pub let type_controls: TypeControls
    pub let selection_controls: SelectionControls
    pub let crop_controls: CropControls
    pub let warp_controls: WarpControls
    pub let controls_box: Checkbox
    ## Brush…: the window opens Brush Settings; a preset picked: the window
    ## refreshes; Apply or Cancel: the window finishes the box, keeping it or not.
    pub var brush_settings: func() -> unit!? = none
    pub var refreshed: func() -> unit!? = none
    pub var finished: func(bool) -> unit!? = none
    let workspace: Workspace
    let kit: Kit

    pub func init(self, workspace: Workspace, kit: Kit) -> unit!:
        self.workspace = workspace
        self.kit = kit
        let font = kit.font
        self.title = Text("Brush", font = font)
        self.title.layout().set_limits(Size(150.0, 0.0), Size(150.0, 16384.0))
        self.hint = Text("", font = font)
        self.size_field = self.scrubber(workspace.tools.brush.diameter, 1.0, max_brush, " px", func (value: float) -> unit!:
            self.workspace.tools.brush.diameter = value)
        self.hardness_field = self.scrubber(workspace.tools.brush.hardness * 100.0, 0.0, 100.0, "%", func (value: float) -> unit!:
            self.workspace.tools.brush.hardness = value / 100.0)
        self.opacity_field = self.scrubber(workspace.tools.brush.opacity * 100.0, 1.0, 100.0, "%", func (value: float) -> unit!:
            self.workspace.tools.brush.opacity = value / 100.0)
        self.flow_field = self.scrubber(workspace.tools.brush.flow * 100.0, 1.0, 100.0, "%", func (value: float) -> unit!:
            self.workspace.tools.brush.flow = value / 100.0)
        # Smudge keeps a spacing of its own; the field shows whichever is in use.
        self.spacing_field = self.scrubber(workspace.tools.brush.spacing * 100.0, 1.0, 500.0, "%", func (value: float) -> unit!:
            if self.smudging():
                self.workspace.tools.smudge_spacing = value / 100.0
            else:
                self.workspace.tools.brush.spacing = value / 100.0)
        var presets: list[Command] = []
        for name in preset_names():
            let chosen = name
            let command = Command(name, id = "preset_" + name)
            kit.bind(command, func () -> unit!:
                self.workspace.tools.apply_preset(chosen)
                if let refresh = self.refreshed:
                    refresh())
            presets.append(command)
        self.preset_menu = Menu(workspace.tools.brush.preset + " ▾", presets, font = font)
        self.brush_controls = HStack([self.preset_menu, kit.labelled("Size", self.size_field), kit.labelled("Hardness", self.hardness_field),
                                      kit.labelled("Opacity", self.opacity_field), kit.labelled("Flow", self.flow_field),
                                      kit.labelled("Spacing", self.spacing_field), kit.button("Brush…", self.open_brush_settings)], spacing = default_spacing)
        self.tolerance_slider = Slider("Tolerance", 0.0, 255.0, workspace.tools.tolerance, 1.0, font = font)
        kit.keep(self.tolerance_slider.on_change(func (value: float) -> unit!:
            self.workspace.tools.tolerance = value))
        self.contiguous_button = kit.checkbox("Contiguous", self.toggle_contiguous)
        self.wand_controls = HStack([self.tolerance_slider, self.contiguous_button], spacing = default_spacing)
        self.selection_controls = SelectionControls(workspace, kit, self.wand_controls)
        self.crop_controls = CropControls(workspace, kit)
        self.warp_controls = WarpControls(workspace, kit)
        self.type_controls = TypeControls(workspace, kit)
        self.text_controls = self.type_controls.row
        self.auto_select_box = kit.checkbox("Auto-Select", func () -> unit!:
            self.workspace.tools.auto_select = not self.workspace.tools.auto_select)
        self.controls_box = kit.checkbox("Show Transform Controls", func () -> unit!:
            self.workspace.transforms.show_transform_controls = not self.workspace.transforms.show_transform_controls
            self.workspace.touch())
        self.move_controls = HStack([self.auto_select_box, self.controls_box], spacing = default_spacing)
        self.transform_controls = TransformControls(workspace, kit)
        self.transform_controls.changed = func () -> unit!:
            if let refresh = self.refreshed:
                refresh()
        self.transform_controls.submitted = func () -> unit!:
            self.finish(true)
        let cancel = kit.button("Cancel", func () -> unit!:
            self.finish(false))
        let apply = kit.button("Apply", func () -> unit!:
            self.finish(true))
        self.box_controls = HStack([cancel, apply], spacing = 8.0)
        self.aligned_box = kit.checkbox("Aligned", func () -> unit!:
            self.workspace.tools.clone_aligned = not self.workspace.tools.clone_aligned)
        let this_layer = self.choice("This Layer", "clone_sample_layer", func () -> unit!:
            self.workspace.tools.clone_all = false)
        let all_layers = self.choice("All Layers", "clone_sample_all", func () -> unit!:
            self.workspace.tools.clone_all = true)
        self.sample_menu = Menu("This Layer ▾", [this_layer, all_layers], font = font)
        self.clone_controls = HStack([self.aligned_box, kit.labelled("Sample", self.sample_menu)], spacing = default_spacing)
        let smudge = self.choice("Smudge", "smear_smudge", func () -> unit!:
            self.workspace.tools.smear_mode = 0)
        let blur = self.choice("Blur", "smear_blur", func () -> unit!:
            self.workspace.tools.smear_mode = 1)
        let liquify = self.choice("Liquify", "smear_liquify", func () -> unit!:
            self.workspace.tools.smear_mode = 2)
        self.smear_menu = Menu("Smudge ▾", [smudge, blur, liquify], font = font)
        let linear = self.choice("Linear", "gradient_linear", func () -> unit!:
            self.workspace.tools.gradient_radial = false)
        let radial = self.choice("Radial", "gradient_radial", func () -> unit!:
            self.workspace.tools.gradient_radial = true)
        self.gradient_menu = Menu("Linear ▾", [linear, radial], font = font)
        self.reverse_box = kit.checkbox("Reverse", func () -> unit!:
            self.workspace.tools.gradient_reverse = not self.workspace.tools.gradient_reverse)
        self.transparent_box = kit.checkbox("To Transparent", func () -> unit!:
            self.workspace.tools.gradient_transparent = not self.workspace.tools.gradient_transparent)
        self.gradient_controls = HStack([self.gradient_menu, self.reverse_box, self.transparent_box], spacing = default_spacing)
        let shadows = self.choice("Shadows", "tone_shadows", func () -> unit!:
            self.workspace.tools.tone_range = 0)
        let midtones = self.choice("Midtones", "tone_midtones", func () -> unit!:
            self.workspace.tools.tone_range = 1)
        let highlights = self.choice("Highlights", "tone_highlights", func () -> unit!:
            self.workspace.tools.tone_range = 2)
        self.range_menu = Menu("Midtones ▾", [shadows, midtones, highlights], font = font)
        let exposure = self.scrubber(workspace.tools.tone_exposure * 100.0, 1.0, 100.0, "%", func (value: float) -> unit!:
            self.workspace.tools.tone_exposure = value / 100.0)
        self.tone_row = HStack([kit.labelled("Range", self.range_menu), kit.labelled("Exposure", exposure)], spacing = default_spacing)
        self.weight_field = self.scrubber(workspace.tools.shape_weight, 1.0, 1000.0, " px", func (value: float) -> unit!:
            self.workspace.tools.shape_weight = value
            restyle_selected(self.workspace))
        self.weight_row = kit.labelled("Weight", self.weight_field)
        self.sides_field = self.scrubber(float(workspace.tools.shape_sides), 3.0, 64.0, "", func (value: float) -> unit!:
            self.workspace.tools.shape_sides = int(value)
            restyle_selected(self.workspace))
        self.sides_row = kit.labelled("Sides", self.sides_field)
        self.fill_box = kit.checkbox("Fill", func () -> unit!:
            self.workspace.tools.shape_fill = not self.workspace.tools.shape_fill
            restyle_selected(self.workspace))
        self.stroke_box = kit.checkbox("Stroke", func () -> unit!:
            self.workspace.tools.shape_stroke = not self.workspace.tools.shape_stroke
            restyle_selected(self.workspace))
        self.stroke_width_field = self.scrubber(workspace.tools.shape_stroke_width, 0.5, 500.0, " px", func (value: float) -> unit!:
            self.workspace.tools.shape_stroke_width = value
            restyle_selected(self.workspace))
        self.paint_row = HStack([self.fill_box, self.stroke_box, self.stroke_width_field], spacing = 8.0)
        self.radius_field = self.scrubber(workspace.tools.shape_radius, 0.0, 1000.0, " px", func (value: float) -> unit!:
            self.workspace.tools.shape_radius = value
            restyle_selected(self.workspace))
        self.radius_row = kit.labelled("Radius", self.radius_field)
        # A scaled shape's sizes are seldom whole pixels: show a tenth.
        for field in [self.weight_field, self.stroke_width_field, self.radius_field]:
            field.set_decimals(1)
        self.bar = Toolbar([self.title, self.smear_menu, self.tone_row, self.paint_row, self.radius_row, self.weight_row, self.sides_row, self.gradient_controls, self.brush_controls, self.clone_controls, self.selection_controls.row, self.crop_controls.row, self.text_controls, self.move_controls,
                            self.transform_controls.row, self.warp_controls.row, Spacer(), self.box_controls],
                           font = font, inset = default_spacing, gap = 4.0)

    ## A brush setting's scrubber; `apply` takes each edit.
    ## A shape tool over a selected shape layer shows and edits that layer's
    ## options, as Photoshop's options bar: the header takes them when the
    ## layer or its values change (a transform scaling its stroke, say).
    func adopt_shape(self) -> unit!:
        let workspace = self.workspace
        if selected_shape_options(workspace) == none:
            self.adopted = ""
        let values = selected_shape_options(workspace) else return
        let key = f"{workspace.layers.selected_id()} {values.fill} {values.stroke} {values.stroke_width} {values.radius} {values.sides}"
        if key == self.adopted:
            return
        self.adopted = key
        workspace.tools.shape_sides = values.sides
        self.sides_field.set_value(float(values.sides))
        if values.line:
            workspace.tools.shape_weight = values.stroke_width
            self.weight_field.set_value(values.stroke_width)
            return
        workspace.tools.shape_fill = values.fill
        workspace.tools.shape_stroke = values.stroke
        workspace.tools.shape_stroke_width = values.stroke_width
        workspace.tools.shape_radius = values.radius
        self.stroke_width_field.set_value(values.stroke_width)
        self.radius_field.set_value(values.radius)

    func scrubber(self, value: float, minimum: float, maximum: float, suffix: str, apply: func(float) -> unit!) -> NumberField!:
        let field = NumberField(value, minimum, maximum, 1.0, suffix = suffix, font = self.kit.font, cells = 8.5)
        self.kit.keep(field.on_change(func (changed: float) -> unit!:
            apply(changed)
            self.workspace.touch()))
        return field

    ## Whether the Smudge tool is in Smudge mode, whose spacing is its own.
    func smudging(self) -> bool:
        return self.workspace.tools.tool == "smear" and self.workspace.tools.smear_mode == 0

    func open_brush_settings(self) -> unit!:
        if let open = self.brush_settings:
            open()

    ## A menu entry that does `change` and shows the header again.
    func choice(self, name: str, id: str, change: func() -> unit!) -> Command!:
        let command = Command(name, id = id)
        self.kit.bind(command, func () -> unit!:
            change()
            if let refresh = self.refreshed:
                refresh())
        return command

    func finish(self, keep: bool) -> unit!:
        if let done = self.finished:
            done(keep)

    func toggle_contiguous(self) -> unit!:
        self.workspace.tools.contiguous = not self.workspace.tools.contiguous
        self.contiguous_button.set_checked(self.workspace.tools.contiguous)

    ## Show the active tool's name, options and hint; `sampling` while the
    ## color picker takes clicks on the canvas.
    pub func show(self, sampling: bool) -> unit!:
        let workspace = self.workspace
        let tool = workspace.tools.tool
        let active = tool_by_id(tool)
        let on_mask = workspace.canvas.editing_mask() and (tool == "brush" or tool == "eraser")
        # A free transform or a warp takes over the header until it is applied or cancelled.
        var over = ""
        if workspace.transforms.transform != none:
            over = "Transform"
        elif let warp = workspace.transforms.mesh_warp:
            over = "Puppet Warp" if warp.puppet else "Warp"
        let transforming = over != ""
        self.title.set_text(over if transforming else (active.title + " on mask" if on_mask else active.title))
        let retouching = tool == "clone" or tool == "heal" or tool == "smear" or tool == "dodge" or tool == "burn"
        self.brush_controls.layout().set_visible(not transforming and (tool == "brush" or tool == "pencil" or tool == "eraser" or tool == "gradient" or retouching))
        self.tone_row.layout().set_visible(not transforming and (tool == "dodge" or tool == "burn"))
        self.range_menu.set_text(["Shadows ▾", "Midtones ▾", "Highlights ▾"][workspace.tools.tone_range])
        self.weight_row.layout().set_visible(not transforming and tool == "line")
        self.sides_row.layout().set_visible(not transforming and tool == "shape_polygon")
        let filled_shape = tool == "rectangle" or tool == "shape_ellipse" or tool == "shape_polygon" or tool == "pen"
        self.paint_row.layout().set_visible(not transforming and filled_shape)
        self.radius_row.layout().set_visible(not transforming and tool == "rectangle")
        if filled_shape or tool == "line":
            self.adopt_shape()
        self.fill_box.set_checked(workspace.tools.shape_fill)
        self.stroke_box.set_checked(workspace.tools.shape_stroke)
        self.clone_controls.layout().set_visible(not transforming and tool == "clone")
        self.smear_menu.layout().set_visible(not transforming and tool == "smear")
        self.aligned_box.set_checked(workspace.tools.clone_aligned)
        self.sample_menu.set_text("All Layers ▾" if workspace.tools.clone_all else "This Layer ▾")
        self.smear_menu.set_text(["Smudge ▾", "Blur ▾", "Liquify ▾"][workspace.tools.smear_mode])
        self.gradient_controls.layout().set_visible(not transforming and tool == "gradient")
        self.gradient_menu.set_text("Radial ▾" if workspace.tools.gradient_radial else "Linear ▾")
        self.reverse_box.set_checked(workspace.tools.gradient_reverse)
        self.transparent_box.set_checked(workspace.tools.gradient_transparent)
        # The wand's option as the workspace has it (it is kept between runs).
        self.contiguous_button.set_checked(workspace.tools.contiguous)
        let selecting = tool == "marquee" or tool == "ellipse" or tool == "lasso" or tool == "polygon" or tool == "magnetic" or tool == "wand"
        self.selection_controls.row.layout().set_visible(not transforming and selecting)
        self.selection_controls.show(tool)
        self.crop_controls.row.layout().set_visible(not transforming and tool == "crop")
        if tool == "crop":
            self.crop_controls.show()
        self.text_controls.layout().set_visible(not transforming and tool == "text")
        if tool == "text":
            self.type_controls.show()
        self.move_controls.layout().set_visible(not transforming and tool == "move")
        self.controls_box.set_checked(workspace.transforms.show_transform_controls)
        self.transform_controls.row.layout().set_visible(workspace.transforms.transform != none)
        self.transform_controls.show()
        self.warp_controls.row.layout().set_visible(over == "Warp")
        self.warp_controls.show()
        self.box_controls.layout().set_visible(transforming or workspace.image.crop_box != none or workspace.painting.gradient != none)
        self.auto_select_box.set_checked(workspace.tools.auto_select)
        self.size_field.set_value(workspace.tools.brush.diameter)
        self.hardness_field.set_value(workspace.tools.brush.hardness * 100.0)
        self.opacity_field.set_value(workspace.tools.brush.opacity * 100.0)
        self.flow_field.set_value(workspace.tools.brush.flow * 100.0)
        self.spacing_field.set_value((workspace.tools.smudge_spacing if self.smudging() else workspace.tools.brush.spacing) * 100.0)
        self.preset_menu.set_text(workspace.tools.brush.preset + " ▾")
        if over == "Warp":
            self.hint.set_text("Drag a corner, a handle or inside the mesh to bend it · a style bends it at once · Enter applies · Esc cancels")
        elif over == "Puppet Warp":
            self.hint.set_text("Click to pin · drag a pin to bend about the others · alt-click takes a pin away · Enter applies · Esc cancels")
        elif transforming:
            self.hint.set_text(f"Corner scales (shift frees) · side stretches · alt about the middle · {ui.primary_key_name().lower()}-corner distorts, +shift side skews, +alt+shift corner is perspective · alt-drag inside copies · outside turns · Enter applies")
        else:
            self.hint.set_text("Click the canvas to sample a color · X swaps · D resets" if sampling else active.hint)