User Interface

Alot sets up a widget tree and an mainloop in the constructor of alot.ui.UI. The visible area is a urwid.Frame, where the footer is used as a status line and the body part displays the currently active alot.buffers.Buffer.

To be able to bind keystrokes and translate them to Commands, keypresses are not propagated down the widget tree as is customary in urwid. Instead, the root widget given to urwids mainloop is a custom wrapper (alot.ui.Inputwrap) that interprets key presses. A dedicated SendKeypressCommand can be used to trigger key presses to the wrapped root widget and thereby accessing standard urwid behaviour.

In order to keep the interface non-blocking, alot makes use of twisted’s deferred - a framework that makes it easy to deal with callbacks. Many commands in alot make use of inline callbacks, which allow you to treat deferred-returning functions almost like syncronous functions. Consider the following example of a function that prompts for some input and acts on it:

from twisted.internet import defer

@defer.inlineCallbacks
def greet(ui):  # ui is instance of alot.ui.UI
    name = yield ui.prompt(prefix='pls enter your name>')
    ui.notify('your name is: ' + name)

UI - the main component

class alot.ui.UI(dbman, accountman, initialcmd, colourmode)

This class integrates all components of alot and offers methods for user interaction like prompt(), notify() etc. It handles the urwid widget tree and mainloop (we use twisted) and is responsible for opening, closing and focussing buffers.

Parameters:
  • dbmanDBManager
  • accountmanAccountManager
  • initialcmd (str) – commandline applied after setting up interface
  • colourmode (int in [1,16,256]) – determines which theme to chose
buffers = []

list of active buffers

current_buffer = None

points to currently active Buffer

dbman = None

Database manager (DBManager)

accountman = None

account manager (AccountManager)

apply_command(cmd)

applies a command

This calls the pre and post hooks attached to the command, as well as cmd.apply().

Parameters:cmd (Command) – an applicable command
prompt(prefix='>', text=u'', completer=None, tab=0, history=[])

prompt for text input

Parameters:
  • prefix (str) – text to print before the input field
  • text (str) – initial content of the input field
  • completer (alot.completion.Completer()) – completion object to use
  • tab (int) – number of tabs to press initially (to select completion results)
  • history (list of str) – history to be used for up/down keys
Returns:

a twisted.defer.Deferred

choice(message, choices={'y': 'yes', 'n': 'no'}, select=None, cancel=None, msg_position='above')

prompt user to make a choice

Parameters:
  • message (unicode) – string to display before list of choices
  • choices (dict: keymap->choice (both str)) – dict of possible choices
  • select (str) – choice to return if enter/return is hit. Ignored if set to None.
  • cancel (str) – choice to return if escape is hit. Ignored if set to None.
  • msg_position (str) – determines if message is above or left of the prompt. Must be above or left.
Returns:

a twisted.defer.Deferred

notify(message, priority='normal', timeout=0, block=False)

opens notification popup

Parameters:
  • message (str) – message to print
  • priority (str) – priority string, used to format the popup: currently, ‘normal’ and ‘error’ are defined. If you use ‘X’ here, the attribute ‘global_notify_X’ is used to format the popup.
  • timeout (int) – seconds until message disappears. Defaults to the value of ‘notify_timeout’ in the general config section. A negative value means never time out.
  • block (bool) – this notification blocks until a keypress is made
Returns:

an urwid widget (this notification) that can be handed to clear_notify() for removal

clear_notify(messages)

clears notification popups. Call this to ged rid of messages that don’t time out.

Parameters:messages – The popups to remove. This should be exactly what notify() returned when creating the popup
buffer_open(buf)

register and focus new Buffer.

buffer_focus(buf)

focus given Buffer.

buffer_close(buf)

closes given Buffer.

This it removes it from the bufferlist and calls its cleanup() method.

get_buffers_of_type(t)

returns currently open buffers for a given subclass of alot.buffer.Buffer

Buffers

A buffer defines a view to your data. It knows how to render itself, to interpret keypresses and is visible in the “body” part of the widget frame. Different modes are defined by subclasses of the following base class.

class alot.buffers.Buffer(ui, widget, name)

Abstract base class for buffers.

rebuild()

tells the buffer to (re)construct its visible content.

cleanup()

called before buffer is dismissed

Available modes are:

Mode Buffer Subclass
search SearchBuffer
thread ThreadBuffer
bufferlist BufferlistBuffer
taglist TagListBuffer
envelope EnvelopeBuffer
class alot.buffers.BufferlistBuffer(ui, filtfun=None)

selectable list of active buffers

index_of(b)

returns the index of Buffer b in the global list of active buffers.

get_selected_buffer()

returns currently selected Buffer element from list

