Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-message

Source of release 0.5.0

0.5.0 / src / panels.luc

## The window: a toolbar of square icon buttons over three docked panes, Mailboxes,
## Messages and Message, as Apple Mail lays them out, with a status line below. The
## panels hold the sources and carry what happens between them: picking a folder fills
## the list, picking a message fills the reader (asking its source for the body when
## it is not stored yet), and each source's events refresh what they touch.
from luce_ui.ui import VStack, HStack, Text, TextField, Font, Button, Spacer, DStack, Panel, DockPosition, Size, Application, Menu, CommandPalette, Command
from interop import Connection
from actions import Actions
from accounts import Account, AccountStore, home
from sources import Source, EmailSource, SourceEvent, seen_flag, flagged_flag, deleted_flag
from sidebar import Sidebar
from message_list import MessageList
from reader import Reader
from composer import Composer
from account_dialog import AccountDialog
from luce_std import paths
import mail_index
import mail_store
import mail_db
from luce_prism import prism
from luce_mime import mime

pub class Panels:
    pub let body: VStack
    pub let actions: Actions
    pub let sidebar: Sidebar
    pub let messages: MessageList
    pub let reader: Reader
    pub let composer: Composer
    pub let account_dialog: AccountDialog
    pub let dock: DStack
    let status: Text
    let search: TextField
    let palette: CommandPalette
    let store: AccountStore
    ## The mail database every account's engine writes and the window reads.
    let mail: prism.Store
    let directory: str
    var connections: list[Connection] = []
    pub var sources: list[Source] = []
    var accounts: list[Account] = []
    ## The folder shown: its source's position and its path.
    var source: int = -1
    var folder: str = ""
    pub var app: Application? = none

    pub func init(self, font: Font, directory: str = "") -> unit!:
        self.directory = directory if directory != "" else home()
        self.store = AccountStore(self.directory)
        mail_store.ensure_path(self.directory)
        self.mail = prism.Store.open(paths.join(self.directory, "mail.prism"))
        self.actions = Actions()
        self.sidebar = Sidebar(font)
        self.messages = MessageList(font)
        self.reader = Reader(font)
        self.composer = Composer(font)
        self.account_dialog = AccountDialog(font)
        self.status = Text("", font = font, muted = true)
        self.search = TextField("", font = font, placeholder = "Search", cells = 22.0)
        self.palette = CommandPalette(self.actions.all, font = font)
        self.sidebar.on_pick = self.show_folder
        self.messages.on_pick = self.show_message
        self.composer.on_status = self.tell
        self.account_dialog.on_save = self.save_accounts
        self.account_dialog.on_remove = self.remove_account
        self.connections.append(self.search.on_change(func (text: str) -> unit!:
            self.messages.set_matches(none)
            self.messages.set_filter(text)))
        # Enter searches the whole text of the folder's messages on the server.
        self.connections.append(self.search.on_commit(self.search_server))
        self.bind_actions()
        # The toolbar: square icon buttons, grouped as Mail groups them.
        let toolbar = HStack([Text("LUCED MESSAGE", font = font),
                              self.tool(font, "get-mail", self.actions.get_mail), self.tool(font, "compose", self.actions.compose),
                              self.gap(), self.tool(font, "reply", self.actions.reply), self.tool(font, "reply-all", self.actions.reply_all),
                              self.tool(font, "forward", self.actions.forward), self.gap(),
                              self.tool(font, "archive", self.actions.archive), self.tool(font, "trash", self.actions.delete),
                              self.tool(font, "junk", self.actions.junk), self.gap(), self.tool(font, "flag", self.actions.flag),
                              self.tool(font, "mail-unread", self.actions.mark_unread), Spacer(),
                              Menu("Mailbox", [self.actions.get_mail, self.actions.compose, self.actions.accounts], font = font),
                              Menu("View", [self.actions.organize], font = font),
                              Menu("Window", [self.actions.palette, self.actions.reset_layout], font = font),
                              self.search], spacing = 4.0, padding = 4.0)
        let mailboxes = Panel("Mailboxes", self.sidebar.view, minimum = Size(180.0, 200.0), closable = false, id = "mailboxes")
        let messages_panel = Panel("Messages", self.messages.table, minimum = Size(320.0, 200.0), closable = false, id = "messages")
        let message = Panel("Message", self.reader.body, minimum = Size(360.0, 200.0), closable = false, id = "message")
        self.dock = DStack([messages_panel], font = font)
        self.dock.add(mailboxes, messages_panel, DockPosition.left)
        self.dock.set_fraction(mailboxes, 0.2)
        self.dock.add(message, messages_panel, DockPosition.right)
        self.dock.set_fraction(messages_panel, 0.45)
        self.dock.layout().set_flex()
        let footer = HStack([self.status], padding = 6.0)
        self.body = VStack([toolbar, self.dock, footer, self.composer.dialog, self.account_dialog.dialog, self.palette], spacing = 0.0)
        self.body.layout().set_flex()
        self.actions.refresh(false)
        self.start_sources()

    func tool(self, font: Font, icon: str, command: Command) -> Button!:
        let button = Button(icon = icon, font = font)
        self.connections.append(button.on_click(func () -> unit!:
            command.trigger()))
        return button

    func gap(self) -> Spacer!:
        let spacer = Spacer()
        spacer.layout().set_limits(Size(10.0, 0.0), Size(10.0, 0.0))
        return spacer

    func bind_actions(self) -> unit!:
        let actions = self.actions
        self.connections.append(actions.get_mail.on_trigger(self.get_mail))
        self.connections.append(actions.compose.on_trigger(self.compose))
        self.connections.append(actions.reply.on_trigger(func () -> unit!:
            self.reply(false)))
        self.connections.append(actions.reply_all.on_trigger(func () -> unit!:
            self.reply(true)))
        self.connections.append(actions.forward.on_trigger(self.forward))
        self.connections.append(actions.delete.on_trigger(self.delete))
        self.connections.append(actions.delete_back.on_trigger(self.delete))
        self.connections.append(actions.archive.on_trigger(func () -> unit!:
            self.file_to("archive")))
        self.connections.append(actions.junk.on_trigger(func () -> unit!:
            self.file_to("junk")))
        self.connections.append(actions.flag.on_trigger(self.toggle_flag))
        self.connections.append(actions.mark_unread.on_trigger(self.mark_unread))
        self.connections.append(actions.accounts.on_trigger(func () -> unit!:
            self.account_dialog.open(self.accounts)))
        self.connections.append(actions.organize.on_trigger(func () -> unit!:
            self.messages.set_threaded(not self.messages.threaded)
            actions.organize.set_text("Organize by Conversation ✓" if self.messages.threaded else "Organize by Conversation")))
        self.connections.append(actions.palette.on_trigger(func () -> unit!:
            self.palette.open()))
        self.connections.append(actions.quit.on_trigger(func () -> unit!:
            if let app = self.app:
                app.stop()))

    ## Search the whole text of the folder's messages on the server; the list narrows
    ## when the "found" event comes back. Empty text shows every message again.
    pub func search_server(self, text: str) -> unit!:
        if text.trim() == "":
            self.messages.set_matches(none)
            return
        if let source = self.current():
            source.search(self.folder, text.trim())

    # mark: sources ==============================================================================

    ## Start a source for every account; ask for one when there are none.
    func start_sources(self) -> unit!:
        self.accounts = self.store.load()
        if self.store.warning != "":
            self.tell(self.store.warning)
        for account in self.accounts:
            self.sources.append(EmailSource(account, self.mail))
        self.sidebar.refresh(self.sources)
        if self.sources.length == 0:
            self.tell("No accounts yet: Mailbox › Accounts… adds one.")
        else:
            self.sidebar.pick(0, "")

    ## Forget a removed account: its password, then, once its source has stopped, the
    ## mail stored for it, so adding the address again starts afresh.
    func remove_account(self, accounts: list[Account], id: str) -> unit!:
        self.store.forget(id) catch failure:
            self.tell(f"The keychain kept the password: {failure.message}")
        self.save_accounts(accounts)
        mail_db.forget_account(self.mail, id) catch failure:
            self.tell(f"The stored mail was not removed: {failure.message}")

    ## Save the accounts and restart every source with them.
    func save_accounts(self, accounts: list[Account]) -> unit!:
        self.store.save(accounts)
        for source in self.sources:
            source.close()
        self.sources = []
        self.source = -1
        self.folder = ""
        self.messages.clear()
        self.reader.clear()
        self.start_sources()

    func current(self) -> Source?:
        if self.source < 0 or self.source >= self.sources.length:
            return none
        return self.sources[self.source]

    ## Take in every source's events; called every frame.
    pub func poll(self) -> unit!:
        self.sidebar.poll()
        self.messages.poll()
        for (position, source) in self.sources.indexed():
            let events = source.poll() catch failure:
                self.tell(failure.message)
                recover []
            for event in events:
                self.apply(position, source, event)

    func apply(self, position: int, source: Source, event: SourceEvent) -> unit!:
        match event.kind:
            "folders":
                self.sidebar.refresh(self.sources)
                if self.source < 0:
                    self.sidebar.pick(position, "")
            "folder":
                if position == self.source and event.folder == self.folder:
                    self.messages.show(source.messages(self.folder))
            "body":
                if let shown = self.reader.shown:
                    if shown.source == position and shown.folder == event.folder:
                        # The message on its way, or an earlier one of its conversation.
                        if (shown.uid == event.uid and not shown.loaded) or (shown.waiting > 0 and event.uid in shown.members):
                            self.show_message(shown.uid)
            "status":
                self.tell(f"{source.title()}: {event.text}" if event.text != "" else "")
            "online":
                self.tell(f"{source.title()}: connected")
            "offline":
                self.tell(f"{source.title()}: offline — {event.text}")
            "sent":
                self.tell("Message sent.")
            "unsent":
                self.tell(f"Not sent: {event.text}")
            "found":
                if position == self.source and event.folder == self.folder:
                    var uids: set[int] = {}
                    for part in event.text.split(","):
                        if ":" in part:
                            let ends = part.split(":")
                            for uid in int(ends[0])..=int(ends[1]):
                                uids.insert(uid)
                        elif part != "":
                            uids.insert(int(part))
                    self.messages.set_filter("")
                    self.messages.set_matches(uids)
                    self.tell(f"{uids.length} message(s) match.")
            "saved":
                self.tell("Draft saved.")
            "unsaved":
                self.tell(f"Draft not saved: {event.text}")
            _:
                if event.text != "":
                    self.tell(event.text)

    pub func tell(self, text: str) -> unit!:
        self.status.set_text(text)

    # mark: picking ==============================================================================

    func show_folder(self, source: int, folder: str) -> unit!:
        self.source = source
        self.folder = folder
        let shown = self.current() else return
        self.reader.clear()
        self.messages.show(shown.messages(folder))

    ## Show the picked message, or its whole conversation, fetching what is not stored.
    func show_message(self, uid: int) -> unit!:
        self.actions.refresh(uid >= 0)
        let source = self.current() else return
        if uid < 0:
            self.reader.clear()
            return
        let count = self.messages.picked_count()
        if count > 1:
            self.reader.many(count, "conversations" if self.messages.threaded else "messages")
            return
        let message = source.message(self.folder, uid)
        if message == none:
            self.reader.loading(self.source, self.folder, uid)
            source.fetch(self.folder, uid)
            return
        let shown = message else return
        let members = self.messages.shown_uids()
        var earlier: list[mime.Message?] = []
        for member in members:
            if member == uid:
                continue
            let other = source.message(self.folder, member)
            if other == none:
                source.fetch(self.folder, member)
            earlier.append(other)
        self.reader.show(self.source, self.folder, uid, shown, members, earlier)
        if self.messages.picked_unread():
            source.set_flags(self.folder, members, true, seen_flag)

    # mark: actions ==============================================================================

    func get_mail(self) -> unit!:
        for source in self.sources:
            source.refresh()
        self.tell("Checking for mail…")

    ## A new message from the account shown, or the first one when no folder is
    ## picked yet (an account still offline has none).
    func compose(self) -> unit!:
        if self.sources.length == 0:
            self.tell("Add an account first: Mailbox › Accounts…")
            return
        self.tell("")
        self.composer.compose(self.current() else self.sources[0])

    func reply(self, all: bool) -> unit!:
        let source = self.current() else return
        let shown = self.reader.shown else return
        if not shown.loaded:
            return
        self.composer.reply(source, shown, all)

    func forward(self) -> unit!:
        let source = self.current() else return
        let shown = self.reader.shown else return
        if not shown.loaded:
            return
        self.composer.forward(source, shown)

    ## Move the selected conversations to Trash, or mark them deleted when there is no Trash.
    func delete(self) -> unit!:
        let source = self.current() else return
        let uids = self.messages.picked_uids()
        if uids.length == 0:
            return
        self.messages.pick_next()
        if not source.move_to(self.folder, uids, "trash"):
            source.set_flags(self.folder, uids, true, deleted_flag)

    ## Move the selected conversations to the folder with `role` (archive, junk).
    func file_to(self, role: str) -> unit!:
        let source = self.current() else return
        let uids = self.messages.picked_uids()
        if uids.length == 0:
            return
        self.messages.pick_next()
        if not source.move_to(self.folder, uids, role):
            self.tell(f"This account has no {role} folder.")

    ## Flag each selected conversation's newest message, or, when the picked one is
    ## flagged, clear the flag from every message of the selection.
    func toggle_flag(self) -> unit!:
        let source = self.current() else return
        if self.messages.picked_uid() < 0:
            return
        if mail_index.has(self.messages.picked_flags(), flagged_flag):
            source.set_flags(self.folder, self.messages.picked_uids(), false, flagged_flag)
        else:
            source.set_flags(self.folder, self.messages.picked_leads(), true, flagged_flag)

    ## Mark each selected conversation's newest message unread.
    func mark_unread(self) -> unit!:
        let source = self.current() else return
        let uids = self.messages.picked_leads()
        if uids.length == 0:
            return
        source.set_flags(self.folder, uids, false, seen_flag)

    pub func close(self):
        for source in self.sources:
            source.close()
        # Every engine has stopped; the database goes last.
        self.mail.close()
        for connection in self.connections:
            connection.disconnect()
        self.connections.clear()