Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-2d

Source of release 0.5.0

0.5.0 / src / brushes_panel.luc

## The Brushes panel, as Photoshop's: the built-in presets, then the brushes
## saved in the library (brush_library.luc), each with a stroke thumbnail,
## imported ones under a folding header per group (the file they came from). A
## click makes that the brush (and picks the Brush tool). The shelf saves the
## brush in hand as a new brush, saves it over the picked saved one,
## duplicates, renames (also a double-click on the name) and deletes, and
## imports brush files (luced-2d's `.l2dbrush`, Photoshop's `.abr`,
## Procreate's `.brush`) and exports `.l2dbrush` files to share.
from luce_ui.ui import Panel, Shelf, Spacer, Size, TextField, VStack, ConfirmDialog
from workspace import Workspace
from brush import Brush, preset, preset_names, max_brush
from luce_painting.brush_mask import BrushMask
from brush_library import SavedBrush, library_path, load_library, save_brush, delete_brush, free_folder, export_brush
from brush_import import import_brushes
from brush_list import BrushList, stroke_thumbnail
from brush_settings import BrushSettings
from kit import Kit
from theme import Look
from luce_std import math

pub class BrushesPanel:
    pub let panel: Panel
    pub let rows: BrushList
    let workspace: Workspace
    let settings: BrushSettings
    let rename_field: TextField
    ## Asks before a saved brush's folder goes, and the row it asks about.
    pub let confirm: ConfirmDialog
    var deleting: int = -1
    ## The library's folder and what it holds.
    pub let library: str
    pub var saved: list[SavedBrush]
    ## A 1 × 1 mask the round thumbnails are drawn through.
    let blank: BrushMask
    ## The saved row being renamed, or -1.
    var renaming: int = -1
    ## A brush picked: the window picks the Brush tool and refreshes.
    pub var chosen: func() -> unit!? = none
    ## Something failed, and why.
    pub var failed: func(str) -> unit!? = none

    ## The library under `directory` (the home folder's `.luced-2d` by default).
    pub func init(self, workspace: Workspace, kit: Kit, settings: BrushSettings, directory: str = "") -> unit!:
        self.workspace = workspace
        self.settings = settings
        self.library = library_path(directory)
        self.saved = load_library(self.library)
        self.blank = BrushMask.create(1, 1)
        self.rows = BrushList(kit.font, self.look)
        self.rows.on_pick = self.pick
        self.rows.stroke = self.stroke_of
        self.rows.on_rename = self.begin_rename
        self.rename_field = TextField("", font = kit.font, cells = 16.0)
        let field_box = self.rename_field.layout()
        field_box.set_popup(true)
        field_box.set_modal(false)
        field_box.set_visible(false)
        kit.keep(self.rename_field.on_commit(self.finish_rename))
        self.confirm = ConfirmDialog(font = kit.font)
        kit.keep(self.confirm.on_choose(self.chosen_delete))
        let content = VStack([self.rows, self.rename_field, self.confirm], spacing = 0.0)
        content.layout().set_flex()
        let shelf = Shelf([kit.shelf_button("plus", self.save_new), kit.shelf_button("save", self.save_over), kit.shelf_button("duplicate", self.duplicate),
                           kit.shelf_button("text-tool", self.rename_selected), kit.shelf_button("import", self.import_file), kit.shelf_button("export", self.export_file),
                           Spacer(), kit.shelf_button("trash", self.delete_selected)])
        self.panel = Panel("Brushes", content, minimum = Size(220.0, 160.0), footer = shelf, id = "brushes")
        self.show()
        # The row of the library brush in hand, as the last run left it; its
        # group open, the other groups folded.
        var open: list[str] = []
        var index = 0
        for saved in self.saved:
            if saved.folder != "" and saved.folder == workspace.tools.brush.folder:
                self.rows.selected = preset_names().length + index
                open.append(saved.group)
            index += 1
        self.rows.fold_all_but(open)

    ## `group` unfolded and scrolled to the top of the list.
    pub func show_group(self, group: str) -> unit!:
        if self.rows.is_folded(group):
            self.rows.toggle_group(group)
        self.rows.scroll_to(self.rows.group_top(group))

    ## The window's accent and selection colors.
    func look(self) -> Look:
        return self.workspace.look

    ## The rows again: the built-ins, then the saved brushes, by group.
    pub func show(self) -> unit!:
        var names: list[str] = []
        var groups: list[str] = []
        for name in preset_names():
            names.append(name)
            groups.append("")
        for saved in self.saved:
            names.append(saved.name)
            groups.append(saved.group)
        self.rows.first_saved = preset_names().length
        self.rows.set_rows(names, groups)

    ## Row `row`'s stroke thumbnail, drawn when the list first shows it.
    func stroke_of(self, row: int) -> bytes!:
        let names = preset_names()
        if row < names.length:
            return stroke_thumbnail(preset(names[row], 24.0, 1.0), self.blank)
        let saved = self.saved_at(row) else return b""
        saved.load_images()
        return stroke_thumbnail(saved.brush, self.blank)

    ## The saved brush on row `row`, when it is one.
    func saved_at(self, row: int) -> SavedBrush?:
        let index = row - preset_names().length
        if index < 0 or index >= self.saved.length:
            return none
        return self.saved[index]

    ## Row `row` picked: a built-in keeps the size and strength in hand, as the
    ## header's preset menu does; a saved brush brings its own, as a copy, so
    ## painting changes nothing saved until Save.
    pub func pick(self, row: int) -> unit!:
        let names = preset_names()
        if row < 0:
            return
        if row < names.length:
            self.workspace.tools.apply_preset(names[row])
        elif let saved = self.saved_at(row):
            saved.load_images()
            let brush = saved.brush.copy()
            brush.diameter = math.max(1.0, math.min(max_brush, brush.diameter))
            brush.preset = saved.name
            brush.folder = saved.folder
            self.workspace.tools.brush = brush
            self.workspace.touch()
        self.settings.show()
        if let done = self.chosen:
            done()

    ## "+": the brush in hand saved as a new brush, "Brush N".
    pub func save_new(self) -> unit!:
        self.add(self.workspace.tools.brush.copy(), f"Brush {self.saved.length + 1}")
        # The brush in hand is that saved brush now: the header's preset menu names it.
        if let saved = self.saved_at(self.rows.selected):
            self.workspace.tools.brush.preset = saved.name
            self.workspace.tools.brush.folder = saved.folder
            self.workspace.touch()
            if let done = self.chosen:
                done()

    ## Keep `brush` in the library as `name` in `group`, and pick its row.
    pub func add(self, brush: Brush, name: str, group: str = "") -> unit!:
        let saved = SavedBrush(name, free_folder(self.library, name), brush, group)
        save_brush(self.library, saved) catch failure:
            self.fail(f"Could not save the brush: {failure.message}")
            return
        brush.preset = name
        brush.folder = saved.folder
        self.saved.append(saved)
        self.show()
        self.rows.selected = preset_names().length + self.saved.length - 1

    ## Save: the brush in hand over the picked saved brush (a built-in is
    ## saved as a new one).
    pub func save_over(self) -> unit!:
        let found = self.saved_at(self.rows.selected)
        if found == none:
            self.save_new()
            return
        let saved = found else return
        let kept = SavedBrush(saved.name, saved.folder, self.workspace.tools.brush.copy(), saved.group)
        save_brush(self.library, kept) catch failure:
            self.fail(f"Could not save the brush: {failure.message}")
            return
        self.saved[self.rows.selected - preset_names().length] = kept
        self.show()

    ## Duplicate: a copy of the picked brush, built-in or saved, as a new one.
    pub func duplicate(self) -> unit!:
        let row = self.rows.selected
        if row < 0:
            return
        if let saved = self.saved_at(row):
            saved.load_images()
            self.add(saved.brush.copy(), saved.name + " copy", saved.group)
        elif row < preset_names().length:
            let name = preset_names()[row]
            self.add(preset(name, self.workspace.tools.brush.diameter, self.workspace.tools.brush.opacity), name + " copy")

    ## Rename the picked saved brush, typed where its name is.
    pub func rename_selected(self) -> unit!:
        let row = self.rows.selected
        if self.saved_at(row) == none:
            return
        self.begin_rename(row, self.rows.name_left(), self.rows.row_top(row) + 2.0)

    func begin_rename(self, row: int, x: float, y: float) -> unit!:
        let saved = self.saved_at(row) else return
        self.renaming = row
        self.rename_field.set_text(saved.name)
        let field_box = self.rename_field.layout()
        field_box.set_popup_point(x - 4.0, y)
        field_box.set_visible(true)
        field_box.request_focus()

    func finish_rename(self, name: str) -> unit!:
        let row = self.renaming
        self.renaming = -1
        self.rename_field.layout().set_visible(false)
        self.rename(row, name) catch failure:
            self.fail(f"Could not rename the brush: {failure.message}")

    ## Saved row `row` named `name` (trimmed; an empty name changes nothing).
    pub func rename(self, row: int, name: str) -> unit!:
        let saved = self.saved_at(row) else return
        let trimmed = name.trim()
        if trimmed == "" or trimmed == saved.name:
            return
        saved.name = trimmed
        save_brush(self.library, saved)
        self.show()

    ## The bin: asks, then the picked saved brush leaves the library; the
    ## built-ins stay.
    pub func delete_selected(self) -> unit!:
        let row = self.rows.selected
        let saved = self.saved_at(row) else return
        self.deleting = row
        self.confirm.open(f"Delete the brush “{saved.name}” from the library?", "Delete", "")

    func chosen_delete(self, role: int) -> unit!:
        let row = self.deleting
        self.deleting = -1
        if role == 0:
            self.remove(row)

    ## Saved row `row` out of the library, its folder removed. The brush in
    ## hand, when it was that one, is an unsaved brush now.
    pub func remove(self, row: int) -> unit!:
        let saved = self.saved_at(row) else return
        delete_brush(self.library, saved.folder) catch failure:
            self.fail(f"Could not delete the brush: {failure.message}")
            return
        _ = self.saved.remove_at(row - preset_names().length)
        if self.workspace.tools.brush.folder == saved.folder:
            self.workspace.tools.brush.folder = ""
            self.workspace.tools.brush.preset = "(unsaved)"
            self.workspace.touch()
        self.rows.selected = -1
        self.show()

    ## Import: the brushes in a file chosen in the open panel join the library.
    pub func import_file(self) -> unit!:
        let app = self.settings.app else return
        let path = app.open_file("Import brushes (.l2dbrush, .abr, .brush)") catch failure:
            self.fail(f"Could not import: {failure.message}")
            return
        if path != "":
            self.import_path(path)

    ## The brushes in the file at `path`, added to the library in their group.
    pub func import_path(self, path: str) -> unit!:
        let imported = import_brushes(path) catch failure:
            self.fail(f"Could not import {path}: {failure.message}")
            return
        # Saved one by one, the rows shown once: an .abr can hold hundreds.
        for saved in imported:
            saved.folder = free_folder(self.library, saved.name)
            save_brush(self.library, saved) catch failure:
                self.fail(f"Could not save {saved.name}: {failure.message}")
                continue
            self.saved.append(saved)
        self.show()
        # The file's group open, scrolled to, to see what came in.
        for saved in imported:
            self.show_group(saved.group)
            break

    ## Export: the picked brush (the one in hand when none is) to a file.
    pub func export_file(self) -> unit!:
        let app = self.settings.app else return
        let chosen = self.export_choice()
        let path = app.save_file("Export the brush to share", chosen.name + ".l2dbrush") catch failure:
            self.fail(f"Could not export: {failure.message}")
            return
        if path != "":
            export_brush(chosen.brush, chosen.name, path, chosen.group) catch failure:
                self.fail(f"Could not export: {failure.message}")

    ## What Export writes: the picked saved brush, else the brush in hand.
    pub func export_choice(self) -> SavedBrush!:
        if let saved = self.saved_at(self.rows.selected):
            saved.load_images()
            return saved
        return SavedBrush(self.workspace.tools.brush.preset, "", self.workspace.tools.brush)

    func fail(self, message: str) -> unit!:
        if let failed = self.failed:
            failed(message)