dymokomi/luced-2d
Source of release 0.5.0
## 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()