Release v0.0.8 (fix cargo publish issues) (#134)

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: ulyssam

.github/workflows/ci.yml

@@ -9,25 +9,6 @@ on:
 name: CI
 
 jobs:
-  clippy_check:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v3
-      with:
-        submodules: true
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
-      with:
-          toolchain: stable
-          components: clippy
-          override: true
-    - name: Check Clippy
-      uses: actions-rs/clippy-check@v1
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-        toolchain: stable
-        args:
   test:
     strategy:
       matrix:
@@ -38,23 +19,38 @@ jobs:
       uses: actions/checkout@v3
       with:
         submodules: true
-    - name: Install Rust
-      uses: actions-rs/toolchain@v1
+    - name: Install Rust (1.66 w/ clippy)
+      uses: dtolnay/rust-toolchain@1.66
       with:
-          toolchain: nightly
-          override: true
-          components: rustfmt, clippy
+          components: clippy
+    - name: Install Rust (nightly w/ rustfmt)
+      run: rustup toolchain install nightly --component rustfmt
     - name: Cache cargo registry
       uses: actions/cache@v3
       with:
         path: ~/.cargo/registry
         key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+    - name: Cache cargo build
+      uses: actions/cache@v3
+      with:
+        path: target
+        key: ${{ runner.os }}-cargo-build-${{ hashFiles('**/Cargo.lock') }}
     - name: Check formatting
-      uses: actions-rs/cargo@v1
+      run: cargo +nightly fmt --all -- --check
+    - name: Check Clippy
+      if: matrix.platform == 'ubuntu-latest'
+      uses: giraffate/clippy-action@v1
       with:
-          command: fmt
-          args: --all -- --check
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        reporter: 'github-check'
     - name: Run tests
-      uses: actions-rs/cargo@v1
+      run: cargo test
+    - name: Build artifacts
+      run: cargo build --release
+    - name: Upload artifacts
+      uses: actions/upload-artifact@master
       with:
-          command: test
+        name: iamb-${{ matrix.platform }}
+        path: |
+          ./target/release/iamb
+          ./target/release/iamb.exe

.gitignore

@@ -1,2 +1,4 @@
 /target
+/result
 /TODO
+/docs/iamb.[15]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "iamb"
-version = "0.0.7"
+version = "0.0.8"
 edition = "2018"
 authors = ["Ulyssa <git@ulyssa.dev>"]
 repository = "https://github.com/ulyssa/iamb"
@@ -12,16 +12,30 @@ exclude = [".github", "CONTRIBUTING.md"]
 keywords = ["matrix", "chat", "tui", "vim"]
 categories = ["command-line-utilities"]
 rust-version = "1.66"
+build = "build.rs"
+
+[build-dependencies]
+mandown = "0.1.3"
+
+[build-dependencies.vergen]
+version = "8"
+default-features = false
+features = ["build", "git", "gitcl",]
 
 [dependencies]
+arboard = "3.2.0"
 bitflags = "1.3.2"
 chrono = "0.4"
 clap = {version = "4.0", features = ["derive"]}
+comrak = {version = "0.18.0", features = ["shortcodes"]}
 css-color-parser = "0.1.2"
 dirs = "4.0.0"
 emojis = "~0.5.2"
+futures = "0.3"
 gethostname = "0.4.1"
 html5ever = "0.26.0"
+image = "0.24.5"
+libc = "0.2"
 markup5ever_rcdom = "0.2.0"
 mime = "^0.3.16"
 mime_guess = "^2.0.4"
@@ -39,12 +53,12 @@ unicode-width = "0.1.10"
 url = {version = "^2.2.2", features = ["serde"]}
 
 [dependencies.modalkit]
-version = "0.0.14"
+version = "0.0.16"
 
 [dependencies.matrix-sdk]
 version = "0.6"
 default-features = false
-features = ["e2e-encryption", "markdown", "sled", "rustls-tls"]
+features = ["e2e-encryption", "sled", "rustls-tls"]
 
 [dependencies.tokio]
 version = "1.24.1"
@@ -52,6 +66,7 @@ features = ["macros", "net", "rt-multi-thread", "sync", "time"]
 
 [dev-dependencies]
 lazy_static = "1.4.0"
+pretty_assertions = "1.4.0"
 
 [profile.release]
 lto = true

README.md

@@ -21,7 +21,7 @@ website, [iamb.chat].
 
 ## Installation
 
-Install Rust and Cargo, and then run:
+Install Rust (1.66.0 or above) and Cargo, and then run:
 
 ```
 cargo install --locked iamb
@@ -37,12 +37,19 @@ pkgin install iamb
 
 ### Arch Linux
 
-On Arch Linux a package is available in the Arch User Repositories (AUR). To install it simply run with your favorite AUR helper:
+On Arch Linux a [package](https://aur.archlinux.org/packages/iamb-git) is available in the
+Arch User Repositories (AUR). To install it simply run with your favorite AUR helper:
 
 ```
 paru iamb-git
 ```
 
+### Nix / NixOS (flake)
+
+```
+nix profile install "github:ulyssa/iamb"
+```
+
 ## Configuration
 
 You can create a basic configuration in `$CONFIG_DIR/iamb/config.json` that looks like:

build.rs

@@ -0,0 +1,29 @@
+use std::error::Error;
+use std::fs;
+use std::iter::FromIterator;
+use std::path::PathBuf;
+
+use mandown::convert;
+use vergen::EmitBuilder;
+
+const IAMB_1_MD: &str = include_str!("docs/iamb.1.md");
+const IAMB_5_MD: &str = include_str!("docs/iamb.5.md");
+
+fn main() -> Result<(), Box<dyn Error>> {
+    EmitBuilder::builder().git_sha(true).emit()?;
+
+    // Build the manual pages.
+    println!("cargo:rerun-if-changed=docs/iamb.1.md");
+    println!("cargo:rerun-if-changed=docs/iamb.5.md");
+
+    let iamb_1 = convert(IAMB_1_MD, "IAMB", 1);
+    let iamb_5 = convert(IAMB_5_MD, "IAMB", 5);
+
+    let out_dir = std::env::var("OUT_DIR");
+    let out_dir = out_dir.as_deref().unwrap_or("docs");
+
+    fs::write(PathBuf::from_iter([out_dir, "iamb.1"]), iamb_1.as_bytes())?;
+    fs::write(PathBuf::from_iter([out_dir, "iamb.5"]), iamb_5.as_bytes())?;
+
+    Ok(())
+}

docs/example_config.json

@@ -0,0 +1,32 @@
+{
+	"default_profile": "default",
+	"profiles": {
+		"default": {
+			"user_id":  "",
+			"url":      "https://matrix.org",
+			"settings": {},
+			"dirs":     {}
+		}
+	},
+	"settings": {
+		"log_level":                  "warn",
+		"reaction_display":           true,
+		"reaction_shortcode_display": false,
+		"read_receipt_send":          true,
+		"read_receipt_display":       true,
+		"request_timeout":            10000,
+		"typing_notice_send":         true,
+		"typing_notice_display":      true,
+		"users": {
+			"@user:matrix.org": {
+				"name":  "John Doe",
+				"color": "magenta"
+			}
+		},
+		"default_room": "#iamb-users:0x.badd.cafe"
+	},
+	"dirs": {
+		"cache":     "~/.cache/iamb/",
+		"logs":      "~/.local/share/iamb/logs/",
+		"downloads": "~/Downloads/"
+	}

docs/iamb.1.md

@@ -0,0 +1,29 @@
+# NAME
+
+iamb – a terminal-based client for Matrix for the Vim addict
+
+# SYNOPSIS
+
+**iamb** [**--profile** _profile_] [**--config-directory** _directory_] [**--help** | **--version**]
+
+# OPTIONS
+
+These options are primitives at the top-level of the file.
+
+**--profile**, **-P**
+> The profile to start with. Overrides **default_profile** from **iamb(5)**.
+
+**--config-directory**, **-C**
+> Path to the directory the configuration file is located in.
+
+**--help**, **-h**
+> Show a short help text and quit.
+
+**--version**, **-V**
+> Show the iamb version and quit.
+
+# SEE ALSO
+
+**iamb(5)**
+
+Full documentation is available online at \<https://iamb.chat\>

docs/iamb.5.md

@@ -0,0 +1,134 @@
+# NAME
+
+config.json – configuration file for iamb
+
+# SYNOPSIS
+
+Configuration must be placed under _~/.config/iamb/_ and is named config.json.
+
+Example configuration usually comes bundled with your installation and can
+typically be found in _/usr/share/iamb_.
+
+As implied by the filename, the configuration is formatted in JSON. It's
+structure and fields are described below.
+
+# BASIC SETTINGS
+
+These options are primitives at the top-level of the file.
+
+**default_profile** (type: string)
+> The default profile to connect to, unless overwritten by a commandline
+> switch. It has to be defined in the *PROFILES* section.
+
+# PROFILES
+
+These options are configured as a map under the profiles name.
+
+**user_id** (type: string)
+> The user ID to use when connecting to the server. For example "user" for
+> "@user:matrix.org".
+
+**url** (type: string)
+> The URL of the users server. For example "https://matrix.org" for
+> "@user:matrix.org".
+
+**settings** (type: settings object)
+> Overwrite general settings for this account. The fields are identical to
+> those in *TUNABLES*.
+
+**layout** (type: startup layout object)
+> Overwrite general settings for this account. The fields are identical to
+> those in *STARTUP LAYOUT*.
+
+**dirs** (type: XDG overrides object)
+> Overwrite general settings for this account. The fields are identical to
+> those in *DIRECTORIES*.
+
+# TUNABLES
+
+These options are configured as a map under the *settings* key and can be
+overridden as described in *PROFILES*.
+
+**log_level** (type: string)
+> Specifies the lowest log level that should be shown. Possible values
+> are: _trace_, _debug_, _info_, _warn_, and _error_.
+
+**reaction_display** (type: boolean)
+> Defines whether or not reactions should be shown.
+
+**reaction_shortcode_display** (type: boolean)
+> Defines whether or not reactions should be shown as their respective
+> shortcode.
+
+**read_receipt_send** (type: boolean)
+> Defines whether or not read confirmations are sent.
+
+**read_receipt_display** (type: boolean)
+> Defines whether or not read confirmations are displayed.
+
+**request_timeout** (type: uint64)
+> Defines the maximum time per request in seconds.
+
+**typing_notice_send** (type: boolean)
+> Defines whether or not the typing state is sent.
+
+**typing_notice_display** (type: boolean)
+> Defines whether or not the typing state is displayed.
+
+**user** (type: map)
+> Overrides values for the specified user. See *USER OVERRIDES* for
+> details on the format.
+
+**default_room** (type: string)
+> The room to show by default instead of a welcome-screen.
+
+## USER OVERRIDES
+
+Overrides are mapped onto matrix User IDs such as _@user:matrix.org_ and are
+maps containing the following key value pairs.
+
+**name** (type: string)
+> Change the display name of the user.
+
+**color** (type: string)
+> Change the color the user is shown as. Possible values are: _black_,
+> _blue_, _cyan_, _dark-gray_, _gray_, _green_, _light-blue_,
+> _light-cyan_, _light-green_, _light-magenta_, _light-red_,
+> _light-yellow_, _magenta_, _none_, _red_, _white_, _yellow_
+
+# STARTUP LAYOUT
+
+Specifies what initial set of tabs and windows to show when starting the
+client. Configured as an object under the key *layout*.
+
+**style** (type: string)
+> Specifies what window layout to load when starting. Valid values are
+> _restore_ to restore the layout from the last time the client was exited,
+> _new_ to open a single window (uses the value of _default\_room_ if set), or
+> _config_ to open the layout described under _tabs_.
+
+**tabs** (type: array of window objects)
+> If **style** is set to _config_, then this value will be used to open a set
+> of tabs and windows at startup. Each object can contain either a **window**
+> key specifying a username, room identifier or room alias to show, or a
+> **split** key specifying an array of window objects.
+
+# DIRECTORIES
+
+Specifies the directories to save data in. Configured as a map under the key
+*dirs*.
+
+**cache** (type: string)
+> Specifies where to store assets and temporary data in.
+
+**logs** (type: string)
+> Specifies where to store log files.
+
+**downloads** (type: string)
+> Specifies where to store downloaded files.
+
+# SEE ALSO
+
+*iamb(1)*
+
+Full documentation is available online at \<https://iamb.chat\>

flake.lock

@@ -0,0 +1,94 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1678901627,
+        "narHash": "sha256-U02riOqrKKzwjsxc/400XnElV+UtPUQWpANPlyazjH0=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "93a2b84fc4b70d9e089d029deacc3583435c2ed6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "locked": {
+        "lastModified": 1659877975,
+        "narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1679437018,
+        "narHash": "sha256-vOuiDPLHSEo/7NkiWtxpHpHgoXoNmrm+wkXZ6a072Fc=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "19cf008bb18e47b6e3b4e16e32a9a4bdd4b45f7e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1665296151,
+        "narHash": "sha256-uOB0oxqxN9K7XGF1hcnY+PQnlQJ+3bP2vCn/+Ru/bbc=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "14ccaaedd95a488dd7ae142757884d8e125b3363",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "flake-utils": "flake-utils_2",
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1679624450,
+        "narHash": "sha256-wiDqUaklmc31E1+wz5sv52sMcWvZKsL1FBeGJCxz628=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "afbdcf305fd6f05f708fe76d52f24d37d066c251",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,40 @@
+{
+  description = "iamb";
+  nixConfig.bash-prompt = "\[nix-develop\]$ ";
+
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+    rust-overlay.url = "github:oxalica/rust-overlay";
+  };
+
+  outputs = { self, nixpkgs, flake-utils, rust-overlay, ... }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        # We only need the nightly overlay in the devShell because .rs files are formatted with nightly.
+        overlays = [ (import rust-overlay) ];
+        pkgs = import nixpkgs { inherit system overlays; };
+        rustNightly = pkgs.rust-bin.nightly."2023-03-17".default;
+      in 
+      with pkgs;
+      {
+        packages.default = pkgs.rustPlatform.buildRustPackage {
+          pname = "iamb";
+          version = "0.0.7";
+          src = ./.;
+          cargoLock.lockFile = ./Cargo.lock;
+          nativeBuildInputs = [ pkgs.pkgconfig ];
+          buildInputs = [ pkgs.openssl ] ++ pkgs.lib.optionals pkgs.stdenv.isDarwin
+            (with pkgs.darwin.apple_sdk.frameworks; [ AppKit Security ]);
+        };
+        devShell = mkShell {
+          buildInputs = [
+            (rustNightly.override { extensions = [ "rust-src" ]; })
+            pkg-config
+            cargo-tarpaulin
+            rust-analyzer
+            rustfmt
+          ];
+        };
+      });
+}

src/base.rs

@@ -1,16 +1,27 @@
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
+use std::convert::TryFrom;
+use std::fmt::{self, Display};
 use std::hash::Hash;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use emojis::Emoji;
+use serde::{
+    de::Error as SerdeError,
+    de::Visitor,
+    Deserialize,
+    Deserializer,
+    Serialize,
+    Serializer,
+};
 use tokio::sync::Mutex as AsyncMutex;
+use url::Url;
 
 use matrix_sdk::{
     encryption::verification::SasVerification,
-    room::Joined,
+    room::{Joined, Room as MatrixRoom},
     ruma::{
         events::{
             reaction::ReactionEvent,
@@ -103,7 +114,9 @@ pub enum VerifyAction {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum MessageAction {
     /// Cance the current reply or edit.
-    Cancel,
+    ///
+    /// The [bool] argument indicates whether to skip confirmation for clearing the message bar.
+    Cancel(bool),
 
     /// Download an attachment to the given path.
     ///
@@ -118,7 +131,9 @@ pub enum MessageAction {
     React(String),
 
     /// Redact a message, with an optional reason.
-    Redact(Option<String>),
+    ///
+    /// The [bool] argument indicates whether to skip confirmation.
+    Redact(Option<String>, bool),
 
     /// Reply to a message.
     Reply,
@@ -178,6 +193,7 @@ pub enum RoomAction {
     InviteAccept,
     InviteReject,
     InviteSend(OwnedUserId),
+    Leave(bool),
     Members(Box<CommandContext<ProgramContext>>),
     Set(RoomField, String),
     Unset(RoomField),
@@ -187,6 +203,7 @@ pub enum RoomAction {
 pub enum SendAction {
     Submit,
     Upload(String),
+    UploadImage(usize, usize, Cow<'static, [u8]>),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -332,6 +349,9 @@ pub enum IambError {
     #[error("Serialization/deserialization error: {0}")]
     Serde(#[from] serde_json::Error),
 
+    #[error("No download directory configured")]
+    NoDownloadDir,
+
     #[error("Selected message does not have any attachments")]
     NoAttachment,
 
@@ -355,6 +375,12 @@ pub enum IambError {
 
     #[error("Verification request error: {0}")]
     VerificationRequestError(#[from] matrix_sdk::encryption::identities::RequestVerificationError),
+
+    #[error("Image error: {0}")]
+    Image(#[from] image::ImageError),
+
+    #[error("Could not use system clipboard data")]
+    Clipboard,
 }
 
 impl From<IambError> for UIError<IambInfo> {
@@ -422,6 +448,9 @@ pub struct RoomInfo {
 
     /// Users currently typing in this room, and when we received notification of them doing so.
     pub users_typing: Option<(Instant, Vec<OwnedUserId>)>,
+
+    /// The display names for users in this room.
+    pub display_names: HashMap<OwnedUserId, String>,
 }
 
 impl RoomInfo {
@@ -443,8 +472,12 @@ impl RoomInfo {
         }
     }
 
+    pub fn get_message_key(&self, event_id: &EventId) -> Option<&MessageKey> {
+        self.keys.get(event_id)?.to_message_key()
+    }
+
     pub fn get_event(&self, event_id: &EventId) -> Option<&Message> {
-        self.messages.get(self.keys.get(event_id)?.to_message_key()?)
+        self.messages.get(self.get_message_key(event_id)?)
     }
 
     pub fn insert_reaction(&mut self, react: ReactionEvent) {
@@ -486,10 +519,10 @@ impl RoomInfo {
 
         match &mut msg.event {
             MessageEvent::Original(orig) => {
-                orig.content = *new_content;
+                orig.content.msgtype = new_content.msgtype;
             },
             MessageEvent::Local(_, content) => {
-                *content = new_content;
+                content.msgtype = new_content.msgtype;
             },
             MessageEvent::Redacted(_) |
             MessageEvent::EncryptedOriginal(_) |
@@ -556,13 +589,13 @@ impl RoomInfo {
         match n {
             0 => Spans(vec![]),
             1 => {
-                let user = settings.get_user_span(typers[0].as_ref());
+                let user = settings.get_user_span(typers[0].as_ref(), self);
 
                 Spans(vec![user, Span::from(" is typing...")])
             },
             2 => {
-                let user1 = settings.get_user_span(typers[0].as_ref());
-                let user2 = settings.get_user_span(typers[1].as_ref());
+                let user1 = settings.get_user_span(typers[0].as_ref(), self);
+                let user2 = settings.get_user_span(typers[1].as_ref(), self);
 
                 Spans(vec![
                     user1,
@@ -617,6 +650,13 @@ fn emoji_map() -> CompletionMap<String, &'static Emoji> {
     return emojis;
 }
 
+#[derive(Default)]
+pub struct SyncInfo {
+    pub spaces: Vec<MatrixRoom>,
+    pub rooms: Vec<Arc<(MatrixRoom, Option<Tags>)>>,
+    pub dms: Vec<Arc<(MatrixRoom, Option<Tags>)>>,
+}
+
 pub struct ChatStore {
     pub cmds: ProgramCommands,
     pub worker: Requester,
@@ -627,6 +667,7 @@ pub struct ChatStore {
     pub settings: ApplicationSettings,
     pub need_load: HashSet<OwnedRoomId>,
     pub emojis: CompletionMap<String, &'static Emoji>,
+    pub sync_info: SyncInfo,
 }
 
 impl ChatStore {
@@ -636,12 +677,14 @@ impl ChatStore {
             settings,
 
             cmds: crate::commands::setup_commands(),
+            emojis: emoji_map(),
+
             names: Default::default(),
             rooms: Default::default(),
             presences: Default::default(),
             verifications: Default::default(),
             need_load: Default::default(),
-            emojis: emoji_map(),
+            sync_info: Default::default(),
         }
     }
 
@@ -657,7 +700,10 @@ impl ChatStore {
             .unwrap_or_else(|| "Untitled Matrix Room".to_string())
     }
 
-    pub async fn set_receipts(&mut self, receipts: Vec<(OwnedRoomId, Receipts)>) {
+    pub async fn set_receipts(
+        &mut self,
+        receipts: Vec<(OwnedRoomId, Receipts)>,
+    ) -> Vec<(OwnedRoomId, OwnedEventId)> {
         let mut updates = vec![];
 
         for (room_id, receipts) in receipts.into_iter() {
@@ -670,11 +716,7 @@ impl ChatStore {
             }
         }
 
-        for (room_id, read_till) in updates.into_iter() {
-            if let Some(room) = self.worker.client.get_joined_room(&room_id) {
-                let _ = room.read_receipt(read_till.as_ref()).await;
-            }
-        }
+        return updates;
     }
 
     pub fn mark_for_load(&mut self, room_id: OwnedRoomId) {
@@ -700,17 +742,159 @@ impl ApplicationStore for ChatStore {}
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum IambId {
+    /// A Matrix room.
     Room(OwnedRoomId),
+
+    /// The `:rooms` window.
     DirectList,
+
+    /// The `:members` window for a given Matrix room.
     MemberList(OwnedRoomId),
+
+    /// The `:rooms` window.
     RoomList,
+
+    /// The `:spaces` window.
     SpaceList,
+
+    /// The `:verify` window.
     VerifyList,
+
+    /// The `:welcome` window.
     Welcome,
 }
 
+impl Display for IambId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IambId::Room(room_id) => {
+                write!(f, "iamb://room/{room_id}")
+            },
+            IambId::MemberList(room_id) => {
+                write!(f, "iamb://members/{room_id}")
+            },
+            IambId::DirectList => f.write_str("iamb://dms"),
+            IambId::RoomList => f.write_str("iamb://rooms"),
+            IambId::SpaceList => f.write_str("iamb://spaces"),
+            IambId::VerifyList => f.write_str("iamb://verify"),
+            IambId::Welcome => f.write_str("iamb://welcome"),
+        }
+    }
+}
+
 impl ApplicationWindowId for IambId {}
 
+impl Serialize for IambId {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl<'de> Deserialize<'de> for IambId {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(IambIdVisitor)
+    }
+}
+
+struct IambIdVisitor;
+
+impl<'de> Visitor<'de> for IambIdVisitor {
+    type Value = IambId;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a valid window URL")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: SerdeError,
+    {
+        let Ok(url) = Url::parse(value) else {
+            return Err(E::custom("Invalid iamb window URL"));
+        };
+
+        if url.scheme() != "iamb" {
+            return Err(E::custom("Invalid iamb window URL"));
+        }
+
+        match url.domain() {
+            Some("room") => {
+                let Some(path) = url.path_segments() else {
+                    return Err(E::custom("Invalid members window URL"));
+                };
+
+                let &[room_id] = path.collect::<Vec<_>>().as_slice() else {
+                    return Err(E::custom("Invalid members window URL"));
+                };
+
+                let Ok(room_id) = OwnedRoomId::try_from(room_id) else {
+                    return Err(E::custom("Invalid room identifier"));
+                };
+
+                Ok(IambId::Room(room_id))
+            },
+            Some("members") => {
+                let Some(path) = url.path_segments() else {
+                    return Err(E::custom("Invalid members window URL"));
+                };
+
+                let &[room_id] = path.collect::<Vec<_>>().as_slice() else {
+                    return Err(E::custom("Invalid members window URL"));
+                };
+
+                let Ok(room_id) = OwnedRoomId::try_from(room_id) else {
+                    return Err(E::custom("Invalid room identifier"));
+                };
+
+                Ok(IambId::MemberList(room_id))
+            },
+            Some("dms") => {
+                if url.path() != "" {
+                    return Err(E::custom("iamb://dms takes no path"));
+                }
+
+                Ok(IambId::DirectList)
+            },
+            Some("rooms") => {
+                if url.path() != "" {
+                    return Err(E::custom("iamb://rooms takes no path"));
+                }
+
+                Ok(IambId::RoomList)
+            },
+            Some("spaces") => {
+                if url.path() != "" {
+                    return Err(E::custom("iamb://spaces takes no path"));
+                }
+
+                Ok(IambId::SpaceList)
+            },
+            Some("verify") => {
+                if url.path() != "" {
+                    return Err(E::custom("iamb://verify takes no path"));
+                }
+
+                Ok(IambId::VerifyList)
+            },
+            Some("welcome") => {
+                if url.path() != "" {
+                    return Err(E::custom("iamb://welcome takes no path"));
+                }
+
+                Ok(IambId::Welcome)
+            },
+            Some(s) => Err(E::custom(format!("{s:?} is not a valid window"))),
+            None => Err(E::custom("Invalid iamb window URL")),
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum RoomFocus {
     Scrollback,
@@ -773,9 +957,7 @@ impl ApplicationInfo for IambInfo {
             IambBufferId::Command(CommandType::Command) => complete_cmdbar(text, cursor, store),
             IambBufferId::Command(CommandType::Search) => vec![],
 
-            IambBufferId::Room(_, RoomFocus::MessageBar) => {
-                complete_matrix_names(text, cursor, store)
-            },
+            IambBufferId::Room(_, RoomFocus::MessageBar) => complete_msgbar(text, cursor, store),
             IambBufferId::Room(_, RoomFocus::Scrollback) => vec![],
 
             IambBufferId::DirectList => vec![],
@@ -807,6 +989,53 @@ fn complete_users(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) ->
         .collect()
 }
 
+fn complete_msgbar(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -> Vec<String> {
+    let id = text
+        .get_prefix_word_mut(cursor, &MATRIX_ID_WORD)
+        .unwrap_or_else(EditRope::empty);
+    let id = Cow::from(&id);
+
+    match id.chars().next() {
+        // Complete room aliases.
+        Some('#') => {
+            return store.application.names.complete(id.as_ref());
+        },
+
+        // Complete room identifiers.
+        Some('!') => {
+            return store
+                .application
+                .rooms
+                .complete(id.as_ref())
+                .into_iter()
+                .map(|i| i.to_string())
+                .collect();
+        },
+
+        // Complete Emoji shortcodes.
+        Some(':') => {
+            let list = store.application.emojis.complete(&id[1..]);
+            let iter = list.into_iter().take(200).map(|s| format!(":{}:", s));
+
+            return iter.collect();
+        },
+
+        // Complete usernames for @ and empty strings.
+        Some('@') | None => {
+            return store
+                .application
+                .presences
+                .complete(id.as_ref())
+                .into_iter()
+                .map(|i| i.to_string())
+                .collect();
+        },
+
+        // Unknown sigil.
+        Some(_) => return vec![],
+    }
+}
+
 fn complete_matrix_names(
     text: &EditRope,
     cursor: &mut Cursor,
@@ -844,6 +1073,17 @@ fn complete_emoji(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) ->
     store.application.emojis.complete(sc.as_ref())
 }
 
+fn complete_cmdname(
+    desc: CommandDescription,
+    text: &EditRope,
+    cursor: &mut Cursor,
+    store: &ProgramStore,
+) -> Vec<String> {
+    // Complete command name and set cursor position.
+    let _ = text.get_prefix_word_mut(cursor, &WordStyle::Little);
+    store.application.cmds.complete_name(desc.command.as_str())
+}
+
 fn complete_cmdarg(
     desc: CommandDescription,
     text: &EditRope,
@@ -862,24 +1102,26 @@ fn complete_cmdarg(
         "react" | "unreact" => complete_emoji(text, cursor, store),
 
         "invite" => complete_users(text, cursor, store),
-        "join" => complete_matrix_names(text, cursor, store),
+        "join" | "split" | "vsplit" | "tabedit" => complete_matrix_names(text, cursor, store),
         "room" => vec![],
         "verify" => vec![],
-        _ => panic!("unknown command {}", cmd.name.as_str()),
+        "vertical" | "horizontal" | "aboveleft" | "belowright" | "tab" => {
+            complete_cmd(desc.arg.text.as_str(), text, cursor, store)
+        },
+        _ => vec![],
     }
 }
 
-fn complete_cmdbar(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -> Vec<String> {
-    let eo = text.cursor_to_offset(cursor);
-    let slice = text.slice(0.into(), eo, false);
-    let cow = Cow::from(&slice);
-
-    match CommandDescription::from_str(cow.as_ref()) {
+fn complete_cmd(
+    cmd: &str,
+    text: &EditRope,
+    cursor: &mut Cursor,
+    store: &ProgramStore,
+) -> Vec<String> {
+    match CommandDescription::from_str(cmd) {
         Ok(desc) => {
             if desc.arg.untrimmed.is_empty() {
-                // Complete command name and set cursor position.
-                let _ = text.get_prefix_word_mut(cursor, &WordStyle::Little);
-                store.application.cmds.complete_name(desc.command.as_str())
+                complete_cmdname(desc, text, cursor, store)
             } else {
                 // Complete command argument.
                 complete_cmdarg(desc, text, cursor, store)
@@ -891,6 +1133,14 @@ fn complete_cmdbar(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -
     }
 }
 
+fn complete_cmdbar(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -> Vec<String> {
+    let eo = text.cursor_to_offset(cursor);
+    let slice = text.slice(0.into(), eo, false);
+    let cow = Cow::from(&slice);
+
+    complete_cmd(cow.as_ref(), text, cursor, store)
+}
+
 #[cfg(test)]
 pub mod tests {
     use super::*;
@@ -975,9 +1225,39 @@ pub mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn test_complete_msgbar() {
+        let store = mock_store().await;
+
+        let text = EditRope::from("going for a walk :walk ");
+        let mut cursor = Cursor::new(0, 22);
+        let res = complete_msgbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec![":walking:", ":walking_man:", ":walking_woman:"]);
+        assert_eq!(cursor, Cursor::new(0, 17));
+
+        let text = EditRope::from("hello @user1 ");
+        let mut cursor = Cursor::new(0, 12);
+        let res = complete_msgbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec!["@user1:example.com"]);
+        assert_eq!(cursor, Cursor::new(0, 6));
+
+        let text = EditRope::from("see #room ");
+        let mut cursor = Cursor::new(0, 9);
+        let res = complete_msgbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec!["#room1:example.com"]);
+        assert_eq!(cursor, Cursor::new(0, 4));
+    }
+
     #[tokio::test]
     async fn test_complete_cmdbar() {
         let store = mock_store().await;
+        let users = vec![
+            "@user1:example.com",
+            "@user2:example.com",
+            "@user3:example.com",
+            "@user4:example.com",
+            "@user5:example.com",
+        ];
 
         let text = EditRope::from("invite    ");
         let mut cursor = Cursor::new(0, 7);
@@ -990,28 +1270,31 @@ pub mod tests {
         let text = EditRope::from("invite    ");
         let mut cursor = Cursor::new(0, 7);
         let res = complete_cmdbar(&text, &mut cursor, &store);
-        assert_eq!(res, vec![
-            "@user1:example.com",
-            "@user2:example.com",
-            "@user3:example.com",
-            "@user4:example.com",
-            "@user5:example.com"
-        ]);
+        assert_eq!(res, users);
 
         let text = EditRope::from("invite ignored");
         let mut cursor = Cursor::new(0, 7);
         let res = complete_cmdbar(&text, &mut cursor, &store);
-        assert_eq!(res, vec![
-            "@user1:example.com",
-            "@user2:example.com",
-            "@user3:example.com",
-            "@user4:example.com",
-            "@user5:example.com"
-        ]);
+        assert_eq!(res, users);
 
         let text = EditRope::from("invite @user1ignored");
         let mut cursor = Cursor::new(0, 13);
         let res = complete_cmdbar(&text, &mut cursor, &store);
         assert_eq!(res, vec!["@user1:example.com"]);
+
+        let text = EditRope::from("abo hor");
+        let mut cursor = Cursor::new(0, 7);
+        let res = complete_cmdbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec!["horizontal"]);
+
+        let text = EditRope::from("abo hor inv");
+        let mut cursor = Cursor::new(0, 11);
+        let res = complete_cmdbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec!["invite"]);
+
+        let text = EditRope::from("abo hor invite \n");
+        let mut cursor = Cursor::new(0, 15);
+        let res = complete_cmdbar(&text, &mut cursor, &store);
+        assert_eq!(res, users);
     }
 }

src/commands.rs

@@ -161,12 +161,23 @@ fn iamb_members(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
     return Ok(step);
 }
 
+fn iamb_leave(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
+    if !desc.arg.text.is_empty() {
+        return Result::Err(CommandError::InvalidArgument);
+    }
+
+    let leave = IambAction::Room(RoomAction::Leave(desc.bang));
+    let step = CommandStep::Continue(leave.into(), ctx.context.take());
+
+    return Ok(step);
+}
+
 fn iamb_cancel(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
     if !desc.arg.text.is_empty() {
         return Result::Err(CommandError::InvalidArgument);
     }
 
-    let mact = IambAction::from(MessageAction::Cancel);
+    let mact = IambAction::from(MessageAction::Cancel(desc.bang));
     let step = CommandStep::Continue(mact.into(), ctx.context.take());
 
     return Ok(step);
@@ -237,7 +248,8 @@ fn iamb_redact(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
         return Result::Err(CommandError::InvalidArgument);
     }
 
-    let ract = IambAction::from(MessageAction::Redact(args.into_iter().next()));
+    let reason = args.into_iter().next();
+    let ract = IambAction::from(MessageAction::Redact(reason, desc.bang));
     let step = CommandStep::Continue(ract.into(), ctx.context.take());
 
     return Ok(step);
@@ -469,6 +481,11 @@ fn add_iamb_commands(cmds: &mut ProgramCommands) {
         f: iamb_invite,
     });
     cmds.add_command(ProgramCommand { name: "join".into(), aliases: vec![], f: iamb_join });
+    cmds.add_command(ProgramCommand {
+        name: "leave".into(),
+        aliases: vec![],
+        f: iamb_leave,
+    });
     cmds.add_command(ProgramCommand {
         name: "members".into(),
         aliases: vec![],
@@ -870,15 +887,19 @@ mod tests {
         let ctx = ProgramContext::default();
 
         let res = cmds.input_cmd("redact", ctx.clone()).unwrap();
-        let act = IambAction::Message(MessageAction::Redact(None));
+        let act = IambAction::Message(MessageAction::Redact(None, false));
+        assert_eq!(res, vec![(act.into(), ctx.clone())]);
+
+        let res = cmds.input_cmd("redact!", ctx.clone()).unwrap();
+        let act = IambAction::Message(MessageAction::Redact(None, true));
         assert_eq!(res, vec![(act.into(), ctx.clone())]);
 
         let res = cmds.input_cmd("redact Removed", ctx.clone()).unwrap();
-        let act = IambAction::Message(MessageAction::Redact(Some("Removed".into())));
+        let act = IambAction::Message(MessageAction::Redact(Some("Removed".into()), false));
         assert_eq!(res, vec![(act.into(), ctx.clone())]);
 
         let res = cmds.input_cmd("redact \"Removed\"", ctx.clone()).unwrap();
-        let act = IambAction::Message(MessageAction::Redact(Some("Removed".into())));
+        let act = IambAction::Message(MessageAction::Redact(Some("Removed".into()), false));
         assert_eq!(res, vec![(act.into(), ctx.clone())]);
 
         let res = cmds.input_cmd("redact Removed Removed", ctx.clone());

src/config.rs

@@ -9,7 +9,7 @@ use std::path::{Path, PathBuf};
 use std::process;
 
 use clap::Parser;
-use matrix_sdk::ruma::{OwnedUserId, UserId};
+use matrix_sdk::ruma::{OwnedRoomAliasId, OwnedRoomId, OwnedUserId, UserId};
 use serde::{de::Error as SerdeError, de::Visitor, Deserialize, Deserializer};
 use tracing::Level;
 use url::Url;
@@ -19,6 +19,8 @@ use modalkit::tui::{
     text::Span,
 };
 
+use super::base::{IambId, RoomInfo};
+
 macro_rules! usage {
     ( $($args: tt)* ) => {
         println!($($args)*);
@@ -89,8 +91,13 @@ fn validate_profile_names(names: &HashMap<String, ProfileConfig>) {
     }
 }
 
+const VERSION: &str = match option_env!("VERGEN_GIT_SHA") {
+    None => env!("CARGO_PKG_VERSION"),
+    Some(_) => concat!(env!("CARGO_PKG_VERSION"), " (", env!("VERGEN_GIT_SHA"), ")"),
+};
+
 #[derive(Parser)]
-#[clap(version, about, long_about = None)]
+#[clap(version = VERSION, about, long_about = None)]
 #[clap(propagate_version = true)]
 pub struct Iamb {
     #[clap(short = 'P', long, value_parser)]
@@ -220,6 +227,24 @@ fn merge_users(a: Option<UserOverrides>, b: Option<UserOverrides>) -> Option<Use
     }
 }
 
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum UserDisplayStyle {
+    // The Matrix username for the sender (e.g., "@user:example.com").
+    #[default]
+    Username,
+
+    // The localpart of the Matrix username (e.g., "@user").
+    LocalPart,
+
+    // The display name for the Matrix user, calculated according to the rules from the spec.
+    //
+    // This is usually something like "Ada Lovelace" if the user has configured a display name, but
+    // it can wind up being the Matrix username if there are display name collisions in the room,
+    // in order to avoid any confusion.
+    DisplayName,
+}
+
 #[derive(Clone)]
 pub struct TunableValues {
     pub log_level: Level,
@@ -231,7 +256,9 @@ pub struct TunableValues {
     pub typing_notice_send: bool,
     pub typing_notice_display: bool,
     pub users: UserOverrides,
+    pub username_display: UserDisplayStyle,
     pub default_room: Option<String>,
+    pub open_command: Option<Vec<String>>,
 }
 
 #[derive(Clone, Default, Deserialize)]
@@ -245,7 +272,9 @@ pub struct Tunables {
     pub typing_notice_send: Option<bool>,
     pub typing_notice_display: Option<bool>,
     pub users: Option<UserOverrides>,
+    pub username_display: Option<UserDisplayStyle>,
     pub default_room: Option<String>,
+    pub open_command: Option<Vec<String>>,
 }
 
 impl Tunables {
@@ -262,7 +291,9 @@ impl Tunables {
             typing_notice_send: self.typing_notice_send.or(other.typing_notice_send),
             typing_notice_display: self.typing_notice_display.or(other.typing_notice_display),
             users: merge_users(self.users, other.users),
+            username_display: self.username_display.or(other.username_display),
             default_room: self.default_room.or(other.default_room),
+            open_command: self.open_command.or(other.open_command),
         }
     }
 
@@ -277,7 +308,9 @@ impl Tunables {
             typing_notice_send: self.typing_notice_send.unwrap_or(true),
             typing_notice_display: self.typing_notice_display.unwrap_or(true),
             users: self.users.unwrap_or_default(),
+            username_display: self.username_display.unwrap_or_default(),
             default_room: self.default_room,
+            open_command: self.open_command,
         }
     }
 }
@@ -286,7 +319,7 @@ impl Tunables {
 pub struct DirectoryValues {
     pub cache: PathBuf,
     pub logs: PathBuf,
-    pub downloads: PathBuf,
+    pub downloads: Option<PathBuf>,
 }
 
 #[derive(Clone, Default, Deserialize)]
@@ -321,21 +354,49 @@ impl Directories {
             dir
         });
 
-        let downloads = self
-            .downloads
-            .or_else(dirs::download_dir)
-            .expect("no dirs.download value configured!");
+        let downloads = self.downloads.or_else(dirs::download_dir);
 
         DirectoryValues { cache, logs, downloads }
     }
 }
 
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(untagged)]
+pub enum WindowPath {
+    AliasId(OwnedRoomAliasId),
+    RoomId(OwnedRoomId),
+    UserId(OwnedUserId),
+    Window(IambId),
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq)]
+#[serde(untagged, deny_unknown_fields)]
+pub enum WindowLayout {
+    Window { window: WindowPath },
+    Split { split: Vec<WindowLayout> },
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "lowercase", tag = "style")]
+pub enum Layout {
+    /// Restore the layout from the previous session.
+    #[default]
+    Restore,
+
+    /// Open a single window using the `default_room` value.
+    New,
+
+    /// Open the window layouts described under `tabs`.
+    Config { tabs: Vec<WindowLayout> },
+}
+
 #[derive(Clone, Deserialize)]
 pub struct ProfileConfig {
     pub user_id: OwnedUserId,
     pub url: Url,
     pub settings: Option<Tunables>,
     pub dirs: Option<Directories>,
+    pub layout: Option<Layout>,
 }
 
 #[derive(Clone, Deserialize)]
@@ -344,6 +405,7 @@ pub struct IambConfig {
     pub default_profile: Option<String>,
     pub settings: Option<Tunables>,
     pub dirs: Option<Directories>,
+    pub layout: Option<Layout>,
 }
 
 impl IambConfig {
@@ -367,11 +429,13 @@ impl IambConfig {
 #[derive(Clone)]
 pub struct ApplicationSettings {
     pub matrix_dir: PathBuf,
+    pub layout_json: PathBuf,
     pub session_json: PathBuf,
     pub profile_name: String,
     pub profile: ProfileConfig,
     pub tunables: TunableValues,
     pub dirs: DirectoryValues,
+    pub layout: Layout,
 }
 
 impl ApplicationSettings {
@@ -392,6 +456,7 @@ impl ApplicationSettings {
             default_profile,
             dirs,
             settings: global,
+            layout,
         } = IambConfig::load(config_json.as_path())?;
 
         validate_profile_names(&profiles);
@@ -415,10 +480,17 @@ impl ApplicationSettings {
             );
         };
 
+        let layout = profile.layout.take().or(layout).unwrap_or_default();
+
         let tunables = global.unwrap_or_default();
         let tunables = profile.settings.take().unwrap_or_default().merge(tunables);
         let tunables = tunables.values();
 
+        let dirs = dirs.unwrap_or_default();
+        let dirs = profile.dirs.take().unwrap_or_default().merge(dirs);
+        let dirs = dirs.values();
+
+        // Set up paths that live inside the profile's data directory.
         let mut profile_dir = config_dir.clone();
         profile_dir.push("profiles");
         profile_dir.push(profile_name.as_str());
@@ -429,17 +501,23 @@ impl ApplicationSettings {
         let mut session_json = profile_dir;
         session_json.push("session.json");
 
-        let dirs = dirs.unwrap_or_default();
-        let dirs = profile.dirs.take().unwrap_or_default().merge(dirs);
-        let dirs = dirs.values();
+        // Set up paths that live inside the profile's cache directory.
+        let mut cache_dir = dirs.cache.clone();
+        cache_dir.push("profiles");
+        cache_dir.push(profile_name.as_str());
+
+        let mut layout_json = cache_dir.clone();
+        layout_json.push("layout.json");
 
         let settings = ApplicationSettings {
             matrix_dir,
+            layout_json,
             session_json,
             profile_name,
             profile,
             tunables,
             dirs,
+            layout,
         };
 
         Ok(settings)
@@ -466,18 +544,45 @@ impl ApplicationSettings {
         Span::styled(String::from(c), style)
     }
 
-    pub fn get_user_span<'a>(&self, user_id: &'a UserId) -> Span<'a> {
-        let (color, name) = self
-            .tunables
+    pub fn get_user_overrides(
+        &self,
+        user_id: &UserId,
+    ) -> (Option<Color>, Option<Cow<'static, str>>) {
+        self.tunables
             .users
             .get(user_id)
             .map(|user| (user.color.as_ref().map(|c| c.0), user.name.clone().map(Cow::Owned)))
-            .unwrap_or_default();
+            .unwrap_or_default()
+    }
 
-        let user_id = user_id.as_str();
-        let color = color.unwrap_or_else(|| user_color(user_id));
+    pub fn get_user_style(&self, user_id: &UserId) -> Style {
+        let color = self
+            .tunables
+            .users
+            .get(user_id)
+            .and_then(|user| user.color.as_ref().map(|c| c.0))
+            .unwrap_or_else(|| user_color(user_id.as_str()));
+
+        user_style_from_color(color)
+    }
+
+    pub fn get_user_span<'a>(&self, user_id: &'a UserId, info: &'a RoomInfo) -> Span<'a> {
+        let (color, name) = self.get_user_overrides(user_id);
+
+        let color = color.unwrap_or_else(|| user_color(user_id.as_str()));
         let style = user_style_from_color(color);
-        let name = name.unwrap_or(Cow::Borrowed(user_id));
+        let name = match (name, &self.tunables.username_display) {
+            (Some(name), _) => name,
+            (None, UserDisplayStyle::Username) => Cow::Borrowed(user_id.as_str()),
+            (None, UserDisplayStyle::LocalPart) => Cow::Borrowed(user_id.localpart()),
+            (None, UserDisplayStyle::DisplayName) => {
+                if let Some(display) = info.display_names.get(user_id) {
+                    Cow::Borrowed(display.as_str())
+                } else {
+                    Cow::Borrowed(user_id.as_str())
+                }
+            },
+        };
 
         Span::styled(name, style)
     }
@@ -487,6 +592,7 @@ impl ApplicationSettings {
 mod tests {
     use super::*;
     use matrix_sdk::ruma::user_id;
+    use std::convert::TryFrom;
 
     #[test]
     fn test_profile_name_invalid() {
@@ -580,4 +686,75 @@ mod tests {
         })];
         assert_eq!(res.users, Some(users.into_iter().collect()));
     }
+
+    #[test]
+    fn test_parse_tunables_username_display() {
+        let res: Tunables = serde_json::from_str("{\"username_display\": \"username\"}").unwrap();
+        assert_eq!(res.username_display, Some(UserDisplayStyle::Username));
+
+        let res: Tunables = serde_json::from_str("{\"username_display\": \"localpart\"}").unwrap();
+        assert_eq!(res.username_display, Some(UserDisplayStyle::LocalPart));
+
+        let res: Tunables =
+            serde_json::from_str("{\"username_display\": \"displayname\"}").unwrap();
+        assert_eq!(res.username_display, Some(UserDisplayStyle::DisplayName));
+    }
+
+    #[test]
+    fn test_parse_layout() {
+        let user = WindowPath::UserId(user_id!("@user:example.com").to_owned());
+        let alias = WindowPath::AliasId(OwnedRoomAliasId::try_from("#room:example.com").unwrap());
+        let room = WindowPath::RoomId(OwnedRoomId::try_from("!room:example.com").unwrap());
+        let dms = WindowPath::Window(IambId::DirectList);
+        let welcome = WindowPath::Window(IambId::Welcome);
+
+        let res: Layout = serde_json::from_str("{\"style\": \"restore\"}").unwrap();
+        assert_eq!(res, Layout::Restore);
+
+        let res: Layout = serde_json::from_str("{\"style\": \"new\"}").unwrap();
+        assert_eq!(res, Layout::New);
+
+        let res: Layout = serde_json::from_str(
+            "{\"style\": \"config\", \"tabs\": [{\"window\":\"@user:example.com\"}]}",
+        )
+        .unwrap();
+        assert_eq!(res, Layout::Config {
+            tabs: vec![WindowLayout::Window { window: user.clone() }]
+        });
+
+        let res: Layout = serde_json::from_str(
+            "{\
+            \"style\": \"config\",\
+            \"tabs\": [\
+                {\"split\":[\
+                    {\"window\":\"@user:example.com\"},\
+                    {\"window\":\"#room:example.com\"}\
+                ]},\
+                {\"split\":[\
+                    {\"window\":\"!room:example.com\"},\
+                    {\"split\":[\
+                        {\"window\":\"iamb://dms\"},\
+                        {\"window\":\"iamb://welcome\"}\
+                    ]}\
+                ]}\
+            ]}",
+        )
+        .unwrap();
+        let split1 = WindowLayout::Split {
+            split: vec![
+                WindowLayout::Window { window: user.clone() },
+                WindowLayout::Window { window: alias },
+            ],
+        };
+        let split2 = WindowLayout::Split {
+            split: vec![WindowLayout::Window { window: dms }, WindowLayout::Window {
+                window: welcome,
+            }],
+        };
+        let split3 = WindowLayout::Split {
+            split: vec![WindowLayout::Window { window: room }, split2],
+        };
+        let tabs = vec![split1, split3];
+        assert_eq!(res, Layout::Config { tabs });
+    }
 }

src/main.rs

@@ -6,7 +6,7 @@ use std::collections::VecDeque;
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fs::{create_dir_all, File};
-use std::io::{stdout, BufReader, Stdout};
+use std::io::{stdout, BufReader, BufWriter, Stdout};
 use std::ops::DerefMut;
 use std::process;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -17,12 +17,26 @@ use clap::Parser;
 use tokio::sync::Mutex as AsyncMutex;
 use tracing_subscriber::FmtSubscriber;
 
-use matrix_sdk::ruma::OwnedUserId;
+use matrix_sdk::{
+    config::SyncSettings,
+    ruma::{
+        api::client::filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
+        OwnedUserId,
+    },
+};
 
 use modalkit::crossterm::{
     self,
     cursor::Show as CursorShow,
-    event::{poll, read, DisableBracketedPaste, EnableBracketedPaste, Event},
+    event::{
+        poll,
+        read,
+        DisableBracketedPaste,
+        DisableFocusChange,
+        EnableBracketedPaste,
+        EnableFocusChange,
+        Event,
+    },
     execute,
     terminal::{EnterAlternateScreen, LeaveAlternateScreen, SetTitle},
 };
@@ -76,12 +90,15 @@ use modalkit::{
             EditInfo,
             Editable,
             EditorAction,
+            InfoMessage,
             InsertTextAction,
             Jumpable,
             Promptable,
             Scrollable,
+            TabAction,
             TabContainer,
             TabCount,
+            UIError,
             WindowAction,
             WindowContainer,
         },
@@ -90,23 +107,123 @@ use modalkit::{
         key::KeyManager,
         store::Store,
     },
-    input::{bindings::BindingMachine, key::TerminalKey},
+    input::{bindings::BindingMachine, dialog::Pager, key::TerminalKey},
     widgets::{
         cmdbar::CommandBarState,
-        screen::{Screen, ScreenState},
+        screen::{FocusList, Screen, ScreenState, TabLayoutDescription},
+        windows::WindowLayoutDescription,
         TerminalCursor,
         TerminalExtOps,
         Window,
     },
 };
 
+fn config_tab_to_desc(
+    layout: config::WindowLayout,
+    store: &mut ProgramStore,
+) -> IambResult<WindowLayoutDescription<IambInfo>> {
+    let desc = match layout {
+        config::WindowLayout::Window { window } => {
+            let ChatStore { names, worker, .. } = &mut store.application;
+
+            let window = match window {
+                config::WindowPath::UserId(user_id) => {
+                    let name = user_id.to_string();
+                    let room_id = worker.join_room(name.clone())?;
+                    names.insert(name, room_id.clone());
+                    IambId::Room(room_id)
+                },
+                config::WindowPath::RoomId(room_id) => IambId::Room(room_id),
+                config::WindowPath::AliasId(alias) => {
+                    let name = alias.to_string();
+                    let room_id = worker.join_room(name.clone())?;
+                    names.insert(name, room_id.clone());
+                    IambId::Room(room_id)
+                },
+                config::WindowPath::Window(id) => id,
+            };
+
+            WindowLayoutDescription::Window { window, length: None }
+        },
+        config::WindowLayout::Split { split } => {
+            let children = split
+                .into_iter()
+                .map(|child| config_tab_to_desc(child, store))
+                .collect::<IambResult<Vec<_>>>()?;
+
+            WindowLayoutDescription::Split { children, length: None }
+        },
+    };
+
+    Ok(desc)
+}
+
+fn setup_screen(
+    settings: ApplicationSettings,
+    store: &mut ProgramStore,
+) -> IambResult<ScreenState<IambWindow, IambInfo>> {
+    let cmd = CommandBarState::new(store);
+    let dims = crossterm::terminal::size()?;
+    let area = Rect::new(0, 0, dims.0, dims.1);
+
+    match settings.layout {
+        config::Layout::Restore => {
+            if let Ok(layout) = std::fs::read(&settings.layout_json) {
+                let tabs: TabLayoutDescription<IambInfo> =
+                    serde_json::from_slice(&layout).map_err(IambError::from)?;
+                let tabs = tabs.to_layout(area.into(), store)?;
+
+                return Ok(ScreenState::from_list(tabs, cmd));
+            }
+        },
+        config::Layout::New => {},
+        config::Layout::Config { tabs } => {
+            let mut list = FocusList::default();
+
+            for tab in tabs.into_iter() {
+                let tab = config_tab_to_desc(tab, store)?;
+                let tab = tab.to_layout(area.into(), store)?;
+                list.push(tab);
+            }
+
+            return Ok(ScreenState::from_list(list, cmd));
+        },
+    }
+
+    let win = settings
+        .tunables
+        .default_room
+        .and_then(|room| IambWindow::find(room, store).ok())
+        .or_else(|| IambWindow::open(IambId::Welcome, store).ok())
+        .unwrap();
+
+    return Ok(ScreenState::new(win, cmd));
+}
+
 struct Application {
-    store: AsyncProgramStore,
-    worker: Requester,
+    /// Terminal backend.
     terminal: Terminal<CrosstermBackend<Stdout>>,
-    bindings: KeyManager<TerminalKey, ProgramAction, RepeatType, ProgramContext>,
-    actstack: VecDeque<(ProgramAction, ProgramContext)>,
+
+    /// State for the Matrix client, editing, etc.
+    store: AsyncProgramStore,
+
+    /// UI state (open tabs, command bar, etc.) to use when rendering.
     screen: ScreenState<IambWindow, IambInfo>,
+
+    /// Handle to communicate synchronously with the Matrix worker task.
+    worker: Requester,
+
+    /// Mapped keybindings.
+    bindings: KeyManager<TerminalKey, ProgramAction, RepeatType, ProgramContext>,
+
+    /// Pending actions to run.
+    actstack: VecDeque<(ProgramAction, ProgramContext)>,
+
+    /// Whether or not the terminal is currently focused.
+    focused: bool,
+
+    /// The tab layout before the last executed [TabAction].
+    last_layout: Option<TabLayoutDescription<IambInfo>>,
 }
 
 impl Application {
@@ -118,6 +235,7 @@ impl Application {
         crossterm::terminal::enable_raw_mode()?;
         crossterm::execute!(stdout, EnterAlternateScreen)?;
         crossterm::execute!(stdout, EnableBracketedPaste)?;
+        crossterm::execute!(stdout, EnableFocusChange)?;
 
         let title = format!("iamb ({})", settings.profile.user_id);
         crossterm::execute!(stdout, SetTitle(title))?;
@@ -129,16 +247,7 @@ impl Application {
         let bindings = KeyManager::new(bindings);
 
         let mut locked = store.lock().await;
-
-        let win = settings
-            .tunables
-            .default_room
-            .and_then(|room| IambWindow::find(room, locked.deref_mut()).ok())
-            .or_else(|| IambWindow::open(IambId::Welcome, locked.deref_mut()).ok())
-            .unwrap();
-
-        let cmd = CommandBarState::new(locked.deref_mut());
-        let screen = ScreenState::new(win, cmd);
+        let screen = setup_screen(settings, locked.deref_mut())?;
 
         let worker = locked.application.worker.clone();
         drop(locked);
@@ -152,12 +261,14 @@ impl Application {
             bindings,
             actstack,
             screen,
+            focused: true,
+            last_layout: None,
         })
     }
 
     fn redraw(&mut self, full: bool, store: &mut ProgramStore) -> Result<(), std::io::Error> {
-        let modestr = self.bindings.showmode();
-        let cursor = self.bindings.get_cursor_indicator();
+        let bindings = &mut self.bindings;
+        let focused = self.focused;
         let sstate = &mut self.screen;
         let term = &mut self.terminal;
 
@@ -168,9 +279,24 @@ impl Application {
         term.draw(|f| {
             let area = f.size();
 
-            let screen = Screen::new(store).showmode(modestr).borders(true);
+            let modestr = bindings.show_mode();
+            let cursor = bindings.get_cursor_indicator();
+            let dialogstr = bindings.show_dialog(area.height as usize, area.width as usize);
+
+            // Don't show terminal cursor when we show a dialog.
+            let hide_cursor = !dialogstr.is_empty();
+
+            let screen = Screen::new(store)
+                .show_dialog(dialogstr)
+                .show_mode(modestr)
+                .borders(true)
+                .focus(focused);
             f.render_stateful_widget(screen, area, sstate);
 
+            if hide_cursor {
+                return;
+            }
+
             if let Some((cx, cy)) = sstate.get_term_cursor() {
                 if let Some(c) = cursor {
                     let style = Style::default().fg(Color::Green);
@@ -200,8 +326,11 @@ impl Application {
                 Event::Mouse(_) => {
                     // Do nothing for now.
                 },
-                Event::FocusGained | Event::FocusLost => {
-                    // Do nothing for now.
+                Event::FocusGained => {
+                    self.focused = true;
+                },
+                Event::FocusLost => {
+                    self.focused = false;
                 },
                 Event::Resize(_, _) => {
                     // We'll redraw for the new size next time step() is called.
@@ -215,7 +344,8 @@ impl Application {
                     match self.screen.editor_command(&act, &ctx, store.deref_mut()) {
                         Ok(None) => {},
                         Ok(Some(info)) => {
-                            self.screen.push_info(info);
+                            drop(store);
+                            self.handle_info(info);
                         },
                         Err(e) => {
                             self.screen.push_error(e);
@@ -279,8 +409,7 @@ impl Application {
             Action::CommandBar(act) => self.screen.command_bar(&act, &ctx)?,
             Action::Macro(act) => self.bindings.macro_command(&act, &ctx, store)?,
             Action::Scroll(style) => self.screen.scroll(&style, &ctx, store)?,
-            Action::Suspend => self.terminal.program_suspend()?,
-            Action::Tab(cmd) => self.screen.tab_command(&cmd, &ctx, store)?,
+            Action::ShowInfoMessage(info) => Some(info),
             Action::Window(cmd) => self.screen.window_command(&cmd, &ctx, store)?,
 
             Action::Jump(l, dir, count) => {
@@ -289,8 +418,20 @@ impl Application {
 
                 None
             },
+            Action::Suspend => {
+                self.terminal.program_suspend()?;
+
+                None
+            },
 
             // UI actions.
+            Action::Tab(cmd) => {
+                if let TabAction::Close(_, _) = &cmd {
+                    self.last_layout = self.screen.as_description().into();
+                }
+
+                self.screen.tab_command(&cmd, &ctx, store)?
+            },
             Action::RedrawScreen => {
                 self.screen.clear_message();
                 self.redraw(true, store)?;
@@ -402,6 +543,18 @@ impl Application {
         }
     }
 
+    fn handle_info(&mut self, info: InfoMessage) {
+        match info {
+            InfoMessage::Message(info) => {
+                self.screen.push_info(info);
+            },
+            InfoMessage::Pager(text) => {
+                let pager = Box::new(Pager::new(text, vec![]));
+                self.bindings.run_dialog(pager);
+            },
+        }
+    }
+
     pub async fn run(&mut self) -> Result<(), std::io::Error> {
         self.terminal.clear()?;
 
@@ -422,11 +575,18 @@ impl Application {
                         continue;
                     },
                     Ok(Some(info)) => {
-                        self.screen.push_info(info);
+                        self.handle_info(info);
 
                         // Continue processing; we'll redraw later.
                         continue;
                     },
+                    Err(
+                        UIError::NeedConfirm(dialog) |
+                        UIError::EditingFailure(EditError::NeedConfirm(dialog)),
+                    ) => {
+                        self.bindings.run_dialog(dialog);
+                        continue;
+                    },
                     Err(e) => {
                         self.screen.push_error(e);
 
@@ -438,6 +598,19 @@ impl Application {
             }
         }
 
+        if let Some(ref layout) = self.last_layout {
+            let locked = self.store.lock().await;
+            let path = locked.application.settings.layout_json.as_path();
+            path.parent().map(create_dir_all).transpose()?;
+
+            let file = File::create(path)?;
+            let writer = BufWriter::new(file);
+
+            if let Err(e) = serde_json::to_writer(writer, layout) {
+                tracing::error!("Failed to save window layout while exiting: {}", e);
+            }
+        }
+
         crossterm::terminal::disable_raw_mode()?;
         execute!(self.terminal.backend_mut(), LeaveAlternateScreen)?;
         self.terminal.show_cursor()?;
@@ -477,6 +650,20 @@ async fn login(worker: Requester, settings: &ApplicationSettings) -> IambResult<
         }
     }
 
+    // Perform an initial, lazily-loaded sync.
+    let mut room = RoomEventFilter::default();
+    room.lazy_load_options = LazyLoadOptions::Enabled { include_redundant_members: false };
+
+    let mut room_ev = RoomFilter::default();
+    room_ev.state = room;
+
+    let mut filter = FilterDefinition::default();
+    filter.room = room_ev;
+
+    let settings = SyncSettings::new().filter(filter.into());
+
+    worker.client.sync_once(settings).await.map_err(IambError::from)?;
+
     Ok(())
 }
 
@@ -495,13 +682,18 @@ async fn run(settings: ApplicationSettings) -> IambResult<()> {
 
     login(worker, &settings).await.unwrap_or_else(print_exit);
 
+    fn restore_tty() {
+        let _ = crossterm::terminal::disable_raw_mode();
+        let _ = crossterm::execute!(stdout(), DisableBracketedPaste);
+        let _ = crossterm::execute!(stdout(), DisableFocusChange);
+        let _ = crossterm::execute!(stdout(), LeaveAlternateScreen);
+        let _ = crossterm::execute!(stdout(), CursorShow);
+    }
+
     // Make sure panics clean up the terminal properly.
     let orig_hook = std::panic::take_hook();
     std::panic::set_hook(Box::new(move |panic_info| {
-        let _ = crossterm::terminal::disable_raw_mode();
-        let _ = crossterm::execute!(stdout(), DisableBracketedPaste);
-        let _ = crossterm::execute!(stdout(), LeaveAlternateScreen);
-        let _ = crossterm::execute!(stdout(), CursorShow);
+        restore_tty();
         orig_hook(panic_info);
         process::exit(1);
     }));
@@ -510,6 +702,7 @@ async fn run(settings: ApplicationSettings) -> IambResult<()> {
 
     // We can now run the application.
     application.run().await?;
+    restore_tty();
 
     Ok(())
 }
@@ -521,6 +714,12 @@ fn main() -> IambResult<()> {
     // Load configuration and set up the Matrix SDK.
     let settings = ApplicationSettings::load(iamb).unwrap_or_else(print_exit);
 
+    // Set umask on Unix platforms so that tokens, keys, etc. are only readable by the user.
+    #[cfg(unix)]
+    unsafe {
+        libc::umask(0o077);
+    };
+
     // Set up the tracing subscriber so we can log client messages.
     let log_prefix = format!("iamb-log-{}", settings.profile_name);
     let log_dir = settings.dirs.logs.as_path();
@@ -539,6 +738,7 @@ fn main() -> IambResult<()> {
 
     let rt = tokio::runtime::Builder::new_multi_thread()
         .enable_all()
+        .worker_threads(2)
         .thread_name_fn(|| {
             static ATOMIC_ID: AtomicUsize = AtomicUsize::new(0);
             let id = ATOMIC_ID.fetch_add(1, Ordering::SeqCst);

src/message/html.rs

@@ -130,7 +130,6 @@ impl Table {
         let cell_min = cell_total / columns;
         let mut cell_slop = cell_total - cell_min * columns;
         let cell_widths = (0..columns)
-            .into_iter()
             .map(|_| {
                 let slopped = cell_slop.min(1);
                 cell_slop -= slopped;
@@ -238,6 +237,7 @@ pub enum StyleTreeNode {
     Image(Option<String>),
     List(StyleTreeChildren, ListStyle),
     Paragraph(Box<StyleTreeNode>),
+    Pre(Box<StyleTreeNode>),
     Reply(Box<StyleTreeNode>),
     Ruler,
     Style(Box<StyleTreeNode>, Style),
@@ -312,6 +312,39 @@ impl StyleTreeNode {
                 child.print(printer, style);
                 printer.commit();
             },
+            StyleTreeNode::Pre(child) => {
+                let mut subp = printer.sub(2).literal(true);
+                let subw = subp.width();
+
+                child.print(&mut subp, style);
+
+                printer.commit();
+                printer.push_line(
+                    vec![
+                        Span::styled(line::TOP_LEFT, style),
+                        Span::styled(line::HORIZONTAL.repeat(subw), style),
+                        Span::styled(line::TOP_RIGHT, style),
+                    ]
+                    .into(),
+                );
+
+                for mut line in subp.finish() {
+                    line.0.insert(0, Span::styled(line::VERTICAL, style));
+                    line.0.push(Span::styled(line::VERTICAL, style));
+                    printer.push_line(line);
+                }
+
+                printer.push_line(
+                    vec![
+                        Span::styled(line::BOTTOM_LEFT, style),
+                        Span::styled(line::HORIZONTAL.repeat(subw), style),
+                        Span::styled(line::BOTTOM_RIGHT, style),
+                    ]
+                    .into(),
+                );
+
+                printer.commit();
+            },
             StyleTreeNode::Reply(child) => {
                 if printer.hide_reply() {
                     return;
@@ -586,6 +619,7 @@ fn h2t(hdl: &Handle) -> StyleTreeChildren {
                 // Other text blocks.
                 "blockquote" => StyleTreeNode::Blockquote(c2t(&node.children.borrow())),
                 "div" | "p" => StyleTreeNode::Paragraph(c2t(&node.children.borrow())),
+                "pre" => StyleTreeNode::Pre(c2t(&node.children.borrow())),
 
                 // No children.
                 "hr" => StyleTreeNode::Ruler,
@@ -594,7 +628,7 @@ fn h2t(hdl: &Handle) -> StyleTreeChildren {
                 "img" => StyleTreeNode::Image(attrs_to_alt(&attrs.borrow())),
 
                 // These don't render in any special way.
-                "a" | "details" | "html" | "pre" | "summary" | "sub" | "sup" => {
+                "a" | "details" | "html" | "summary" | "sub" | "sup" => {
                     *c2t(&node.children.borrow())
                 },
 
@@ -631,6 +665,7 @@ pub fn parse_matrix_html(s: &str) -> StyleTree {
 pub mod tests {
     use super::*;
     use crate::util::space_span;
+    use pretty_assertions::assert_eq;
 
     #[test]
     fn test_header() {
@@ -1028,9 +1063,8 @@ pub mod tests {
             Span::raw("│"),
             Span::raw("    "),
             Span::raw("│"),
-            Span::styled(" ", bold),
             Span::styled("3", bold),
-            Span::styled(" ", bold),
+            Span::styled("  ", bold),
             Span::raw("│")
         ]);
 
@@ -1158,4 +1192,93 @@ pub mod tests {
         assert_eq!(text.lines[1], Spans(vec![Span::raw("World"), Span::raw("  "),]));
         assert_eq!(text.lines[2], Spans(vec![Span::raw("Goodbye")]),);
     }
+
+    #[test]
+    fn test_embedded_newline() {
+        let s = "<p>Hello\nWorld</p>";
+        let tree = parse_matrix_html(s);
+        let text = tree.to_text(15, Style::default(), true);
+        assert_eq!(text.lines.len(), 1);
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![
+                Span::raw("Hello"),
+                Span::raw(" "),
+                Span::raw("World"),
+                Span::raw("    ")
+            ])
+        );
+    }
+
+    #[test]
+    fn test_pre_tag() {
+        let s = concat!(
+            "<pre><code class=\"language-rust\">",
+            "fn hello() -&gt; usize {\n",
+            "    return 5;\n",
+            "}\n",
+            "</code></pre>\n"
+        );
+        let tree = parse_matrix_html(s);
+        let text = tree.to_text(25, Style::default(), true);
+        assert_eq!(text.lines.len(), 5);
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![
+                Span::raw(line::TOP_LEFT),
+                Span::raw(line::HORIZONTAL.repeat(23)),
+                Span::raw(line::TOP_RIGHT)
+            ])
+        );
+        assert_eq!(
+            text.lines[1],
+            Spans(vec![
+                Span::raw(line::VERTICAL),
+                Span::raw("fn"),
+                Span::raw(" "),
+                Span::raw("hello"),
+                Span::raw("("),
+                Span::raw(")"),
+                Span::raw(" "),
+                Span::raw("-"),
+                Span::raw(">"),
+                Span::raw(" "),
+                Span::raw("usize"),
+                Span::raw(" "),
+                Span::raw("{"),
+                Span::raw("  "),
+                Span::raw(line::VERTICAL)
+            ])
+        );
+        assert_eq!(
+            text.lines[2],
+            Spans(vec![
+                Span::raw(line::VERTICAL),
+                Span::raw("    "),
+                Span::raw("return"),
+                Span::raw(" "),
+                Span::raw("5"),
+                Span::raw(";"),
+                Span::raw("          "),
+                Span::raw(line::VERTICAL)
+            ])
+        );
+        assert_eq!(
+            text.lines[3],
+            Spans(vec![
+                Span::raw(line::VERTICAL),
+                Span::raw("}"),
+                Span::raw(" ".repeat(22)),
+                Span::raw(line::VERTICAL)
+            ])
+        );
+        assert_eq!(
+            text.lines[4],
+            Spans(vec![
+                Span::raw(line::BOTTOM_LEFT),
+                Span::raw(line::HORIZONTAL.repeat(23)),
+                Span::raw(line::BOTTOM_RIGHT)
+            ])
+        );
+    }
 }

src/message/mod.rs

@@ -7,6 +7,7 @@ use std::hash::{Hash, Hasher};
 use std::slice::Iter;
 
 use chrono::{DateTime, Local as LocalTz, NaiveDateTime, TimeZone};
+use comrak::{markdown_to_html, ComrakOptions};
 use unicode_width::UnicodeWidthStr;
 
 use matrix_sdk::ruma::{
@@ -26,6 +27,7 @@ use matrix_sdk::ruma::{
                 Relation,
                 RoomMessageEvent,
                 RoomMessageEventContent,
+                TextMessageEventContent,
             },
             redaction::SyncRoomRedactionEvent,
         },
@@ -93,6 +95,20 @@ const USER_GUTTER_EMPTY_SPAN: Span<'static> = span_static(USER_GUTTER_EMPTY);
 const TIME_GUTTER_EMPTY: &str = "            ";
 const TIME_GUTTER_EMPTY_SPAN: Span<'static> = span_static(TIME_GUTTER_EMPTY);
 
+fn text_to_message_content(input: String) -> TextMessageEventContent {
+    let mut options = ComrakOptions::default();
+    options.extension.shortcodes = true;
+    options.render.hardbreaks = true;
+    let html = markdown_to_html(input.as_str(), &options);
+
+    TextMessageEventContent::html(input, html)
+}
+
+pub fn text_to_message(input: String) -> RoomMessageEventContent {
+    let msg = MessageType::Text(text_to_message_content(input));
+    RoomMessageEventContent::new(msg)
+}
+
 #[inline]
 fn millis_to_datetime(ms: UInt) -> DateTime<LocalTz> {
     let time = i64::from(ms) / 1000;
@@ -628,7 +644,7 @@ impl Message {
         {
             let cols = MessageColumns::Four;
             let fill = width - USER_GUTTER - TIME_GUTTER - READ_GUTTER;
-            let user = self.show_sender(prev, true, settings);
+            let user = self.show_sender(prev, true, info, settings);
             let time = self.timestamp.show_time();
             let read = match info.receipts.get(self.event.event_id()) {
                 Some(read) => read.iter(),
@@ -639,7 +655,7 @@ impl Message {
         } else if USER_GUTTER + TIME_GUTTER + MIN_MSG_LEN <= width {
             let cols = MessageColumns::Three;
             let fill = width - USER_GUTTER - TIME_GUTTER;
-            let user = self.show_sender(prev, true, settings);
+            let user = self.show_sender(prev, true, info, settings);
             let time = self.timestamp.show_time();
             let read = [].iter();
 
@@ -647,7 +663,7 @@ impl Message {
         } else if USER_GUTTER + MIN_MSG_LEN <= width {
             let cols = MessageColumns::Two;
             let fill = width - USER_GUTTER;
-            let user = self.show_sender(prev, true, settings);
+            let user = self.show_sender(prev, true, info, settings);
             let time = None;
             let read = [].iter();
 
@@ -655,7 +671,7 @@ impl Message {
         } else {
             let cols = MessageColumns::One;
             let fill = width.saturating_sub(2);
-            let user = self.show_sender(prev, false, settings);
+            let user = self.show_sender(prev, false, info, settings);
             let time = None;
             let read = [].iter();
 
@@ -684,7 +700,7 @@ impl Message {
         if let Some(r) = &reply {
             let w = width.saturating_sub(2);
             let mut replied = r.show_msg(w, style, true);
-            let mut sender = r.sender_span(settings);
+            let mut sender = r.sender_span(info, settings);
             let sender_width = UnicodeWidthStr::width(sender.content.as_ref());
             let trailing = w.saturating_sub(sender_width + 1);
 
@@ -777,16 +793,21 @@ impl Message {
         }
     }
 
-    fn sender_span(&self, settings: &ApplicationSettings) -> Span {
-        settings.get_user_span(self.sender.as_ref())
+    fn sender_span<'a>(
+        &'a self,
+        info: &'a RoomInfo,
+        settings: &'a ApplicationSettings,
+    ) -> Span<'a> {
+        settings.get_user_span(self.sender.as_ref(), info)
     }
 
-    fn show_sender(
-        &self,
+    fn show_sender<'a>(
+        &'a self,
         prev: Option<&Message>,
         align_right: bool,
-        settings: &ApplicationSettings,
-    ) -> Option<Span> {
+        info: &'a RoomInfo,
+        settings: &'a ApplicationSettings,
+    ) -> Option<Span<'a>> {
         if let Some(prev) = prev {
             if self.sender == prev.sender &&
                 self.timestamp.same_day(&prev.timestamp) &&
@@ -796,7 +817,7 @@ impl Message {
             }
         }
 
-        let Span { content, style } = self.sender_span(settings);
+        let Span { content, style } = self.sender_span(info, settings);
         let stop = content.len().min(28);
         let s = &content[..stop];
 
@@ -972,4 +993,53 @@ pub mod tests {
         // MessageCursor::latest() should point at the most recent message after conversion.
         assert_eq!(identity(&mc6), mc1);
     }
+
+    #[test]
+    fn test_markdown_message() {
+        let input = "**bold**\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(content.formatted.unwrap().body, "<p><strong>bold</strong></p>\n");
+
+        let input = "*emphasis*\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(content.formatted.unwrap().body, "<p><em>emphasis</em></p>\n");
+
+        let input = "`code`\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(content.formatted.unwrap().body, "<p><code>code</code></p>\n");
+
+        let input = "```rust\nconst A: usize = 1;\n```\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(
+            content.formatted.unwrap().body,
+            "<pre><code class=\"language-rust\">const A: usize = 1;\n</code></pre>\n"
+        );
+
+        let input = ":heart:\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(content.formatted.unwrap().body, "<p>\u{2764}\u{FE0F}</p>\n");
+
+        let input = "para 1\n\npara 2\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(content.formatted.unwrap().body, "<p>para 1</p>\n<p>para 2</p>\n");
+
+        let input = "line 1\nline 2\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(content.formatted.unwrap().body, "<p>line 1<br />\nline 2</p>\n");
+
+        let input = "# Heading\n## Subheading\n\ntext\n";
+        let content = text_to_message_content(input.into());
+        assert_eq!(content.body, input);
+        assert_eq!(
+            content.formatted.unwrap().body,
+            "<h1>Heading</h1>\n<h2>Subheading</h2>\n<p>text</p>\n"
+        );
+    }
 }

src/message/printer.rs

@@ -17,6 +17,7 @@ pub struct TextPrinter<'a> {
     alignment: Alignment,
     curr_spans: Vec<Span<'a>>,
     curr_width: usize,
+    literal: bool,
 }
 
 impl<'a> TextPrinter<'a> {
@@ -30,6 +31,7 @@ impl<'a> TextPrinter<'a> {
             alignment: Alignment::Left,
             curr_spans: vec![],
             curr_width: 0,
+            literal: false,
         }
     }
 
@@ -38,6 +40,11 @@ impl<'a> TextPrinter<'a> {
         self
     }
 
+    pub fn literal(mut self, literal: bool) -> Self {
+        self.literal = literal;
+        self
+    }
+
     pub fn hide_reply(&self) -> bool {
         self.hide_reply
     }
@@ -56,6 +63,7 @@ impl<'a> TextPrinter<'a> {
             alignment: self.alignment,
             curr_spans: vec![],
             curr_width: 0,
+            literal: self.literal,
         }
     }
 
@@ -156,8 +164,22 @@ impl<'a> TextPrinter<'a> {
     pub fn push_str(&mut self, s: &'a str, style: Style) {
         let style = self.base_style.patch(style);
 
-        for word in UnicodeSegmentation::split_word_bounds(s) {
-            if self.width == 0 && word.chars().all(char::is_whitespace) {
+        if self.width == 0 {
+            return;
+        }
+
+        for mut word in UnicodeSegmentation::split_word_bounds(s) {
+            if let "\n" | "\r\n" = word {
+                if self.literal {
+                    self.commit();
+                    continue;
+                }
+
+                // Render embedded newlines as spaces.
+                word = " ";
+            }
+
+            if !self.literal && self.curr_width == 0 && word.chars().all(char::is_whitespace) {
                 // Drop leading whitespace.
                 continue;
             }
@@ -173,7 +195,7 @@ impl<'a> TextPrinter<'a> {
                 // Word doesn't fit on this line, so start a new one.
                 self.commit();
 
-                if word.chars().all(char::is_whitespace) {
+                if !self.literal && word.chars().all(char::is_whitespace) {
                     // Drop leading whitespace.
                     continue;
                 }

src/tests.rs

@@ -30,6 +30,7 @@ use crate::{
         ProfileConfig,
         TunableValues,
         UserColor,
+        UserDisplayStyle,
         UserDisplayTunables,
     },
     message::{
@@ -42,6 +43,8 @@ use crate::{
     worker::Requester,
 };
 
+const TEST_ROOM1_ALIAS: &str = "#room1:example.com";
+
 lazy_static! {
     pub static ref TEST_ROOM1_ID: OwnedRoomId = RoomId::new(server_name!("example.com")).to_owned();
     pub static ref TEST_USER1: OwnedUserId = user_id!("@user1:example.com").to_owned();
@@ -158,6 +161,7 @@ pub fn mock_room() -> RoomInfo {
         fetch_id: RoomFetchStatus::NotStarted,
         fetch_last: None,
         users_typing: None,
+        display_names: HashMap::new(),
     }
 }
 
@@ -165,7 +169,7 @@ pub fn mock_dirs() -> DirectoryValues {
     DirectoryValues {
         cache: PathBuf::new(),
         logs: PathBuf::new(),
-        downloads: PathBuf::new(),
+        downloads: None,
     }
 }
 
@@ -186,22 +190,28 @@ pub fn mock_tunables() -> TunableValues {
         })]
         .into_iter()
         .collect::<HashMap<_, _>>(),
+        open_command: None,
+        username_display: UserDisplayStyle::Username,
     }
 }
 
 pub fn mock_settings() -> ApplicationSettings {
     ApplicationSettings {
         matrix_dir: PathBuf::new(),
+        layout_json: PathBuf::new(),
         session_json: PathBuf::new(),
+
         profile_name: "test".into(),
         profile: ProfileConfig {
             user_id: user_id!("@user:example.com").to_owned(),
             url: Url::parse("https://example.com").unwrap(),
             settings: None,
             dirs: None,
+            layout: None,
         },
         tunables: mock_tunables(),
         dirs: mock_dirs(),
+        layout: Default::default(),
     }
 }
 
@@ -223,7 +233,8 @@ pub async fn mock_store() -> ProgramStore {
     let room_id = TEST_ROOM1_ID.clone();
     let info = mock_room();
 
-    store.rooms.insert(room_id, info);
+    store.rooms.insert(room_id.clone(), info);
+    store.names.insert(TEST_ROOM1_ALIAS.to_string(), room_id);
 
     ProgramStore::new(store)
 }

src/windows/mod.rs

@@ -1,4 +1,6 @@
 use std::cmp::{Ord, Ordering, PartialOrd};
+use std::ops::Deref;
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use matrix_sdk::{
@@ -10,7 +12,6 @@ use matrix_sdk::{
         OwnedRoomId,
         RoomId,
     },
-    DisplayName,
 };
 
 use modalkit::tui::{
@@ -78,6 +79,8 @@ use self::{room::RoomState, welcome::WelcomeState};
 pub mod room;
 pub mod welcome;
 
+type MatrixRoomInfo = Arc<(MatrixRoom, Option<Tags>)>;
+
 const MEMBER_FETCH_DEBOUNCE: Duration = Duration::from_secs(5);
 
 #[inline]
@@ -199,7 +202,7 @@ fn room_prompt(
 
             Err(err)
         },
-        PromptAction::Recall(_, _) => {
+        PromptAction::Recall(..) => {
             let msg = "Cannot recall history inside a list";
             let err = EditError::Failure(msg.into());
 
@@ -380,10 +383,13 @@ impl WindowOps<IambInfo> for IambWindow {
         match self {
             IambWindow::Room(state) => state.draw(area, buf, focused, store),
             IambWindow::DirectList(state) => {
-                let dms = store.application.worker.direct_messages();
-                let mut items = dms
+                let mut items = store
+                    .application
+                    .sync_info
+                    .dms
+                    .clone()
                     .into_iter()
-                    .map(|(id, name, tags)| DirectItem::new(id, name, tags, store))
+                    .map(|room_info| DirectItem::new(room_info, store))
                     .collect::<Vec<_>>();
                 items.sort();
 
@@ -403,7 +409,7 @@ impl WindowOps<IambInfo> for IambWindow {
 
                 if need_fetch {
                     if let Ok(mems) = store.application.worker.members(room_id.clone()) {
-                        let items = mems.into_iter().map(MemberItem::new);
+                        let items = mems.into_iter().map(|m| MemberItem::new(m, room_id.clone()));
                         state.set(items.collect());
                         *last_fetch = Some(Instant::now());
                     }
@@ -416,10 +422,13 @@ impl WindowOps<IambInfo> for IambWindow {
                     .render(area, buf, state);
             },
             IambWindow::RoomList(state) => {
-                let joined = store.application.worker.active_rooms();
-                let mut items = joined
+                let mut items = store
+                    .application
+                    .sync_info
+                    .rooms
+                    .clone()
                     .into_iter()
-                    .map(|(room, name, tags)| RoomItem::new(room, name, tags, store))
+                    .map(|room_info| RoomItem::new(room_info, store))
                     .collect::<Vec<_>>();
                 items.sort();
 
@@ -432,9 +441,13 @@ impl WindowOps<IambInfo> for IambWindow {
                     .render(area, buf, state);
             },
             IambWindow::SpaceList(state) => {
-                let spaces = store.application.worker.spaces();
-                let items =
-                    spaces.into_iter().map(|(room, name)| SpaceItem::new(room, name, store));
+                let items = store
+                    .application
+                    .sync_info
+                    .spaces
+                    .clone()
+                    .into_iter()
+                    .map(|room| SpaceItem::new(room, store));
                 state.set(items.collect());
                 state.draw(area, buf, focused, store);
 
@@ -529,10 +542,15 @@ impl Window<IambInfo> for IambWindow {
 
                 Spans::from(title)
             },
-            IambWindow::MemberList(_, room_id, _) => {
+            IambWindow::MemberList(state, room_id, _) => {
                 let title = store.application.get_room_title(room_id.as_ref());
-
-                Spans(vec![bold_span("Room Members: "), title.into()])
+                let n = state.len();
+                let v = vec![
+                    bold_span("Room Members "),
+                    Span::styled(format!("({n}): "), bold_style()),
+                    title.into(),
+                ];
+                Spans(v)
             },
         }
     }
@@ -546,10 +564,15 @@ impl Window<IambInfo> for IambWindow {
             IambWindow::Welcome(_) => bold_spans("Welcome to iamb"),
 
             IambWindow::Room(w) => w.get_title(store),
-            IambWindow::MemberList(_, room_id, _) => {
+            IambWindow::MemberList(state, room_id, _) => {
                 let title = store.application.get_room_title(room_id.as_ref());
-
-                Spans(vec![bold_span("Room Members: "), title.into()])
+                let n = state.len();
+                let v = vec![
+                    bold_span("Room Members "),
+                    Span::styled(format!("({n}): "), bold_style()),
+                    title.into(),
+                ];
+                Spans(v)
             },
         }
     }
@@ -629,36 +652,45 @@ impl Window<IambInfo> for IambWindow {
 
 #[derive(Clone)]
 pub struct RoomItem {
-    room: MatrixRoom,
-    tags: Option<Tags>,
+    room_info: MatrixRoomInfo,
     name: String,
 }
 
 impl RoomItem {
-    fn new(
-        room: MatrixRoom,
-        name: DisplayName,
-        tags: Option<Tags>,
-        store: &mut ProgramStore,
-    ) -> Self {
-        let name = name.to_string();
+    fn new(room_info: MatrixRoomInfo, store: &mut ProgramStore) -> Self {
+        let room = &room_info.deref().0;
         let room_id = room.room_id();
 
         let info = store.application.get_room_info(room_id.to_owned());
-        info.name = name.clone().into();
-        info.tags = tags.clone();
+        let name = info.name.clone().unwrap_or_default();
+        info.tags = room_info.deref().1.clone();
 
         if let Some(alias) = room.canonical_alias() {
             store.application.names.insert(alias.to_string(), room_id.to_owned());
         }
 
-        RoomItem { room, tags, name }
+        RoomItem { room_info, name }
+    }
+
+    #[inline]
+    fn room(&self) -> &MatrixRoom {
+        &self.room_info.deref().0
+    }
+
+    #[inline]
+    fn room_id(&self) -> &RoomId {
+        self.room().room_id()
+    }
+
+    #[inline]
+    fn tags(&self) -> &Option<Tags> {
+        &self.room_info.deref().1
     }
 }
 
 impl PartialEq for RoomItem {
     fn eq(&self, other: &Self) -> bool {
-        self.room.room_id() == other.room.room_id()
+        self.room_id() == other.room_id()
     }
 }
 
@@ -666,7 +698,7 @@ impl Eq for RoomItem {}
 
 impl Ord for RoomItem {
     fn cmp(&self, other: &Self) -> Ordering {
-        tag_cmp(&self.tags, &other.tags).then_with(|| room_cmp(&self.room, &other.room))
+        tag_cmp(self.tags(), other.tags()).then_with(|| room_cmp(self.room(), other.room()))
     }
 }
 
@@ -684,7 +716,7 @@ impl ToString for RoomItem {
 
 impl ListItem<IambInfo> for RoomItem {
     fn show(&self, selected: bool, _: &ViewportContext<ListCursor>, _: &mut ProgramStore) -> Text {
-        if let Some(tags) = &self.tags {
+        if let Some(tags) = &self.tags() {
             let style = selected_style(selected);
             let mut spans = vec![Span::styled(self.name.as_str(), style)];
 
@@ -697,7 +729,7 @@ impl ListItem<IambInfo> for RoomItem {
     }
 
     fn get_word(&self) -> Option<String> {
-        self.room.room_id().to_string().into()
+        self.room_id().to_string().into()
     }
 }
 
@@ -708,29 +740,37 @@ impl Promptable<ProgramContext, ProgramStore, IambInfo> for RoomItem {
         ctx: &ProgramContext,
         _: &mut ProgramStore,
     ) -> EditResult<Vec<(ProgramAction, ProgramContext)>, IambInfo> {
-        room_prompt(self.room.room_id(), act, ctx)
+        room_prompt(self.room_id(), act, ctx)
     }
 }
 
 #[derive(Clone)]
 pub struct DirectItem {
-    room: MatrixRoom,
-    tags: Option<Tags>,
+    room_info: MatrixRoomInfo,
     name: String,
 }
 
 impl DirectItem {
-    fn new(
-        room: MatrixRoom,
-        name: DisplayName,
-        tags: Option<Tags>,
-        store: &mut ProgramStore,
-    ) -> Self {
-        let name = name.to_string();
+    fn new(room_info: MatrixRoomInfo, store: &mut ProgramStore) -> Self {
+        let room_id = room_info.deref().0.room_id().to_owned();
+        let name = store.application.get_room_info(room_id).name.clone().unwrap_or_default();
 
-        store.application.set_room_name(room.room_id(), name.as_str());
+        DirectItem { room_info, name }
+    }
 
-        DirectItem { room, tags, name }
+    #[inline]
+    fn room(&self) -> &MatrixRoom {
+        &self.room_info.deref().0
+    }
+
+    #[inline]
+    fn room_id(&self) -> &RoomId {
+        self.room().room_id()
+    }
+
+    #[inline]
+    fn tags(&self) -> &Option<Tags> {
+        &self.room_info.deref().1
     }
 }
 
@@ -742,7 +782,7 @@ impl ToString for DirectItem {
 
 impl ListItem<IambInfo> for DirectItem {
     fn show(&self, selected: bool, _: &ViewportContext<ListCursor>, _: &mut ProgramStore) -> Text {
-        if let Some(tags) = &self.tags {
+        if let Some(tags) = &self.tags() {
             let style = selected_style(selected);
             let mut spans = vec![Span::styled(self.name.as_str(), style)];
 
@@ -755,13 +795,13 @@ impl ListItem<IambInfo> for DirectItem {
     }
 
     fn get_word(&self) -> Option<String> {
-        self.room.room_id().to_string().into()
+        self.room_id().to_string().into()
     }
 }
 
 impl PartialEq for DirectItem {
     fn eq(&self, other: &Self) -> bool {
-        self.room.room_id() == other.room.room_id()
+        self.room_id() == other.room_id()
     }
 }
 
@@ -769,7 +809,7 @@ impl Eq for DirectItem {}
 
 impl Ord for DirectItem {
     fn cmp(&self, other: &Self) -> Ordering {
-        tag_cmp(&self.tags, &other.tags).then_with(|| room_cmp(&self.room, &other.room))
+        tag_cmp(self.tags(), other.tags()).then_with(|| room_cmp(self.room(), other.room()))
     }
 }
 
@@ -786,7 +826,7 @@ impl Promptable<ProgramContext, ProgramStore, IambInfo> for DirectItem {
         ctx: &ProgramContext,
         _: &mut ProgramStore,
     ) -> EditResult<Vec<(ProgramAction, ProgramContext)>, IambInfo> {
-        room_prompt(self.room.room_id(), act, ctx)
+        room_prompt(self.room_id(), act, ctx)
     }
 }
 
@@ -797,11 +837,14 @@ pub struct SpaceItem {
 }
 
 impl SpaceItem {
-    fn new(room: MatrixRoom, name: DisplayName, store: &mut ProgramStore) -> Self {
-        let name = name.to_string();
+    fn new(room: MatrixRoom, store: &mut ProgramStore) -> Self {
         let room_id = room.room_id();
-
-        store.application.set_room_name(room_id, name.as_str());
+        let name = store
+            .application
+            .get_room_info(room_id.to_owned())
+            .name
+            .clone()
+            .unwrap_or_default();
 
         if let Some(alias) = room.canonical_alias() {
             store.application.names.insert(alias.to_string(), room_id.to_owned());
@@ -1043,7 +1086,7 @@ impl Promptable<ProgramContext, ProgramStore, IambInfo> for VerifyItem {
 
                 Err(err)
             },
-            PromptAction::Recall(_, _) => {
+            PromptAction::Recall(..) => {
                 let msg = "Cannot recall history inside a list";
                 let err = EditError::Failure(msg.into());
 
@@ -1057,11 +1100,12 @@ impl Promptable<ProgramContext, ProgramStore, IambInfo> for VerifyItem {
 #[derive(Clone)]
 pub struct MemberItem {
     member: RoomMember,
+    room_id: OwnedRoomId,
 }
 
 impl MemberItem {
-    fn new(member: RoomMember) -> Self {
-        Self { member }
+    fn new(member: RoomMember, room_id: OwnedRoomId) -> Self {
+        Self { member, room_id }
     }
 }
 
@@ -1078,12 +1122,32 @@ impl ListItem<IambInfo> for MemberItem {
         _: &ViewportContext<ListCursor>,
         store: &mut ProgramStore,
     ) -> Text {
-        let mut user = store.application.settings.get_user_span(self.member.user_id());
+        let info = store.application.rooms.get_or_default(self.room_id.clone());
+        let user_id = self.member.user_id();
+
+        let (color, name) = store.application.settings.get_user_overrides(self.member.user_id());
+        let color = color.unwrap_or_else(|| super::config::user_color(user_id.as_str()));
+        let mut style = super::config::user_style_from_color(color);
 
         if selected {
-            user.style = user.style.add_modifier(StyleModifier::REVERSED);
+            style = style.add_modifier(StyleModifier::REVERSED);
         }
 
+        let mut spans = vec![];
+        let mut parens = false;
+
+        if let Some(name) = name {
+            spans.push(Span::styled(name, style));
+            parens = true;
+        } else if let Some(display) = info.display_names.get(user_id) {
+            spans.push(Span::styled(display.clone(), style));
+            parens = true;
+        }
+
+        spans.extend(parens.then_some(Span::styled(" (", style)));
+        spans.push(Span::styled(user_id.as_str(), style));
+        spans.extend(parens.then_some(Span::styled(")", style)));
+
         let state = match self.member.membership() {
             MembershipState::Ban => Span::raw(" (banned)").into(),
             MembershipState::Invite => Span::raw(" (invited)").into(),
@@ -1093,11 +1157,9 @@ impl ListItem<IambInfo> for MemberItem {
             _ => None,
         };
 
-        if let Some(state) = state {
-            Spans(vec![user, state]).into()
-        } else {
-            user.into()
-        }
+        spans.extend(state);
+
+        return Spans(spans).into();
     }
 
     fn get_word(&self) -> Option<String> {
@@ -1120,7 +1182,7 @@ impl Promptable<ProgramContext, ProgramStore, IambInfo> for MemberItem {
 
                 Err(err)
             },
-            PromptAction::Recall(_, _) => {
+            PromptAction::Recall(..) => {
                 let msg = "Cannot recall history inside a list";
                 let err = EditError::Failure(msg.into());
 

src/windows/room/chat.rs

@@ -1,9 +1,11 @@
 use std::borrow::Cow;
-use std::ffi::OsStr;
+use std::ffi::{OsStr, OsString};
 use std::fs;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
+use modalkit::editing::store::RegisterError;
+use std::process::Command;
 use tokio;
 
 use matrix_sdk::{
@@ -27,6 +29,7 @@ use matrix_sdk::{
 };
 
 use modalkit::{
+    input::dialog::PromptYesNo,
     tui::{
         buffer::Buffer,
         layout::Rect,
@@ -40,6 +43,7 @@ use modalkit::{
 
 use modalkit::editing::{
     action::{
+        Action,
         EditError,
         EditInfo,
         EditResult,
@@ -75,7 +79,7 @@ use crate::base::{
     SendAction,
 };
 
-use crate::message::{Message, MessageEvent, MessageKey, MessageTimeStamp};
+use crate::message::{text_to_message, Message, MessageEvent, MessageKey, MessageTimeStamp};
 use crate::worker::Requester;
 
 use super::scrollback::{Scrollback, ScrollbackState};
@@ -163,59 +167,67 @@ impl ChatState {
             .ok_or(IambError::NoSelectedMessage)?;
 
         match act {
-            MessageAction::Cancel => {
+            MessageAction::Cancel(skip_confirm) => {
                 self.reply_to = None;
                 self.editing = None;
 
-                Ok(None)
+                if skip_confirm {
+                    return Ok(None);
+                }
+
+                let msg = "Would you like to clear the message bar?";
+                let act = PromptAction::Abort(false);
+                let prompt = PromptYesNo::new(msg, vec![Action::from(act)]);
+                let prompt = Box::new(prompt);
+
+                Err(UIError::NeedConfirm(prompt))
             },
             MessageAction::Download(filename, flags) => {
                 if let MessageEvent::Original(ev) = &msg.event {
                     let media = client.media();
 
-                    let mut filename = match filename {
-                        Some(f) => PathBuf::from(f),
-                        None => settings.dirs.downloads.clone(),
+                    let mut filename = match (filename, &settings.dirs.downloads) {
+                        (Some(f), _) => PathBuf::from(f),
+                        (None, Some(downloads)) => downloads.clone(),
+                        (None, None) => return Err(IambError::NoDownloadDir.into()),
                     };
 
-                    let source = match &ev.content.msgtype {
-                        MessageType::Audio(c) => {
-                            if filename.is_dir() {
-                                filename.push(c.body.as_str());
-                            }
-
-                            c.source.clone()
-                        },
+                    let (source, msg_filename) = match &ev.content.msgtype {
+                        MessageType::Audio(c) => (c.source.clone(), c.body.as_str()),
                         MessageType::File(c) => {
-                            if filename.is_dir() {
-                                if let Some(name) = &c.filename {
-                                    filename.push(name);
-                                } else {
-                                    filename.push(c.body.as_str());
-                                }
-                            }
-
-                            c.source.clone()
-                        },
-                        MessageType::Image(c) => {
-                            if filename.is_dir() {
-                                filename.push(c.body.as_str());
-                            }
-
-                            c.source.clone()
-                        },
-                        MessageType::Video(c) => {
-                            if filename.is_dir() {
-                                filename.push(c.body.as_str());
-                            }
-
-                            c.source.clone()
+                            (c.source.clone(), c.filename.as_deref().unwrap_or(c.body.as_str()))
                         },
+                        MessageType::Image(c) => (c.source.clone(), c.body.as_str()),
+                        MessageType::Video(c) => (c.source.clone(), c.body.as_str()),
                         _ => {
                             return Err(IambError::NoAttachment.into());
                         },
                     };
 
+                    if filename.is_dir() {
+                        filename.push(msg_filename);
+                    }
+
+                    if filename.exists() && !flags.contains(DownloadFlags::FORCE) {
+                        // Find an incrementally suffixed filename, e.g. image-2.jpg -> image-3.jpg
+                        if let Some(stem) = filename.file_stem().and_then(OsStr::to_str) {
+                            let ext = filename.extension();
+                            let mut filename_incr = filename.clone();
+                            for n in 1..=1000 {
+                                if let Some(ext) = ext.and_then(OsStr::to_str) {
+                                    filename_incr.set_file_name(format!("{}-{}.{}", stem, n, ext));
+                                } else {
+                                    filename_incr.set_file_name(format!("{}-{}", stem, n));
+                                }
+
+                                if !filename_incr.exists() {
+                                    filename = filename_incr;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
                     if !filename.exists() || flags.contains(DownloadFlags::FORCE) {
                         let req = MediaRequest { source, format: MediaFormat::File };
 
@@ -236,14 +248,21 @@ impl ChatState {
                     }
 
                     let info = if flags.contains(DownloadFlags::OPEN) {
-                        // open::that may not return until the spawned program closes.
                         let target = filename.clone().into_os_string();
-                        tokio::task::spawn_blocking(move || open::that(target));
-
-                        InfoMessage::from(format!(
-                            "Attachment downloaded to {} and opened",
-                            filename.display()
-                        ))
+                        match open_command(
+                            store.application.settings.tunables.open_command.as_ref(),
+                            target,
+                        ) {
+                            Ok(_) => {
+                                InfoMessage::from(format!(
+                                    "Attachment downloaded to {} and opened",
+                                    filename.display()
+                                ))
+                            },
+                            Err(err) => {
+                                return Err(err);
+                            },
+                        }
                     } else {
                         InfoMessage::from(format!(
                             "Attachment downloaded to {}",
@@ -286,6 +305,7 @@ impl ChatState {
                 };
 
                 self.tbox.set_text(text);
+                self.reply_to = msg.reply_to().and_then(|id| info.get_message_key(&id)).cloned();
                 self.editing = self.scrollback.get_key(info);
                 self.focus = RoomFocus::MessageBar;
 
@@ -312,7 +332,16 @@ impl ChatState {
 
                 Ok(None)
             },
-            MessageAction::Redact(reason) => {
+            MessageAction::Redact(reason, skip_confirm) => {
+                if !skip_confirm {
+                    let msg = "Are you sure you want to redact this message?";
+                    let act = IambAction::Message(MessageAction::Redact(reason, true));
+                    let prompt = PromptYesNo::new(msg, vec![Action::from(act)]);
+                    let prompt = Box::new(prompt);
+
+                    return Err(UIError::NeedConfirm(prompt));
+                }
+
                 let room = self.get_joined(&store.application.worker)?;
                 let event_id = match &msg.event {
                     MessageEvent::EncryptedOriginal(ev) => ev.event_id.clone(),
@@ -407,10 +436,7 @@ impl ChatState {
                     return Ok(None);
                 }
 
-                let msg = TextMessageEventContent::markdown(msg.to_string());
-                let msg = MessageType::Text(msg);
-
-                let mut msg = RoomMessageEventContent::new(msg);
+                let mut msg = text_to_message(msg.trim_end().to_string());
 
                 if let Some((_, event_id)) = &self.editing {
                     msg.relates_to = Some(Relation::Replacement(Replacement::new(
@@ -455,6 +481,36 @@ impl ChatState {
                 let msg = MessageType::Text(msg);
                 let msg = RoomMessageEventContent::new(msg);
 
+                (resp.event_id, msg)
+            },
+            SendAction::UploadImage(width, height, bytes) => {
+                // Convert to png because arboard does not give us the mime type.
+                let bytes =
+                    image::ImageBuffer::from_raw(width as _, height as _, bytes.into_owned())
+                        .ok_or(IambError::Clipboard)
+                        .and_then(|imagebuf| {
+                            let dynimage = image::DynamicImage::ImageRgba8(imagebuf);
+                            let bytes = Vec::<u8>::new();
+                            let mut buff = std::io::Cursor::new(bytes);
+                            dynimage.write_to(&mut buff, image::ImageOutputFormat::Png)?;
+                            Ok(buff.into_inner())
+                        })
+                        .map_err(IambError::from)?;
+                let mime = mime::IMAGE_PNG;
+
+                let name = "Clipboard.png";
+                let config = AttachmentConfig::new();
+
+                let resp = room
+                    .send_attachment(name.as_ref(), &mime, bytes.as_ref(), config)
+                    .await
+                    .map_err(IambError::from)?;
+
+                // Mock up the local echo message for the scrollback.
+                let msg = TextMessageEventContent::plain(format!("[Attached File: {name}]"));
+                let msg = MessageType::Text(msg);
+                let msg = RoomMessageEventContent::new(msg);
+
                 (resp.event_id, msg)
             },
         };
@@ -601,6 +657,15 @@ impl Editable<ProgramContext, ProgramStore, IambInfo> for ChatState {
                 // Run command again.
                 delegate!(self, w => w.editor_command(act, ctx, store))
             },
+            Err(EditError::Register(RegisterError::ClipboardImage(data))) => {
+                let msg = "Do you really want to upload the image from your system clipboard?";
+                let send =
+                    IambAction::Send(SendAction::UploadImage(data.width, data.height, data.bytes));
+                let prompt = PromptYesNo::new(msg, vec![Action::from(send)]);
+                let prompt = Box::new(prompt);
+
+                Err(EditError::NeedConfirm(prompt))
+            },
             res @ Err(_) => res,
         }
     }
@@ -677,13 +742,14 @@ impl PromptActions<ProgramContext, ProgramStore, IambInfo> for ChatState {
         &mut self,
         dir: &MoveDir1D,
         count: &Count,
+        prefixed: bool,
         ctx: &ProgramContext,
         _: &mut ProgramStore,
     ) -> EditResult<Vec<(ProgramAction, ProgramContext)>, IambInfo> {
         let count = ctx.resolve(count);
         let rope = self.tbox.get();
 
-        let text = self.sent.recall(&rope, &mut self.sent_scrollback, *dir, count);
+        let text = self.sent.recall(&rope, &mut self.sent_scrollback, *dir, prefixed, count);
 
         if let Some(text) = text {
             self.tbox.set_text(text);
@@ -707,7 +773,9 @@ impl Promptable<ProgramContext, ProgramStore, IambInfo> for ChatState {
         match act {
             PromptAction::Submit => self.submit(ctx, store),
             PromptAction::Abort(empty) => self.abort(*empty, ctx, store),
-            PromptAction::Recall(dir, count) => self.recall(dir, count, ctx, store),
+            PromptAction::Recall(dir, count, prefixed) => {
+                self.recall(dir, count, *prefixed, ctx, store)
+            },
             _ => Err(EditError::Unimplemented("unknown prompt action".to_string())),
         }
     }
@@ -733,10 +801,33 @@ impl<'a> StatefulWidget for Chat<'a> {
     type State = ChatState;
 
     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        // Determine whether we have a description to show for the message bar.
+        let desc_spans = match (&state.editing, &state.reply_to) {
+            (None, None) => None,
+            (Some(_), None) => Some(Spans::from("Editing message")),
+            (editing, Some(_)) => {
+                state.reply_to.as_ref().and_then(|k| {
+                    let room = self.store.application.rooms.get(state.id())?;
+                    let msg = room.messages.get(k)?;
+                    let user =
+                        self.store.application.settings.get_user_span(msg.sender.as_ref(), room);
+                    let prefix = if editing.is_some() {
+                        Span::from("Editing reply to ")
+                    } else {
+                        Span::from("Replying to ")
+                    };
+                    let spans = Spans(vec![prefix, user]);
+
+                    spans.into()
+                })
+            },
+        };
+
+        // Determine the region to show each UI element.
         let lines = state.tbox.has_lines(5).max(1) as u16;
         let drawh = area.height;
         let texth = lines.min(drawh).clamp(1, 5);
-        let desch = if state.reply_to.is_some() {
+        let desch = if desc_spans.is_some() {
             drawh.saturating_sub(texth).min(1)
         } else {
             0
@@ -747,25 +838,7 @@ impl<'a> StatefulWidget for Chat<'a> {
         let descarea = Rect::new(area.x, scrollarea.y + scrollh, area.width, desch);
         let textarea = Rect::new(area.x, descarea.y + desch, area.width, texth);
 
-        let scrollback_focused = state.focus.is_scrollback() && self.focused;
-        let scrollback = Scrollback::new(self.store).focus(scrollback_focused);
-        scrollback.render(scrollarea, buf, &mut state.scrollback);
-
-        let desc_spans = match (&state.editing, &state.reply_to) {
-            (None, None) => None,
-            (Some(_), _) => Some(Spans::from("Editing message")),
-            (_, Some(_)) => {
-                state.reply_to.as_ref().and_then(|k| {
-                    let room = self.store.application.rooms.get(state.id())?;
-                    let msg = room.messages.get(k)?;
-                    let user = self.store.application.settings.get_user_span(msg.sender.as_ref());
-                    let spans = Spans(vec![Span::from("Replying to "), user]);
-
-                    spans.into()
-                })
-            },
-        };
-
+        // Render the message bar and any description for it.
         if let Some(desc_spans) = desc_spans {
             Paragraph::new(desc_spans).render(descarea, buf);
         }
@@ -774,5 +847,35 @@ impl<'a> StatefulWidget for Chat<'a> {
 
         let tbox = TextBox::new().prompt(prompt);
         tbox.render(textarea, buf, &mut state.tbox);
+
+        // Render the message scrollback.
+        let scrollback_focused = state.focus.is_scrollback() && self.focused;
+        let scrollback = Scrollback::new(self.store)
+            .focus(scrollback_focused)
+            .room_focus(self.focused);
+        scrollback.render(scrollarea, buf, &mut state.scrollback);
     }
 }
+
+fn open_command(open_command: Option<&Vec<String>>, target: OsString) -> IambResult<()> {
+    if let Some(mut cmd) = open_command.and_then(cmd) {
+        cmd.arg(target);
+        cmd.spawn()?;
+        return Ok(());
+    } else {
+        // open::that may not return until the spawned program closes.
+        tokio::task::spawn_blocking(move || {
+            return open::that(target);
+        });
+        return Ok(());
+    }
+}
+
+fn cmd(open_command: &Vec<String>) -> Option<Command> {
+    if let [program, args @ ..] = open_command.as_slice() {
+        let mut cmd = Command::new(program);
+        cmd.args(args);
+        return Some(cmd);
+    }
+    None
+}

src/windows/room/mod.rs

@@ -43,11 +43,13 @@ use modalkit::{
         WriteFlags,
     },
     editing::completion::CompletionList,
+    input::dialog::PromptYesNo,
     input::InputContext,
     widgets::{TermOffset, TerminalCursor, WindowOps},
 };
 
 use crate::base::{
+    IambAction,
     IambError,
     IambId,
     IambInfo,
@@ -137,8 +139,9 @@ impl RoomState {
         let mut invited = vec![Span::from(format!("You have been invited to join {name}"))];
 
         if let Ok(Some(inviter)) = &inviter {
+            let info = store.application.rooms.get_or_default(self.id().to_owned());
             invited.push(Span::from(" by "));
-            invited.push(store.application.settings.get_user_span(inviter.user_id()));
+            invited.push(store.application.settings.get_user_span(inviter.user_id(), info));
         }
 
         let l1 = Spans(invited);
@@ -218,6 +221,24 @@ impl RoomState {
                     Err(IambError::NotJoined.into())
                 }
             },
+            RoomAction::Leave(skip_confirm) => {
+                if let Some(room) = store.application.worker.client.get_joined_room(self.id()) {
+                    if skip_confirm {
+                        room.leave().await.map_err(IambError::from)?;
+
+                        Ok(vec![])
+                    } else {
+                        let msg = "Do you really want to leave this room?";
+                        let leave = IambAction::Room(RoomAction::Leave(true));
+                        let prompt = PromptYesNo::new(msg, vec![Action::from(leave)]);
+                        let prompt = Box::new(prompt);
+
+                        Err(UIError::NeedConfirm(prompt))
+                    }
+                } else {
+                    Err(IambError::NotJoined.into())
+                }
+            },
             RoomAction::Members(mut cmd) => {
                 let width = Count::Exact(30);
                 let act =

src/windows/room/scrollback.rs

@@ -4,7 +4,13 @@ use regex::Regex;
 
 use matrix_sdk::ruma::OwnedRoomId;
 
-use modalkit::tui::{buffer::Buffer, layout::Rect, widgets::StatefulWidget};
+use modalkit::tui::{
+    buffer::Buffer,
+    layout::{Alignment, Rect},
+    style::{Modifier as StyleModifier, Style},
+    text::{Span, Spans},
+    widgets::{Paragraph, StatefulWidget, Widget},
+};
 use modalkit::widgets::{ScrollActions, TerminalCursor, WindowOps};
 
 use modalkit::editing::{
@@ -1205,14 +1211,43 @@ impl TerminalCursor for ScrollbackState {
     }
 }
 
+fn render_jump_to_recent(area: Rect, buf: &mut Buffer, focused: bool) -> Rect {
+    if area.height <= 5 || area.width <= 20 {
+        return area;
+    }
+
+    let top = Rect::new(area.x, area.y, area.width, area.height - 1);
+    let bar = Rect::new(area.x, area.y + top.height, area.width, 1);
+    let msg = vec![
+        Span::raw("Use "),
+        Span::styled("G", Style::default().add_modifier(StyleModifier::BOLD)),
+        Span::raw(if focused { "" } else { " in scrollback" }),
+        Span::raw(" to jump to latest message"),
+    ];
+
+    Paragraph::new(Spans::from(msg))
+        .alignment(Alignment::Center)
+        .render(bar, buf);
+
+    return top;
+}
+
 pub struct Scrollback<'a> {
+    room_focused: bool,
     focused: bool,
     store: &'a mut ProgramStore,
 }
 
 impl<'a> Scrollback<'a> {
     pub fn new(store: &'a mut ProgramStore) -> Self {
-        Scrollback { focused: false, store }
+        Scrollback { room_focused: false, focused: false, store }
+    }
+
+    /// Indicate whether the room window is currently focused, regardless of whether the scrollback
+    /// also is.
+    pub fn room_focus(mut self, focused: bool) -> Self {
+        self.room_focused = focused;
+        self
     }
 
     /// Indicate whether the scrollback is currently focused.
@@ -1228,7 +1263,11 @@ impl<'a> StatefulWidget for Scrollback<'a> {
     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
         let info = self.store.application.rooms.get_or_default(state.room_id.clone());
         let settings = &self.store.application.settings;
-        let area = info.render_typing(area, buf, &self.store.application.settings);
+        let area = if state.cursor.timestamp.is_some() {
+            render_jump_to_recent(area, buf, self.focused)
+        } else {
+            info.render_typing(area, buf, &self.store.application.settings)
+        };
 
         state.set_term_info(area);
 
@@ -1307,7 +1346,10 @@ impl<'a> StatefulWidget for Scrollback<'a> {
             y += 1;
         }
 
-        if settings.tunables.read_receipt_send && state.cursor.timestamp.is_none() {
+        if self.room_focused &&
+            settings.tunables.read_receipt_send &&
+            state.cursor.timestamp.is_none()
+        {
             // If the cursor is at the last message, then update the read marker.
             info.read_till = info.messages.last_key_value().map(|(k, _)| k.1.clone());
         }

src/windows/room/space.rs

@@ -1,11 +1,18 @@
 use std::ops::{Deref, DerefMut};
+use std::time::{Duration, Instant};
 
 use matrix_sdk::{
     room::Room as MatrixRoom,
     ruma::{OwnedRoomId, RoomId},
 };
 
-use modalkit::tui::{buffer::Buffer, layout::Rect, widgets::StatefulWidget};
+use modalkit::tui::{
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    text::{Span, Spans, Text},
+    widgets::StatefulWidget,
+};
 
 use modalkit::{
     widgets::list::{List, ListState},
@@ -16,10 +23,13 @@ use crate::base::{IambBufferId, IambInfo, ProgramStore, RoomFocus};
 
 use crate::windows::RoomItem;
 
+const SPACE_HIERARCHY_DEBOUNCE: Duration = Duration::from_secs(5);
+
 pub struct SpaceState {
     room_id: OwnedRoomId,
     room: MatrixRoom,
     list: ListState<RoomItem, IambInfo>,
+    last_fetch: Option<Instant>,
 }
 
 impl SpaceState {
@@ -27,8 +37,9 @@ impl SpaceState {
         let room_id = room.room_id().to_owned();
         let content = IambBufferId::Room(room_id.clone(), RoomFocus::Scrollback);
         let list = ListState::new(content, vec![]);
+        let last_fetch = None;
 
-        SpaceState { room_id, room, list }
+        SpaceState { room_id, room, list, last_fetch }
     }
 
     pub fn refresh_room(&mut self, store: &mut ProgramStore) {
@@ -50,6 +61,7 @@ impl SpaceState {
             room_id: self.room_id.clone(),
             room: self.room.clone(),
             list: self.list.dup(store),
+            last_fetch: self.last_fetch,
         }
     }
 }
@@ -94,30 +106,52 @@ impl<'a> StatefulWidget for Space<'a> {
     type State = SpaceState;
 
     fn render(self, area: Rect, buffer: &mut Buffer, state: &mut Self::State) {
-        let members =
-            if let Ok(m) = self.store.application.worker.space_members(state.room_id.clone()) {
-                m
-            } else {
-                return;
-            };
+        let mut empty_message = None;
+        let need_fetch = match state.last_fetch {
+            Some(i) => i.elapsed() >= SPACE_HIERARCHY_DEBOUNCE,
+            None => true,
+        };
 
-        let items = members
-            .into_iter()
-            .filter_map(|id| {
-                let (room, name, tags) = self.store.application.worker.get_room(id.clone()).ok()?;
+        if need_fetch {
+            let res = self.store.application.worker.space_members(state.room_id.clone());
 
-                if id != state.room_id {
-                    Some(RoomItem::new(room, name, tags, self.store))
-                } else {
-                    None
-                }
-            })
-            .collect();
+            match res {
+                Ok(members) => {
+                    let items = members
+                        .into_iter()
+                        .filter_map(|id| {
+                            let (room, _, tags) =
+                                self.store.application.worker.get_room(id.clone()).ok()?;
+                            let room_info = std::sync::Arc::new((room, tags));
 
-        state.list.set(items);
+                            if id != state.room_id {
+                                Some(RoomItem::new(room_info, self.store))
+                            } else {
+                                None
+                            }
+                        })
+                        .collect();
 
-        List::new(self.store)
-            .focus(self.focused)
-            .render(area, buffer, &mut state.list)
+                    state.list.set(items);
+                    state.last_fetch = Some(Instant::now());
+                },
+                Err(e) => {
+                    let lines = vec![
+                        Spans::from("Unable to fetch space room hierarchy:"),
+                        Span::styled(e.to_string(), Style::default().fg(Color::Red)).into(),
+                    ];
+
+                    empty_message = Text { lines }.into();
+                },
+            }
+        }
+
+        let mut list = List::new(self.store).focus(self.focused);
+
+        if let Some(text) = empty_message {
+            list = list.empty_message(text);
+        }
+
+        list.render(area, buffer, &mut state.list)
     }
 }

src/worker.rs

@@ -8,6 +8,7 @@ use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
+use futures::{stream::FuturesUnordered, StreamExt};
 use gethostname::gethostname;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tokio::task::JoinHandle;
@@ -21,7 +22,6 @@ use matrix_sdk::{
     room::{Invited, Messages, MessagesOptions, Room as MatrixRoom, RoomMember},
     ruma::{
         api::client::{
-            filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
             room::create_room::v3::{CreationContent, Request as CreateRoomRequest, RoomPreset},
             room::Visibility,
             space::get_hierarchy::v1::Request as SpaceHierarchyRequest,
@@ -39,6 +39,7 @@ use matrix_sdk::{
             reaction::ReactionEventContent,
             room::{
                 encryption::RoomEncryptionEventContent,
+                member::OriginalSyncRoomMemberEvent,
                 message::{MessageType, RoomMessageEventContent},
                 name::RoomNameEventContent,
                 redaction::{OriginalSyncRoomRedactionEvent, SyncRoomRedactionEvent},
@@ -56,6 +57,7 @@ use matrix_sdk::{
         room::RoomType,
         serde::Raw,
         EventEncryptionAlgorithm,
+        OwnedEventId,
         OwnedRoomId,
         OwnedRoomOrAliasId,
         OwnedUserId,
@@ -259,19 +261,122 @@ async fn load_insert(room_id: OwnedRoomId, res: MessageFetchResult, store: Async
     }
 }
 
-async fn load_older(client: &Client, store: &AsyncProgramStore) {
+async fn load_older(client: &Client, store: &AsyncProgramStore) -> usize {
     let limit = MIN_MSG_LOAD;
-    let plan = load_plan(store).await;
 
     // Fetch each room separately, so they don't block each other.
-    for (room_id, fetch_id) in plan.into_iter() {
-        let client = client.clone();
-        let store = store.clone();
+    load_plan(store)
+        .await
+        .into_iter()
+        .map(|(room_id, fetch_id)| {
+            let client = client.clone();
+            let store = store.clone();
 
-        tokio::spawn(async move {
-            let res = load_older_one(client, room_id.as_ref(), fetch_id, limit).await;
-            load_insert(room_id, res, store).await;
-        });
+            async move {
+                let res = load_older_one(client, room_id.as_ref(), fetch_id, limit).await;
+                load_insert(room_id, res, store).await;
+            }
+        })
+        .collect::<FuturesUnordered<_>>()
+        .count()
+        .await
+}
+
+async fn load_older_forever(client: &Client, store: &AsyncProgramStore) {
+    // Load older messages every 2 seconds.
+    let mut interval = tokio::time::interval(Duration::from_secs(2));
+
+    loop {
+        interval.tick().await;
+        load_older(client, store).await;
+    }
+}
+
+async fn refresh_rooms(client: &Client, store: &AsyncProgramStore) {
+    let mut names = vec![];
+
+    let mut spaces = vec![];
+    let mut rooms = vec![];
+    let mut dms = vec![];
+
+    for room in client.invited_rooms().into_iter() {
+        let name = room.display_name().await.unwrap_or(DisplayName::Empty).to_string();
+        names.push((room.room_id().to_owned(), name));
+
+        if room.is_direct() {
+            let tags = room.tags().await.unwrap_or_default();
+
+            dms.push(Arc::new((room.into(), tags)));
+        } else if room.is_space() {
+            spaces.push(room.into());
+        } else {
+            let tags = room.tags().await.unwrap_or_default();
+
+            rooms.push(Arc::new((room.into(), tags)));
+        }
+    }
+
+    for room in client.joined_rooms().into_iter() {
+        let name = room.display_name().await.unwrap_or(DisplayName::Empty).to_string();
+        names.push((room.room_id().to_owned(), name));
+
+        if room.is_direct() {
+            let tags = room.tags().await.unwrap_or_default();
+
+            dms.push(Arc::new((room.into(), tags)));
+        } else if room.is_space() {
+            spaces.push(room.into());
+        } else {
+            let tags = room.tags().await.unwrap_or_default();
+
+            rooms.push(Arc::new((room.into(), tags)));
+        }
+    }
+
+    let mut locked = store.lock().await;
+    locked.application.sync_info.spaces = spaces;
+    locked.application.sync_info.rooms = rooms;
+    locked.application.sync_info.dms = dms;
+
+    for (room_id, name) in names {
+        locked.application.set_room_name(&room_id, &name);
+    }
+}
+
+async fn refresh_rooms_forever(client: &Client, store: &AsyncProgramStore) {
+    let mut interval = tokio::time::interval(Duration::from_secs(5));
+
+    loop {
+        interval.tick().await;
+
+        refresh_rooms(client, store).await;
+    }
+}
+
+async fn refresh_receipts_forever(client: &Client, store: &AsyncProgramStore) {
+    // Update the displayed read receipts every 5 seconds.
+    let mut interval = tokio::time::interval(Duration::from_secs(5));
+    let mut sent = HashMap::<OwnedRoomId, OwnedEventId>::default();
+
+    loop {
+        interval.tick().await;
+        let receipts = update_receipts(client).await;
+        let read = store.lock().await.application.set_receipts(receipts).await;
+
+        for (room_id, read_till) in read.into_iter() {
+            if let Some(read_sent) = sent.get(&room_id) {
+                if read_sent == &read_till {
+                    // Skip unchanged receipts.
+                    continue;
+                }
+            }
+
+            if let Some(room) = client.get_joined_room(&room_id) {
+                if room.read_receipt(&read_till).await.is_ok() {
+                    sent.insert(room_id, read_till);
+                }
+            }
+        }
     }
 }
 
@@ -330,8 +435,6 @@ async fn update_receipts(client: &Client) -> Vec<(OwnedRoomId, Receipts)> {
 pub type FetchedRoom = (MatrixRoom, DisplayName, Option<Tags>);
 
 pub enum WorkerTask {
-    ActiveRooms(ClientReply<Vec<FetchedRoom>>),
-    DirectMessages(ClientReply<Vec<FetchedRoom>>),
     Init(AsyncProgramStore, ClientReply<()>),
     Login(LoginStyle, ClientReply<IambResult<EditInfo>>),
     GetInviter(Invited, ClientReply<IambResult<Option<RoomMember>>>),
@@ -339,7 +442,6 @@ pub enum WorkerTask {
     JoinRoom(String, ClientReply<IambResult<OwnedRoomId>>),
     Members(OwnedRoomId, ClientReply<IambResult<Vec<RoomMember>>>),
     SpaceMembers(OwnedRoomId, ClientReply<IambResult<Vec<OwnedRoomId>>>),
-    Spaces(ClientReply<Vec<(MatrixRoom, DisplayName)>>),
     TypingNotice(OwnedRoomId),
     Verify(VerifyAction, SasVerification, ClientReply<IambResult<EditInfo>>),
     VerifyRequest(OwnedUserId, ClientReply<IambResult<EditInfo>>),
@@ -348,14 +450,6 @@ pub enum WorkerTask {
 impl Debug for WorkerTask {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
         match self {
-            WorkerTask::ActiveRooms(_) => {
-                f.debug_tuple("WorkerTask::ActiveRooms").field(&format_args!("_")).finish()
-            },
-            WorkerTask::DirectMessages(_) => {
-                f.debug_tuple("WorkerTask::DirectMessages")
-                    .field(&format_args!("_"))
-                    .finish()
-            },
             WorkerTask::Init(_, _) => {
                 f.debug_tuple("WorkerTask::Init")
                     .field(&format_args!("_"))
@@ -395,9 +489,6 @@ impl Debug for WorkerTask {
                     .field(&format_args!("_"))
                     .finish()
             },
-            WorkerTask::Spaces(_) => {
-                f.debug_tuple("WorkerTask::Spaces").field(&format_args!("_")).finish()
-            },
             WorkerTask::TypingNotice(room_id) => {
                 f.debug_tuple("WorkerTask::TypingNotice").field(room_id).finish()
             },
@@ -441,14 +532,6 @@ impl Requester {
         return response.recv();
     }
 
-    pub fn direct_messages(&self) -> Vec<FetchedRoom> {
-        let (reply, response) = oneshot();
-
-        self.tx.send(WorkerTask::DirectMessages(reply)).unwrap();
-
-        return response.recv();
-    }
-
     pub fn get_inviter(&self, invite: Invited) -> IambResult<Option<RoomMember>> {
         let (reply, response) = oneshot();
 
@@ -473,14 +556,6 @@ impl Requester {
         return response.recv();
     }
 
-    pub fn active_rooms(&self) -> Vec<FetchedRoom> {
-        let (reply, response) = oneshot();
-
-        self.tx.send(WorkerTask::ActiveRooms(reply)).unwrap();
-
-        return response.recv();
-    }
-
     pub fn members(&self, room_id: OwnedRoomId) -> IambResult<Vec<RoomMember>> {
         let (reply, response) = oneshot();
 
@@ -497,14 +572,6 @@ impl Requester {
         return response.recv();
     }
 
-    pub fn spaces(&self) -> Vec<(MatrixRoom, DisplayName)> {
-        let (reply, response) = oneshot();
-
-        self.tx.send(WorkerTask::Spaces(reply)).unwrap();
-
-        return response.recv();
-    }
-
     pub fn typing_notice(&self, room_id: OwnedRoomId) {
         self.tx.send(WorkerTask::TypingNotice(room_id)).unwrap();
     }
@@ -531,7 +598,6 @@ pub struct ClientWorker {
     settings: ApplicationSettings,
     client: Client,
     load_handle: Option<JoinHandle<()>>,
-    rcpt_handle: Option<JoinHandle<()>>,
     sync_handle: Option<JoinHandle<()>>,
 }
 
@@ -570,7 +636,6 @@ impl ClientWorker {
             settings,
             client: client.clone(),
             load_handle: None,
-            rcpt_handle: None,
             sync_handle: None,
         };
 
@@ -596,18 +661,10 @@ impl ClientWorker {
         if let Some(handle) = self.sync_handle.take() {
             handle.abort();
         }
-
-        if let Some(handle) = self.rcpt_handle.take() {
-            handle.abort();
-        }
     }
 
     async fn run(&mut self, task: WorkerTask) {
         match task {
-            WorkerTask::DirectMessages(reply) => {
-                assert!(self.initialized);
-                reply.send(self.direct_messages().await);
-            },
             WorkerTask::Init(store, reply) => {
                 assert_eq!(self.initialized, false);
                 self.init(store).await;
@@ -625,10 +682,6 @@ impl ClientWorker {
                 assert!(self.initialized);
                 reply.send(self.get_room(room_id).await);
             },
-            WorkerTask::ActiveRooms(reply) => {
-                assert!(self.initialized);
-                reply.send(self.active_rooms().await);
-            },
             WorkerTask::Login(style, reply) => {
                 assert!(self.initialized);
                 reply.send(self.login_and_sync(style).await);
@@ -641,10 +694,6 @@ impl ClientWorker {
                 assert!(self.initialized);
                 reply.send(self.space_members(space).await);
             },
-            WorkerTask::Spaces(reply) => {
-                assert!(self.initialized);
-                reply.send(self.spaces().await);
-            },
             WorkerTask::TypingNotice(room_id) => {
                 assert!(self.initialized);
                 self.typing_notice(room_id).await;
@@ -789,6 +838,38 @@ impl ClientWorker {
             },
         );
 
+        let _ = self.client.add_event_handler(
+            |ev: OriginalSyncRoomMemberEvent,
+             room: MatrixRoom,
+             client: Client,
+             store: Ctx<AsyncProgramStore>| {
+                async move {
+                    let room_id = room.room_id();
+                    let user_id = ev.state_key;
+
+                    let ambiguous_name =
+                        ev.content.displayname.as_deref().unwrap_or_else(|| user_id.localpart());
+                    let ambiguous = client
+                        .store()
+                        .get_users_with_display_name(room_id, ambiguous_name)
+                        .await
+                        .map(|users| users.len() > 1)
+                        .unwrap_or_default();
+
+                    let mut locked = store.lock().await;
+                    let info = locked.application.get_room_info(room_id.to_owned());
+
+                    if ambiguous {
+                        info.display_names.remove(&user_id);
+                    } else if let Some(display) = ev.content.displayname {
+                        info.display_names.insert(user_id, display);
+                    } else {
+                        info.display_names.remove(&user_id);
+                    }
+                }
+            },
+        );
+
         let _ = self.client.add_event_handler(
             |ev: OriginalSyncKeyVerificationStartEvent,
              client: Client,
@@ -845,10 +926,11 @@ impl ClientWorker {
                     let request = client
                         .encryption()
                         .get_verification_request(&ev.sender, &ev.content.transaction_id)
-                        .await
-                        .unwrap();
+                        .await;
 
-                    request.accept().await.unwrap();
+                    if let Some(request) = request {
+                        request.accept().await.unwrap();
+                    }
                 }
             },
         );
@@ -901,34 +983,14 @@ impl ClientWorker {
             },
         );
 
-        self.rcpt_handle = tokio::spawn({
-            let store = store.clone();
-            let client = self.client.clone();
-
-            async move {
-                // Update the displayed read receipts every 5 seconds.
-                let mut interval = tokio::time::interval(Duration::from_secs(5));
-
-                loop {
-                    interval.tick().await;
-
-                    let receipts = update_receipts(&client).await;
-                    store.lock().await.application.set_receipts(receipts).await;
-                }
-            }
-        })
-        .into();
-
         self.load_handle = tokio::spawn({
             let client = self.client.clone();
 
             async move {
-                // Load older messages every 2 seconds.
-                let mut interval = tokio::time::interval(Duration::from_secs(2));
-                loop {
-                    interval.tick().await;
-                    load_older(&client, &store).await;
-                }
+                let load = load_older_forever(&client, &store);
+                let rcpt = refresh_receipts_forever(&client, &store);
+                let room = refresh_rooms_forever(&client, &store);
+                let ((), (), ()) = tokio::join!(load, rcpt, room);
             }
         })
         .into();
@@ -957,58 +1019,42 @@ impl ClientWorker {
             },
         }
 
-        let handle = tokio::spawn(async move {
+        self.sync_handle = tokio::spawn(async move {
             loop {
                 let settings = SyncSettings::default();
 
                 let _ = client.sync(settings).await;
             }
-        });
-
-        self.sync_handle = Some(handle);
-
-        // Perform an initial, lazily-loaded sync.
-        let mut room = RoomEventFilter::default();
-        room.lazy_load_options = LazyLoadOptions::Enabled { include_redundant_members: false };
-
-        let mut room_ev = RoomFilter::default();
-        room_ev.state = room;
-
-        let mut filter = FilterDefinition::default();
-        filter.room = room_ev;
-
-        let settings = SyncSettings::new().filter(filter.into());
-
-        self.client.sync_once(settings).await.map_err(IambError::from)?;
+        })
+        .into();
 
         Ok(Some(InfoMessage::from("Successfully logged in!")))
     }
 
-    async fn direct_message(&mut self, user: OwnedUserId) -> IambResult<FetchedRoom> {
-        for (room, name, tags) in self.direct_messages().await {
+    async fn direct_message(&mut self, user: OwnedUserId) -> IambResult<OwnedRoomId> {
+        for room in self.client.rooms() {
+            if !room.is_direct() {
+                continue;
+            }
+
             if room.get_member(user.as_ref()).await.map_err(IambError::from)?.is_some() {
-                return Ok((room, name, tags));
+                return Ok(room.room_id().to_owned());
             }
         }
 
         let rt = CreateRoomType::Direct(user.clone());
         let flags = CreateRoomFlags::ENCRYPTED;
 
-        match create_room(&self.client, None, rt, flags).await {
-            Ok(room_id) => self.get_room(room_id).await,
-            Err(e) => {
-                error!(
-                    user_id = user.as_str(),
-                    err = e.to_string(),
-                    "Failed to create direct message room"
-                );
+        create_room(&self.client, None, rt, flags).await.map_err(|e| {
+            error!(
+                user_id = user.as_str(),
+                err = e.to_string(),
+                "Failed to create direct message room"
+            );
 
-                let msg = format!("Could not open a room with {user}");
-                let err = UIError::Failure(msg);
-
-                Err(err)
-            },
-        }
+            let msg = format!("Could not open a room with {user}");
+            UIError::Failure(msg)
+        })
     }
 
     async fn get_inviter(&mut self, invited: Invited) -> IambResult<Option<RoomMember>> {
@@ -1040,9 +1086,7 @@ impl ClientWorker {
                 },
             }
         } else if let Ok(user) = OwnedUserId::try_from(name.as_str()) {
-            let room = self.direct_message(user).await?.0;
-
-            return Ok(room.room_id().to_owned());
+            self.direct_message(user).await
         } else {
             let msg = format!("{:?} is not a valid room or user name", name.as_str());
             let err = UIError::Failure(msg);
@@ -1051,62 +1095,6 @@ impl ClientWorker {
         }
     }
 
-    async fn direct_messages(&self) -> Vec<FetchedRoom> {
-        let mut rooms = vec![];
-
-        for room in self.client.invited_rooms().into_iter() {
-            if !room.is_direct() {
-                continue;
-            }
-
-            let name = room.display_name().await.unwrap_or(DisplayName::Empty);
-            let tags = room.tags().await.unwrap_or_default();
-
-            rooms.push((room.into(), name, tags));
-        }
-
-        for room in self.client.joined_rooms().into_iter() {
-            if !room.is_direct() {
-                continue;
-            }
-
-            let name = room.display_name().await.unwrap_or(DisplayName::Empty);
-            let tags = room.tags().await.unwrap_or_default();
-
-            rooms.push((room.into(), name, tags));
-        }
-
-        return rooms;
-    }
-
-    async fn active_rooms(&self) -> Vec<FetchedRoom> {
-        let mut rooms = vec![];
-
-        for room in self.client.invited_rooms().into_iter() {
-            if room.is_space() || room.is_direct() {
-                continue;
-            }
-
-            let name = room.display_name().await.unwrap_or(DisplayName::Empty);
-            let tags = room.tags().await.unwrap_or_default();
-
-            rooms.push((room.into(), name, tags));
-        }
-
-        for room in self.client.joined_rooms().into_iter() {
-            if room.is_space() || room.is_direct() {
-                continue;
-            }
-
-            let name = room.display_name().await.unwrap_or(DisplayName::Empty);
-            let tags = room.tags().await.unwrap_or_default();
-
-            rooms.push((room.into(), name, tags));
-        }
-
-        return rooms;
-    }
-
     async fn members(&mut self, room_id: OwnedRoomId) -> IambResult<Vec<RoomMember>> {
         if let Some(room) = self.client.get_room(room_id.as_ref()) {
             Ok(room.active_members().await.map_err(IambError::from)?)
@@ -1127,32 +1115,6 @@ impl ClientWorker {
         Ok(rooms)
     }
 
-    async fn spaces(&self) -> Vec<(MatrixRoom, DisplayName)> {
-        let mut spaces = vec![];
-
-        for room in self.client.invited_rooms().into_iter() {
-            if !room.is_space() {
-                continue;
-            }
-
-            let name = room.display_name().await.unwrap_or(DisplayName::Empty);
-
-            spaces.push((room.into(), name));
-        }
-
-        for room in self.client.joined_rooms().into_iter() {
-            if !room.is_space() {
-                continue;
-            }
-
-            let name = room.display_name().await.unwrap_or(DisplayName::Empty);
-
-            spaces.push((room.into(), name));
-        }
-
-        return spaces;
-    }
-
     async fn typing_notice(&mut self, room_id: OwnedRoomId) {
         if let Some(room) = self.client.get_joined_room(room_id.as_ref()) {
             let _ = room.typing_notice(true).await;
@@ -1215,7 +1177,7 @@ impl ClientWorker {
                 let _req = request.await.map_err(IambError::from)?;
                 let info = format!("Sent verification request to {user_id}");
 
-                Ok(InfoMessage::from(info).into())
+                Ok(Some(InfoMessage::from(info)))
             },
             None => {
                 let msg = format!("Could not find identity information for {user_id}");