class alot.buffers.EnvelopeBuffer(ui, envelope)

message composition mode

toggle_all_headers()

toggles visibility of all envelope headers

class alot.buffers.SearchBuffer(ui, initialquery='', sort_order=None)

shows a result set for a Thread query, one line per Thread

kill_filler_process()

terminates the process that fills this buffers PipeWalker.

get_selected_threadline()

returns curently focussed alot.widgets.ThreadlineWidget from the result list.

get_selected_thread()

returns currently selected Thread

class alot.buffers.ThreadBuffer(ui, thread)

shows a single mailthread as a (collapsible) tree of MessageWidgets.

get_selected_thread()

returns the displayed Thread

get_selection()

returns focussed MessageWidget

get_selected_message()

returns focussed Message

get_message_widgets()

returns all MessageWidgets displayed in this thread-tree.

unfold_matching(querystring)

unfolds those MessageWidgets that represent Messages matching querystring.

class alot.buffers.TagListBuffer(ui, alltags=[], filtfun=None)

selectable list of tagstrings present in the database

get_selected_tag()

returns selected tagstring

Widgets

What follows is a list of the non-standard urwid widgets used in alot. Some of them respect user settings, themes in particular.

Completion

alot.ui.UI.prompt() allows tab completion using a Completer object handed as ‘completer’ parameter. alot.completion defines several subclasses for different occasions like completing email addresses from an AddressBook, notmuch tagstrings. Some of these actually build on top of each other; the QueryCompleter for example uses a TagsCompleter internally to allow tagstring completion after “is:” or “tag:” keywords when typing a notmuch querystring.

All these classes overide the method complete, which for a given string and cursor position in that string returns a list of tuples (completed_string, new_cursor_position) that are taken to be the completed values. Note that completed_string does not need to have the original string as prefix.

class alot.completion.Completer

base class for completers

complete(original, pos)

returns a list of completions and cursor positions for the string original from position pos on.

Parameters:
  • original (str) – the string to complete
  • pos (int) – starting position to complete from
Returns:

pairs of completed string and cursor position in the new string

Return type:

list of (str, int)

relevant_part(original, pos, sep=' ')

calculates the subword in a sep-splitted list of substrings of original that pos is ia.n

class alot.completion.StringlistCompleter(resultlist)

completer for a fixed list of strings

Parameters:resultlist – strings used for completion
class alot.completion.MultipleSelectionCompleter(completer, separator=', ')

Meta-Completer that turns any Completer into one that deals with a list of completion strings using the wrapped Completer. This allows for example to easily construct a completer for comma separated recipient-lists using a ContactsCompleter.

Parameters:
  • completer (Completer) – completer to use for individual substrings
  • separator (str) – separator used to split the completion string into substrings to be fed to completer.
relevant_part(original, pos)

calculates the subword of original that pos is in

class alot.completion.QueryCompleter(dbman, accountman)

completion for a notmuch query string

Parameters:
  • dbman (DBManager) – used to look up avaliable tagstrings
  • accountman (AccountManager) – used to look up known addresses to complete ‘from’ and ‘to’ queries
class alot.completion.TagCompleter(dbman)

complete a tagstring

Parameters:dbman (DBManager) – used to look up avaliable tagstrings
class alot.completion.TagsCompleter(dbman)

completion for a comma separated list of tagstrings

Parameters:dbman (DBManager) – used to look up avaliable tagstrings
class alot.completion.ContactsCompleter(abooks, addressesonly=False)

completes contacts from given address books

Parameters:
  • abooks (list of AddresBook) – used to look up email addresses
  • addressesonly (bool) – only insert address, not the realname of the contact
class alot.completion.AbooksCompleter(abooks, addressesonly=False)

completes a contact from given address books

Parameters:
  • abooks (list of AddresBook) – used to look up email addresses
  • addressesonly (bool) – only insert address, not the realname of the contact
class alot.completion.AccountCompleter(accountman)

completes users’ own mailaddresses

Parameters:accountman (AccountManager) – used to look up the list of addresses
class alot.completion.CommandCompleter(mode)

completes commands

Parameters:mode (str) – mode identifier
class alot.completion.CommandLineCompleter(dbman, accountman, mode, currentbuffer=None)

completion for commandline

Parameters:
  • dbman (DBManager) – used to look up avaliable tagstrings
  • accountman (AccountManager) – used to look up known addresses to complete ‘from’ and ‘to’ queries
  • mode (str) – mode identifier
  • currentbuffer (Buffer) – currently active buffer. If defined, this will be used to dynamically extract possible completion strings
class alot.completion.PathCompleter

completion for paths

Project Versions

Table Of Contents

Previous topic

Email Database

Next topic

Accessing User Settings