Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-2d

Source of release 0.5.1

0.5.1 / src / panels.luc

## The window's contents, after Compositor's: the menu bar, a contextual tool
## header, the dock (the viewport with its tool rail and rulers, Layers and
## Properties, and whatever else the "+" or the Window menu opened —
## panel_catalog.luc) and a status line; the dialogs
## float above. Each part lives in its own module; this one composes them,
## wires every shared command to what the window does for it, and refreshes
## them all when the document changes.
from luce_ui.ui import Font, Text, VStack, HStack, Toolbar, Size, Spacer, Widget, DStack, Panel, Rule, ContextMenu, NumberField
from luce_window.input import Key
from workspace import Workspace
from actions import Actions
from view import CanvasView
from layers import LayerList
from tabs import DocumentTabs
from rulers import Ruler, RulerCorner
from document_panel import DocumentSettings
from palette import Palette
from color_picker import ColorPicker
from settings import Store
from settings_panel import SettingsDialog
from kit import Kit
from tool_header import ToolHeader
from brush_settings import BrushSettings, define_tip
from brush import preset
from brush_dynamics import no_mappings
from adjust_dialog import AdjustDialog
from style_dialog import StyleDialog
from properties import Properties
from prompts import Prompts
from document_files import DocumentFiles
from menus import menu_bar
from layers_panel import LayersPanel
from size_dialogs import SizeDialogs
from color_range_dialog import ColorRangeDialog
from replace_color_dialog import ReplaceColorDialog
from select_mask_dialog import SelectMaskDialog
from channel_dialogs import SaveSelectionDialog, LoadSelectionDialog
from text_editing import TextEditing
from script_editor import ScriptEditor
from tool_rail import ToolRail
from layer_transfer import send_layers
from panel_catalog import PanelCatalog
from panel_list import panel_entries
from dock_layout import DockLayout
from align import align_modes, align_layers
from luce_std import math
from units import unit_ids
from transform_flow import TransformFlow
from panel_prompts import PanelPrompts
from panels_wiring import PanelsWiring

