Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-photo

Source of release 0.1.1

0.1.1 / 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()