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