dymokomi/luced-message
Source of release 0.5.0
## 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()