pub class Panels:
    pub let body: VStack
    ## Frames until the canvas takes the keys back (0: nothing pending). Docking
    ## focuses the panels it adds, after this frame, so the canvas asks later.
    var focus_canvas_in: int = 0
    pub let view: CanvasView
    ## The open documents' tabs across the top of the viewport.
    pub let tabs: DocumentTabs
    ## Rulers above and left of the canvas; the row above holds the corner too.
    pub let top_ruler: Ruler
    pub let left_ruler: Ruler
    let ruler_row: HStack
    let left_ruler_menu: ContextMenu
    pub let workspace: Workspace
    pub let actions: Actions
    pub let status: Text
    ## The zoom as a number to type, in the status bar's corner.
    let zoom_field: NumberField
    pub let header: ToolHeader
    pub let brush: BrushSettings
    pub let adjust: AdjustDialog
    pub let style: StyleDialog
    ## File › Script Editor…
    pub let scripts: ScriptEditor
    pub let properties: Properties
    pub let prompts: Prompts
    pub let layers: LayerList
    ## The dock and its panes, each pane's buttons on a shelf at its bottom.
    pub let dock: DStack
    pub let viewport_panel: Panel
    pub let layers_panel: LayersPanel
    ## Every panel the "+" and the Window menu open (panel_catalog.luc).
    pub let catalog: PanelCatalog
    ## The arrangement kept across runs (dock_layout.luc).
    pub let dock_layout: DockLayout
    ## The tool rail: its buttons, groups and flyouts (tool_rail.luc).
    pub let rail: ToolRail
    ## The palette below the tool rail and the picker its swatches open, as Compositor's.
    pub let palette: Palette
    pub let picker: ColorPicker
    ## The picker and the mask's black/white choice on a swatch, the text
    ## editor for the Text tool (panel_prompts.luc).
    pub let panel_prompts: PanelPrompts
    ## The menus' transforms and crop (transform_flow.luc).
    pub let transform_flow: TransformFlow
    ## The workspace revision the panels last showed.
    var shown_revision: int = -1
    ## The load percentage the status bar shows while a picture opens: -1 when
    ## none is, -2 when the status bar says something else meanwhile.
    var shown_opening: int = -1
    pub let document_settings: DocumentSettings
    pub let size_dialogs: SizeDialogs
    pub let color_range: ColorRangeDialog
    pub let replace_color: ReplaceColorDialog
    pub let select_mask: SelectMaskDialog
    pub let save_selection: SaveSelectionDialog
    pub let load_selection: LoadSelectionDialog
    pub let text_editing: TextEditing
    pub let settings_dialog: SettingsDialog
    pub let files: DocumentFiles
    let kit: Kit

    pub func init(self, workspace: Workspace, actions: Actions, font: Font, store: Store? = none) -> unit!:
        self.workspace = workspace
        self.actions = actions
        self.kit = Kit(font)
        let kit = self.kit
        self.settings_dialog = SettingsDialog(workspace, actions, font, store else Store())
        self.settings_dialog.applied = self.refresh
        self.prompts = Prompts(workspace, font)
        self.prompts.refreshed = self.refresh
        kit.keep(self.prompts.prompt.on_submit(self.prompts.apply))
        self.files = DocumentFiles(workspace, self.prompts, kit)
        self.files.refreshed = self.refresh
        self.view = CanvasView(workspace, font)
        self.view.on_open_files = self.files.open_files
        self.view.keys.on_key_up = self.spring_back
        self.view.context.on_changed = self.refresh
        self.view.context.on_refused = self.prompts.tell
        self.tabs = DocumentTabs(workspace, font)
        self.tabs.on_switch = self.switch_document
        self.tabs.on_close = self.files.close_document_at
        self.layers_panel = LayersPanel(workspace, actions, kit)
        self.layers = self.layers_panel.layer_list
        self.layers.on_drop_outside = self.layers_dropped
        # Pictures dropped on the list become layers, one after another.
        self.layers.on_place_files = self.files.place_files
        self.layers_panel.refreshed = self.refresh
        self.layers_panel.failed = self.prompts.tell
        self.status = Text("", font = font)
        self.zoom_field = NumberField(100.0, 1.0, 6400.0, 1.0, suffix = "%", font = font, cells = 7.0)
        kit.keep(self.zoom_field.on_change(self.type_zoom))
        self.header = ToolHeader(workspace, kit)
        self.header.brush_settings = self.open_brush
        self.header.refreshed = self.refresh
        self.brush = BrushSettings(workspace, kit)
        self.brush.on_failed = self.prompts.tell
        self.adjust = AdjustDialog(workspace, kit)
        self.adjust.changed = self.document_changed
        self.adjust.session.report(self.refresh, self.prompts.tell)
        self.style = StyleDialog(workspace, kit)
        self.style.changed = self.document_changed
        self.style.session.report(self.refresh, self.prompts.tell)
        self.style.pick_color = func (title: str, hex: str, changed: func(str) -> unit!) -> unit!:
            self.picker.open_for(title, hex, changed)
        self.layers_panel.open_style = self.style.open
        self.scripts = ScriptEditor(workspace, actions, kit)
        self.scripts.changed = self.refresh
        self.properties = Properties(workspace, kit, actions.blends, self.toggle_visibility, self.toggle_clipped, self.toggle_mask, self.style.open)
        self.properties.changed = self.document_changed
        self.properties.refreshed = self.refresh
        self.palette = Palette(workspace)
        self.picker = ColorPicker(workspace, font)
        self.picker.closed = self.refresh
        self.picker.committed = self.settings_dialog.remember
        self.document_settings = DocumentSettings(workspace, font)
        self.document_settings.applied = self.refresh
        kit.dialog_keys(self.document_settings.dialog, self.document_settings.cancel, self.document_settings.apply)
        kit.dialog_keys(self.settings_dialog.dialog, self.settings_dialog.cancel, self.settings_dialog.save)
        self.text_editing = TextEditing(workspace, kit, actions.commit_text)
        self.text_editing.changed = self.refresh
        self.text_editing.failed = self.prompts.tell
        self.header.type_controls.changed = self.text_editing.restyle
        kit.bind(actions.commit_text, self.text_editing.commit)
        self.panel_prompts = PanelPrompts(workspace, kit, self.picker, self.text_editing, self.prompts, self.adjust.dialog)
        self.panel_prompts.refreshed = self.refresh
        self.palette.on_pick = self.panel_prompts.pick_color
        # Both places that show a Gradient Map pick its colors with the picker.
        self.adjust.controls.map_colors.pick_color = self.panel_prompts.pick_any_color
        self.properties.adjustment.map_colors.pick_color = self.panel_prompts.pick_any_color
        self.view.context.on_text = self.panel_prompts.place_text
        self.view.context.on_edit_text = self.panel_prompts.edit_text
        self.transform_flow = TransformFlow(workspace, self.view, self.prompts)
        self.transform_flow.refreshed = self.refresh
        self.header.finished = self.transform_flow.finish_box
        self.size_dialogs = SizeDialogs(workspace, actions, kit)
        self.size_dialogs.report(self.refresh, self.prompts.tell)
        self.tabs.on_new = self.size_dialogs.new_canvas.open
        self.color_range = ColorRangeDialog(workspace, kit)
        self.color_range.session.report(self.refresh, self.prompts.tell)
        kit.bind(actions.color_range, self.color_range.open)
        self.replace_color = ReplaceColorDialog(workspace, kit)
        self.replace_color.session.report(self.refresh, self.prompts.tell)
        kit.bind(actions.replace_color, self.replace_color.open)
        self.select_mask = SelectMaskDialog(workspace, kit)
        self.select_mask.session.report(self.refresh, self.prompts.tell)
        kit.bind(actions.select_mask, self.select_mask.open)
        self.save_selection = SaveSelectionDialog(workspace, kit)
        self.save_selection.applied = self.refresh
        self.save_selection.failed = self.prompts.tell
        kit.bind(actions.save_selection, self.save_selection.open)
        self.load_selection = LoadSelectionDialog(workspace, kit)
        self.load_selection.applied = self.refresh
        self.load_selection.failed = self.prompts.tell
        kit.bind(actions.load_selection, self.load_selection.open)
        # Every shared command to what this window does for it (panels_wiring.luc).
        let wiring = PanelsWiring(actions, kit, workspace, self.prompts, self.refresh)
        wiring.menus(self.files, self.view, self.status, self.transform_flow, self.settings_dialog, self.choose_tool, self.define_brush)
        wiring.dialogs(self.adjust, self.style, self.scripts, self.document_settings, self.settings_dialog)
        wiring.layers(self.view, self.toggle_mask, self.toggle_visibility)
        # The tool rail: font-sized square buttons, the active
        # tool selected, and the palette below them.
        self.rail = ToolRail(actions, kit)
        var rail_items: list[Widget] = self.rail.items
        rail_items.append(Rule())
        rail_items.append(self.palette)
        # Quick Mask's button under the swatches, as Photoshop's.
        rail_items.append(self.rail.quick)
        let rail = VStack(rail_items, spacing = 3.0, padding = 4.0)
        rail.layout().set_limits(Size(kit.tool_side() + 12.0, 100.0), Size(kit.tool_side() + 12.0, 16384.0))
        rail.layout().set_flex(horizontal = 0.0)
        # The viewport: the tool rail beside the canvas, a one-point backdrop rule
        # between them as eleusis's viewport has, and rulers around the canvas;
        # right-click either ruler for its units.
        self.top_ruler = Ruler(workspace, self.view, font, true)
        self.left_ruler = Ruler(workspace, self.view, font, false)
        self.ruler_row = HStack([RulerCorner(), ContextMenu(self.top_ruler, actions.units, font = font)], spacing = 0.0)
        self.left_ruler_menu = ContextMenu(self.left_ruler, actions.units, font = font)
        self.view.linked = [self.top_ruler.layout(), self.left_ruler.layout()]
        let view_row = HStack([self.left_ruler_menu, self.view], spacing = 0.0)
        view_row.layout().set_flex()
        let canvas_area = VStack([self.ruler_row, view_row], spacing = 0.0)
        canvas_area.layout().set_flex()
        let canvas_row = HStack([rail, Rule(structural = true, vertical = true), canvas_area], spacing = 0.0)
        canvas_row.layout().set_flex()
        let viewport = VStack([self.tabs, canvas_row], spacing = 0.0)
        viewport.layout().set_flex()
        self.viewport_panel = Panel("Viewport", viewport, minimum = Size(320.0, 200.0), closable = false, id = "viewport")
        self.dock = DStack([self.viewport_panel], font = font)
        self.dock.layout().set_flex()
        self.catalog = PanelCatalog(self.dock, self.viewport_panel, workspace, kit, self.view, self.settings_dialog, self.layers_panel, self.properties, self.brush)
        self.catalog.refreshed = self.refresh
        self.catalog.failed = self.prompts.tell
        self.catalog.open_picker = self.panel_prompts.pick_color
        self.catalog.pick_any_color = self.panel_prompts.pick_any_color
        self.catalog.brush_chosen = func () -> unit!:
            self.choose_tool("brush")
        self.catalog.align_commands = actions.aligns
        # The panels as they always start; the app brings back the kept arrangement.
        self.dock_layout = DockLayout(self.dock, self.catalog, self.viewport_panel)
        self.dock_layout.arrange_default()
        kit.bind(actions.reset_layout, func () -> unit!:
            self.dock_layout.reset()
            # Re-docking panels focuses the last one added; the keys belong to the canvas.
            self.focus_canvas_in = 2
            self.refresh())
        var align_index = 0
        for each in align_modes():
            let chosen = each
            kit.bind(actions.aligns[align_index], func () -> unit!:
                _ = align_layers(self.workspace, chosen)
                self.refresh())
            align_index += 1
        var window_index = 0
        for entry in panel_entries():
            let id = entry.id
            kit.bind(actions.windows[window_index], func () -> unit!:
                self.catalog.toggle(id)
                self.refresh())
            window_index += 1
        # The status bar is where a control's hint shows, as in eleusis: no tooltips.
        self.body = VStack([menu_bar(actions, font), self.header.bar, self.dock, Toolbar([self.zoom_field, self.status, Spacer(), self.header.hint], font = font),
                            self.prompts.prompt, self.panel_prompts.mask_prompt, self.adjust.dialog, self.style.dialog, self.scripts.dialog, self.settings_dialog.dialog,
                            self.document_settings.dialog, self.files.confirm, self.files.export_dialog.dialog, self.text_editing.dialog,
                            self.picker.dialog, self.color_range.dialog, self.replace_color.dialog, self.select_mask.dialog, self.save_selection.dialog, self.load_selection.dialog] + self.size_dialogs.dialogs(), spacing = 0.0)
        self.body.layout().set_flex()
        self.refresh()

    # -- Tools and colors.

    ## A key let go over the canvas: if it is the current tool's key and the
    ## tool was used while it was held, return to the tool before, as
    ## Photoshop's spring-loaded tools do. A tap keeps the new tool.
    pub func spring_back(self, key: Key) -> unit!:
        let workspace = self.workspace
        if not workspace.tools.tool_used or workspace.tools.tool_before == workspace.tools.tool:
            return
        for command in self.actions.tools:
            if command.id() == workspace.tools.tool and command.shortcut().key == key:
                self.choose_tool(workspace.tools.tool_before)
                return

    pub func choose_tool(self, tool: str) -> unit!:
        self.workspace.choose_tool(tool)
        self.refresh()

    ## Edit › Define Brush Preset…: the selection's pixels (the whole picture
    ## without one) become the tip of a new brush in the library, which is
    ## then the brush in hand, as Photoshop's.
    pub func define_brush(self) -> unit!:
        let tip = define_tip(self.workspace) catch failure:
            self.prompts.tell(f"Define Brush Preset: {failure.message}")
            return
        let brush = preset("Hard Round", math.max(float(tip.width()), float(tip.height())), 1.0)
        brush.dynamics = no_mappings()
        brush.spacing = 0.1
        brush.tip = tip
        self.catalog.open("brushes")
        let brushes = self.catalog.brushes else return
        brushes.add(brush, f"Sampled Brush {brushes.saved.length + 1}")
        brushes.pick(brushes.rows.selected)
        self.refresh()

    ## Brush…: Brush Settings, floating the first time.
    pub func open_brush(self) -> unit!:
        self.brush.open(self.dock)

    # -- Layers.

    pub func select_layer(self, index: int) -> unit!:
        self.workspace.layers.select(index)
        self.refresh()

    pub func toggle_visibility(self) -> unit!:
        self.workspace.edits.toggle_visibility()
        self.refresh()

    pub func toggle_mask(self) -> unit!:
        self.prompts.attempt("Mask", func () -> unit!:
            self.workspace.edits.toggle_mask())

    pub func toggle_clipped(self) -> unit!:
        self.workspace.edits.toggle_clipped()
        self.refresh()

    # -- Documents.

    pub func switch_document(self, index: int) -> unit!:
        self.workspace.documents.switch_to(index)
        self.refresh()

    ## Layers dragged from the Layers panel and let go at window point
    ## (`x`, `y`): onto another document's tab, they go there.
    func layers_dropped(self, x: float, y: float) -> unit!:
        let index = self.tabs.tab_at(x, y)
        if index >= 0 and index != self.workspace.documents.current:
            send_layers(self.workspace, index)
            self.refresh()

    # -- Showing the state.

    ## A zoom typed in the status bar, in percent, about the view's middle.
    func type_zoom(self, percent: float) -> unit!:
        let bounds = self.view.layout().bounds()
        self.workspace.viewport.zoom_about(percent / 100.0 / self.workspace.viewport.zoom, bounds.width * 0.5, bounds.height * 0.5)
        self.refresh()

    ## The document's pixels changed without a structural change: redraw the
    ## canvas and the layer thumbnails.
    func document_changed(self) -> unit!:
        self.view.layout().invalidate()
        self.layers.layout().invalidate()

    ## Once a frame, while the document's picture opens (or Select and Mask's
    ## OK refines the selection): how far it has come, in the status bar and on
    ## its tab, and its thumbnail filling in; once it is in, the panels as
    ## usual (the edits it held back are offered again). Queued drops start
    ## one after another.
    pub func show_opening(self) -> unit!:
        let workspace = self.workspace
        workspace.documents.continue_opening()
        self.files.pump()
        let canvas = workspace.canvas
        canvas.continue_refine() catch failure:
            self.prompts.tell(f"Select and Mask: {failure.message}")
        let refining = canvas.refine_keeping()
        if not canvas.is_opening() and not refining:
            if self.shown_opening != -1:
                self.shown_opening = -1
                self.refresh()
            return
        let percent = canvas.refine_percent() if refining else canvas.opening_percent()
        # The queue's place counts too, so the status changes when the next picture starts.
        let queued = self.files.queue.status(percent)
        let shown = percent + 1000 * queued.length
        if shown == self.shown_opening:
            return
        self.shown_opening = shown
        let name = workspace.live.path if workspace.live.path != "" else "Untitled"
        let doing = f"Refining… {percent}%  |  edits wait until the selection is in" if refining else (queued if queued != "" else f"Opening… {percent}%") + "  |  edits wait until the picture is in"
        self.status.set_text(f"{doing}  |  {workspace.canvas.width()} × {workspace.canvas.height()} px  |  {name}")
        self.tabs.layout().invalidate()
        self.layers.layout().invalidate()

    ## Once a frame: when the document changed since the panels last showed it
    ## (a stroke let go, a key's edit), show it — not mid-stroke, when every
    ## frame changes it. Menus and shortcuts then offer what is possible now.
    pub func refresh_if_changed(self) -> unit!:
        if self.workspace.live.revision == self.shown_revision or self.workspace.canvas.painting():
            return
        self.refresh()

    pub func refresh(self) -> unit!:
        let workspace = self.workspace
        self.shown_revision = workspace.live.revision
        self.header.show(self.picker.is_open())
        self.palette.layout().invalidate()
        self.picker.sync()
        if self.dock.contains(self.brush.panel):
            self.brush.show()
        self.properties.show()
        self.catalog.show_made()
        var window_index = 0
        for entry in panel_entries():
            self.actions.windows[window_index].set_checked(self.catalog.is_open(entry.id))
            window_index += 1
        let name = workspace.live.path if workspace.live.path != "" else "Untitled"
        let percent = int(workspace.viewport.zoom * 100.0 + 0.5)
        let dpi = int(math.floor(workspace.canvas.resolution() + 0.5))
        self.zoom_field.set_value(float(percent))
        self.status.set_text(f"{workspace.canvas.width()} × {workspace.canvas.height()} px  |  {dpi} px/in  |  {workspace.canvas.profile()}  |  {name}")
        if workspace.canvas.is_opening() or workspace.canvas.refine_keeping():
            # The next frame puts the progress back.
            self.shown_opening = -2
        self.layers_panel.show()
        self.rail.show(workspace)
        self.actions.update(workspace)
        # The view aids, with their state in the View menu.
        self.ruler_row.layout().set_visible(workspace.viewport.show_rulers)
        self.left_ruler_menu.layout().set_visible(workspace.viewport.show_rulers)
        self.top_ruler.layout().invalidate()
        self.left_ruler.layout().invalidate()
        self.actions.show_rulers.set_checked(workspace.viewport.show_rulers)
        self.actions.show_guides.set_checked(workspace.viewport.show_guides)
        self.actions.snap.set_checked(workspace.viewport.snap)
        self.actions.lock_guides.set_checked(workspace.viewport.lock_guides)
        self.actions.clear_guides.set_enabled(workspace.canvas.guide_count() > 0)
        self.actions.show_transform_controls.set_checked(workspace.transforms.show_transform_controls)
        self.actions.show_grid.set_checked(workspace.viewport.show_grid)
        var shown = 0
        for unit_name in unit_ids():
            self.actions.units[shown].set_checked(workspace.viewport.units == unit_name)
            shown += 1
        self.layers.layout().invalidate()
        self.tabs.layout().invalidate()
        self.view.layout().invalidate()

    pub func close(self):
        self.prompts.cancel()
        self.settings_dialog.close()
        self.picker.close()
        self.document_settings.close()
        self.size_dialogs.close()
        self.text_editing.close_all()
        if self.workspace.previews.previewing():
            self.workspace.previews.end_preview(false) catch failure:
                _ = failure
        self.kit.close()

    ## Each frame: give the canvas the keys once a pending focus is due.
    pub func settle_focus(self) -> unit!:
        if self.focus_canvas_in <= 0:
            return
        self.focus_canvas_in -= 1
        if self.focus_canvas_in == 0:
            self.view.layout().request_focus()