dymokomi/luced-photo
Source of release 0.1.0
0.1.0 / src / presets_pane.luc
## The Presets pane, in the Library mode, as folders: Starts (the recipes a
## photo begins from: Television, Cinema, Slide, Black & White…), Film Looks
## (the looks of particular pictures luce-develop documents), the library's own
## folders of saved presets, then the saved presets in no folder. A click on a
## folder opens or closes it; a click on a row gives it to the selected photos
## (develop_session.luc says how). The row the photo shown was last given is
## highlighted (preset_marks.luc), its folder opened. A saved preset also names
## the parameters the Library mode shows for its photos (expose_dialog.luc):
## asked when it is saved, changed from its menu. The footer saves the
## developed photo's settings as a new preset (into the folder chosen), makes a
## folder, saves over the chosen preset, renames and deletes a preset or a
## folder; the row's menu (right-click) does the same and moves a preset into
## a folder. Presets and their folders live in the catalog (presets.lucb), so
## they travel with the library.
from luce_ui.ui import Panel, VStack, Shelf, Spacer, Size, Button, ButtonStyle, ListView, ListItem, ContextMenu, Command, TextPrompt, ConfirmDialog, Font, IconKind
from interop import Connection
from photo_library import PhotoLibrary
from expose_dialog import ExposeDialog
import presets
from luce_develop import looks
import preset_marks
from luce_develop import recipe
from luce_develop import settings
## The built-in folders' keys (a library folder's is its id, above 0).
let starts_folder: int = -1
let looks_folder: int = -2
pub class PresetsPane:
pub let panel: Panel
let library: PhotoLibrary
let rows: ListView
let row_menu: ContextMenu
let prompt: TextPrompt
let confirm: ConfirmDialog
let apply_command: Command
let update_command: Command
let rename_command: Command
let delete_command: Command
let expose_command: Command
let out_command: Command
## "Move to …" commands, made for each opening of the menu.
var move_commands: list[Command] = []
var move_connections: list[Connection] = []
pub let expose: ExposeDialog
let font: Font
var connections: list[Connection] = []
## What each row is: a preset mark (preset_marks.luc), or "" for a folder;
## a folder row's key (starts_folder, looks_folder or a folder's id), 0 for
## a preset row; and the folders closed.
var row_marks: list[str] = []
var row_folders: list[int] = []
var closed: set[int] = {}
## What the prompt asks for: "save" a new preset's name, "folder" a new
## folder's, "rename" the preset or "rename_folder" the folder with id
## `renaming`.
var asking: str = ""
var renaming: int = -1
## The settings a new preset takes: the photo's when Save was pressed; its
## name, and the folder it goes in.
var pending: str = ""
var pending_name: str = ""
var pending_folder: int = 0
## The preset whose exposed parameters the dialog edits (-1: a new one).
var exposing: int = -1
## What Delete asks about: a preset's id, or a folder's (`deleting_folder`).
var deleting: int = -1
var deleting_folder: bool = false
## The developed photo's settings as a saved preset holds them, none without one.
pub var current: func() -> str?!? = none
## A row was clicked: its name, settings and the mark the photos keep of it.
pub var on_apply: func(str, str, str) -> unit!? = none
pub var on_status: func(str) -> unit!? = none
pub func init(self, library: PhotoLibrary, font: Font) -> unit!:
self.library = library
self.font = font
self.rows = ListView([], font = font)
self.rows.layout().set_flex()
self.connections.append(self.rows.on_activate(self.clicked))
self.apply_command = Command("Apply to Selected Photos", id = "preset_apply")
self.update_command = Command("Update with Current Settings", id = "preset_update")
self.rename_command = Command("Rename…", id = "preset_rename")
self.delete_command = Command("Delete…", id = "preset_delete")
self.expose_command = Command("Show in Library…", id = "preset_expose")
self.out_command = Command("Move Out of Its Folder", id = "preset_out")
self.connections.append(self.expose_command.on_trigger(self.expose_chosen))
self.expose = ExposeDialog(font)
self.expose.chosen = self.exposed
self.connections.append(self.apply_command.on_trigger(func () -> unit!:
self.apply(self.rows.selected_index())))
self.connections.append(self.update_command.on_trigger(self.update_chosen))
self.connections.append(self.rename_command.on_trigger(self.rename_chosen))
self.connections.append(self.delete_command.on_trigger(self.delete_chosen))
self.connections.append(self.out_command.on_trigger(func () -> unit!:
self.move_chosen(0)))
self.row_menu = ContextMenu(self.rows, [self.apply_command], font = font)
self.connections.append(self.row_menu.on_open(self.fit_menu))
self.prompt = TextPrompt(font = font)
self.connections.append(self.prompt.on_submit(self.submitted))
self.confirm = ConfirmDialog(font = font)
self.connections.append(self.confirm.on_choose(self.chosen_delete))
let content = VStack([self.row_menu, self.prompt, self.confirm, self.expose.dialog], spacing = 0.0)
content.layout().set_flex()
let shelf = Shelf([self.shelf_button("plus", self.save_new), self.shelf_button("folder-new", self.new_folder),
self.shelf_button("save", self.update_chosen), self.shelf_button("text-tool", self.rename_chosen), Spacer(),
self.shelf_button("trash", self.delete_chosen)])
self.panel = Panel("Presets", content, minimum = Size(220.0, 120.0), closable = false, footer = shelf, id = "presets")
self.show()
func shelf_button(self, icon: str, callback: func() -> unit!) -> Button!:
let button = Button(icon = icon, font = self.font)
button.set_style(ButtonStyle.plain)
self.connections.append(button.on_click(callback))
button.layout().set_size(self.font.line_height() + 3.0, self.font.line_height() + 3.0)
return button
# mark: rows ===============================================================================
## List the folders and what is open in them, the row with mark `chosen`
## chosen ("" none).
pub func show(self, chosen: str = "") -> unit!:
let saved = self.library.presets
var items: list[ListItem] = []
self.row_marks = []
self.row_folders = []
self.add_folder(items, starts_folder, "Starts")
if not (starts_folder in self.closed):
for at in 0..<recipe.mode_total():
self.add_row(items, recipe.mode_name(at), preset_marks.for_start(at), "film-strip", 1)
self.add_folder(items, looks_folder, "Film Looks")
if not (looks_folder in self.closed):
for at in 0..<looks.count():
self.add_row(items, looks.name(at), preset_marks.for_look(at), "movie-camera", 1)
for folder in 0..<saved.folder_count():
let id = saved.folder_id(folder)
self.add_folder(items, id, saved.folder_name(folder))
if not (id in self.closed):
for at in 0..<saved.count():
if saved.folder(at) == id:
self.add_row(items, saved.name(at), preset_marks.for_saved(saved.id(at)), "film-strip", 1)
for at in 0..<saved.count():
if saved.folder(at) == 0:
self.add_row(items, saved.name(at), preset_marks.for_saved(saved.id(at)), "film-strip", 0)
self.rows.set_items(items)
self.rows.select(self.row_of(chosen))
self.panel.set_text("Presets" if saved.count() == 0 else f"Presets · {saved.count()}")
func add_folder(self, items: list[ListItem], key: int, name: str) -> unit!:
self.row_marks.append("")
self.row_folders.append(key)
items.append(ListItem(text = name, icon = IconKind.folder if key in self.closed else IconKind.folder_open))
## A row: a start or a saved preset (a film strip), or a film look of a
## motion picture (a movie camera); `depth` 1 inside a folder (its icon under the
## folder's name), 0 at the top.
func add_row(self, items: list[ListItem], name: str, mark: str, symbol: str, depth: int) -> unit!:
self.row_marks.append(mark)
self.row_folders.append(0)
items.append(ListItem(text = name, symbol = symbol, depth = depth))
## Row `row`'s mark ("" for a folder or none), and the row of mark `mark` (-1 none).
pub func mark_of(self, row: int) -> str:
return self.row_marks[row] if row >= 0 and row < self.row_marks.length else ""
pub func row_of(self, mark: str) -> int:
if mark == "":
return -1
for (at, held) in self.row_marks.indexed():
if held == mark:
return at
return -1
## The folder a mark's row is in (its key), 0 for none.
func folder_of(self, mark: str) -> int:
if preset_marks.start_of(mark) >= 0:
return starts_folder
if preset_marks.look_of(mark) >= 0:
return looks_folder
let saved = self.library.presets
let found = saved.position_of(preset_marks.saved_of(mark))
return saved.folder(found) if found >= 0 else 0
## The library's preset chosen in the list (its position), or -1.
func chosen(self) -> int:
return self.library.presets.position_of(preset_marks.saved_of(self.mark_of(self.rows.selected_index())))
## The library folder chosen: the folder row's, or the chosen preset's (0 none).
func chosen_folder(self) -> int:
let row = self.rows.selected_index()
if row < 0 or row >= self.row_folders.length:
return 0
if self.row_folders[row] > 0:
return self.row_folders[row]
let at = self.chosen()
return self.library.presets.folder(at) if at >= 0 else 0
## A click: a folder opens or closes, a row is given to the selected photos.
func clicked(self, row: int) -> unit!:
if row >= 0 and row < self.row_folders.length and self.row_folders[row] != 0:
let key = self.row_folders[row]
if key in self.closed:
_ = self.closed.remove(key)
else:
self.closed.insert(key)
self.show()
self.rows.select(self.row_of_folder(key))
return
self.apply(row)
func row_of_folder(self, key: int) -> int:
for (at, held) in self.row_folders.indexed():
if held == key:
return at
return -1
## Stack row `at` (a start, a film look or a preset) on the selected
## photos, as a click does.
pub func apply(self, at: int) -> unit!:
self.apply_mark(self.mark_of(at))
## Stack what mark `mark` names on the selected photos.
pub func apply_mark(self, mark: str) -> unit!:
let tell = self.on_apply else return
let saved = self.library.presets
let found = saved.position_of(preset_marks.saved_of(mark))
if found >= 0:
tell(saved.name(found), saved.settings(found), mark)
elif preset_marks.start_of(mark) >= 0:
let start = preset_marks.start_of(mark)
tell(recipe.mode_name(start), settings.mode_text(start), mark)
elif preset_marks.look_of(mark) >= 0:
let look = preset_marks.look_of(mark)
tell(looks.name(look), looks.text(look), mark)
## Highlight what the photo shown was last given (its mark), its folder
## opened, or nothing: a highlighted row is always the photo's own, so a
## click on any row shows as a change.
pub func follow(self, mark: str) -> unit!:
let folder = self.folder_of(mark) if mark != "" else 0
if folder != 0 and folder in self.closed:
_ = self.closed.remove(folder)
self.show(mark)
return
let row = self.row_of(mark)
if row != self.rows.selected_index():
self.rows.select(row)
# mark: the menu ===========================================================================
## The menu for the row pressed: a preset's commands and a move into each
## folder; a folder's rename and delete; a start's or look's Apply.
func fit_menu(self) -> unit!:
for connection in self.move_connections:
connection.disconnect()
self.move_connections = []
self.move_commands = []
let row = self.rows.selected_index()
let saved = self.library.presets
if row >= 0 and row < self.row_folders.length and self.row_folders[row] > 0:
self.row_menu.set_commands([self.rename_command, Command("", divider = true), self.delete_command])
return
let at = self.chosen()
if at < 0:
self.row_menu.set_commands([self.apply_command])
return
var commands = [self.apply_command, self.update_command, self.expose_command, self.rename_command, Command("", divider = true)]
for folder in 0..<saved.folder_count():
let id = saved.folder_id(folder)
if id == saved.folder(at):
continue
let move = Command(f"Move to “{saved.folder_name(folder)}”", id = f"preset_move_{id}")
self.move_connections.append(move.on_trigger(func () -> unit!:
self.move_chosen(id)))
self.move_commands.append(move)
commands.append(move)
if saved.folder(at) != 0:
commands.append(self.out_command)
commands = commands + [Command("", divider = true), self.delete_command]
self.row_menu.set_commands(commands)
## Put the chosen preset into folder `folder` (0: none).
func move_chosen(self, folder: int) -> unit!:
let at = self.chosen()
if at < 0:
return
let id = self.library.presets.id(at)
self.library.move_preset(id, folder)
_ = self.closed.remove(folder)
self.show(preset_marks.for_saved(id))
# mark: saving =============================================================================
## The developed photo's settings, or none (and why) without one.
func current_settings(self) -> str?!:
let ask = self.current else return none
if let text = ask():
return text
self.tell("Select a photo whose settings to keep.")
return none
func save_new(self) -> unit!:
let text = self.current_settings() else return
self.pending = text
self.pending_folder = self.chosen_folder()
self.asking = "save"
self.prompt.open("Save the photo’s settings as the preset", self.free_name("Preset", false), accept = "Next")
func new_folder(self) -> unit!:
self.asking = "folder"
self.prompt.open("A folder for presets", self.free_name("Folder", true), accept = "Make")
func update_chosen(self) -> unit!:
let at = self.chosen()
if at < 0:
self.tell("Choose one of your presets to update.")
return
let text = self.current_settings() else return
let name = self.library.presets.name(at)
let id = self.library.save_preset(name, text, self.library.presets.exposed(at))
self.show(preset_marks.for_saved(id))
self.tell(f"Updated “{name}” with the photo’s settings.")
## Rename the chosen preset, or the chosen folder.
func rename_chosen(self) -> unit!:
let saved = self.library.presets
let row = self.rows.selected_index()
if row >= 0 and row < self.row_folders.length and self.row_folders[row] > 0:
self.asking = "rename_folder"
self.renaming = self.row_folders[row]
self.prompt.open("Rename the folder", saved.folder_name(saved.folder_position_of(self.renaming)), accept = "Rename")
return
let at = self.chosen()
if at < 0:
return
self.asking = "rename"
self.renaming = saved.id(at)
self.prompt.open("Rename the preset", saved.name(at), accept = "Rename")
func submitted(self, typed: str) -> unit!:
let name = typed.trim()
let asking = self.asking
self.asking = ""
if name == "":
return
let saved = self.library.presets
if asking == "save":
# Then which parameters the Library mode shows for it.
self.pending_name = name
self.exposing = -1
let known = saved.position_of_name(name)
let shown = saved.exposed(known) if known >= 0 else presets.default_exposed
self.expose.open(f"Save “{name}”: what the Library shows", self.pending, shown)
elif asking == "folder":
let id = self.library.make_preset_folder(name)
self.show()
self.rows.select(self.row_of_folder(id))
elif asking == "rename":
let taken = saved.position_of_name(name)
if taken >= 0 and saved.id(taken) != self.renaming:
self.tell(f"A preset is already named “{name}”.")
return
self.library.rename_preset(self.renaming, name)
self.show(preset_marks.for_saved(self.renaming))
elif asking == "rename_folder":
self.library.rename_preset_folder(self.renaming, name)
self.show()
self.rows.select(self.row_of_folder(self.renaming))
## The parameters the Library shows for the chosen preset: the dialog.
func expose_chosen(self) -> unit!:
let at = self.chosen()
if at < 0:
return
let saved = self.library.presets
self.exposing = saved.id(at)
self.expose.open(f"“{saved.name(at)}”: what the Library shows", saved.settings(at), saved.exposed(at))
## The dialog's OK: a new preset saved, or a preset's parameters changed.
func exposed(self, shown: str) -> unit!:
if self.exposing >= 0:
self.library.set_exposed(self.exposing, shown)
self.show(preset_marks.for_saved(self.exposing))
self.exposing = -1
return
let name = self.pending_name
let replacing = self.library.presets.position_of_name(name) >= 0
let id = self.library.save_preset(name, self.pending, shown, self.pending_folder)
_ = self.closed.remove(self.pending_folder)
self.show(preset_marks.for_saved(id))
self.tell(f"Updated “{name}”." if replacing else f"Saved the preset “{name}”.")
## `base`, else "`base` 2", "`base` 3"…: a name no preset (or, for a
## folder, no folder) has.
func free_name(self, base: str, folder: bool) -> str:
let saved = self.library.presets
var name = base
var number = 2
while (self.folder_named(name) if folder else saved.position_of_name(name) >= 0):
name = f"{base} {number}"
number += 1
return name
func folder_named(self, name: str) -> bool:
let saved = self.library.presets
for at in 0..<saved.folder_count():
if saved.folder_name(at).lower() == name.lower():
return true
return false
# mark: deleting ===========================================================================
## Delete the chosen preset, or the chosen folder (its presets stay, in no folder).
func delete_chosen(self) -> unit!:
let saved = self.library.presets
let row = self.rows.selected_index()
if row >= 0 and row < self.row_folders.length and self.row_folders[row] > 0:
self.deleting = self.row_folders[row]
self.deleting_folder = true
let name = saved.folder_name(saved.folder_position_of(self.deleting))
self.confirm.open(f"Delete the folder “{name}”? Its presets stay, in no folder.", "Delete", "")
return
let at = self.chosen()
if at < 0:
return
self.deleting = saved.id(at)
self.deleting_folder = false
self.confirm.open(f"Delete the preset “{saved.name(at)}”? Photos keep the settings it gave them.", "Delete", "")
func chosen_delete(self, role: int) -> unit!:
let id = self.deleting
self.deleting = -1
if role != 0 or id < 0:
return
if self.deleting_folder:
self.library.delete_preset_folder(id)
else:
self.library.delete_preset(id)
self.show()
func tell(self, text: str) -> unit!:
if let say = self.on_status:
say(text)
pub func close(self):
self.expose.close()
for connection in self.move_connections:
connection.disconnect()
for connection in self.connections:
connection.disconnect()
self.connections.clear()