Minimal buflist with just the room ids

src/app.rs

@@ -28,8 +28,9 @@ use tokio::sync::mpsc;
 
 use crate::{
   action::Action,
+  buffers::{Buffers, RoomBuffer},
   commands::RataCommands,
-  components::{fps::FpsCounter, home::Home, Component},
+  components::{FpsCounter, Home, Component},
   config::Config,
   mode::Mode,
   tui,
@@ -42,6 +43,7 @@ pub struct App {
   pub tick_rate: f64,
   pub frame_rate: f64,
   pub components: Vec<Box<dyn Component>>,
+  pub buffers: Buffers,
   pub should_quit: AtomicBool,
   pub should_suspend: bool,
   pub mode: Mode,
@@ -114,6 +116,7 @@ impl App {
       components: vec![Box::new(home), Box::new(fps)],
       should_quit: AtomicBool::new(false),
       should_suspend: false,
+      buffers: Buffers::new(),
       clients,
       config,
       commands: RataCommands::new(),
@@ -146,12 +149,18 @@ impl App {
       component.init(tui.size()?)?;
     }
 
+    for client in &self.clients {
+      for room in client.joined_rooms() {
+        self.buffers.push(Box::new(RoomBuffer::new(vec![client.clone()], room.room_id().to_owned())));
+      }
+    }
+
     let sync_clients = self.clients.clone();
     let mut sync_results = FuturesUnordered::new();
     for client in sync_clients.iter() {
       client.add_event_handler(
         |ev: matrix_sdk::ruma::events::room::message::SyncRoomMessageEvent| async move {
-          println!("Received a message {:?}", ev);
+          // TODO
         },
       );
       let server_name = client.user_id().expect("missing user id").server_name();
@@ -215,7 +224,7 @@ impl App {
             tui.resize(Rect::new(0, 0, w, h))?;
             tui.draw(|f| {
               for component in self.components.iter_mut() {
-                let r = component.draw(f, f.size());
+                let r = component.draw(f, f.size(), &self.buffers);
                 if let Err(e) = r {
                   action_tx
                     .send(Action::Error(format!("Failed to draw: {:?}", e)))
@@ -227,7 +236,7 @@ impl App {
           Action::Render => {
             tui.draw(|f| {
               for component in self.components.iter_mut() {
-                let r = component.draw(f, f.size());
+                let r = component.draw(f, f.size(), &self.buffers);
                 if let Err(e) = r {
                   action_tx
                     .send(Action::Error(format!("Failed to draw: {:?}", e)))
@@ -239,7 +248,7 @@ impl App {
           _ => {},
         }
         for component in self.components.iter_mut() {
-          if let Some(action) = component.update(action.clone())? {
+          if let Some(action) = component.update(&action)? {
             action_tx.send(action)?
           };
         }
@@ -303,7 +312,7 @@ impl App {
     client: matrix_sdk::Client,
     sync_response: matrix_sdk::sync::SyncResponse,
   ) -> Result<()> {
-    println!("{:?}", sync_response);
+    // TODO
     Ok(())
   }
 }

src/buffers/mod.rs

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2023  Valentin Lorentz
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+mod room;
+pub use room::RoomBuffer;
+
+pub trait Buffer {
+  /// A short human-readable name for the room, eg. to show in compact buflist
+  fn short_name(&self) -> String;
+}
+
+pub struct Buffers(Vec<Box<dyn Buffer>>);
+
+impl Buffers {
+  pub fn new() -> Self {
+    Self(Vec::new())
+  }
+
+  pub fn iter(&self) -> impl Iterator<Item=&dyn Buffer> {
+    self.0.iter().map(|buffer_box| &**buffer_box)
+  }
+
+  pub fn push(&mut self, buffer: Box<dyn Buffer>) {
+    self.0.push(buffer)
+  }
+}

src/buffers/room.rs

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023  Valentin Lorentz
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use matrix_sdk::Client;
+use matrix_sdk::Room;
+use matrix_sdk::ruma::OwnedRoomId;
+
+use super::Buffer;
+
+pub struct RoomBuffer {
+  clients: Vec<Client>,
+  room_id: OwnedRoomId,
+}
+
+impl RoomBuffer {
+  pub fn new(clients: Vec<Client>, room_id: OwnedRoomId) -> Self {
+    RoomBuffer { clients, room_id }
+  }
+}
+
+impl Buffer for RoomBuffer {
+  fn short_name(&self) -> String {
+    self.room_id.as_str().to_owned()
+  }
+}

src/components.rs

@@ -10,8 +10,12 @@ use crate::{
   tui::Event,
 };
 
-pub mod fps;
-pub mod home;
+mod buflist;
+pub use buflist::Buflist;
+mod fps;
+pub use fps::FpsCounter;
+mod home;
+pub use home::Home;
 
 /// `Component` is a trait that represents a visual and interactive element of the user interface.
 /// Implementors of this trait can be registered with the main application loop and will be able to receive events,
@@ -108,7 +112,7 @@ pub trait Component {
   ///
   /// * `Result<Option<Action>>` - An action to be processed or none.
   #[allow(unused_variables)]
-  fn update(&mut self, action: Action) -> Result<Option<Action>> {
+  fn update(&mut self, action: &Action) -> Result<Option<Action>> {
     Ok(None)
   }
   /// Render the component on the screen. (REQUIRED)
@@ -117,9 +121,10 @@ pub trait Component {
   ///
   /// * `f` - A frame used for rendering.
   /// * `area` - The area in which the component should be drawn.
+  /// * `buffers` - Current state of the application (FIXME: abstraction leak?)
   ///
   /// # Returns
   ///
   /// * `Result<()>` - An Ok result or an error.
-  fn draw(&mut self, f: &mut Frame<'_>, area: Rect) -> Result<()>;
+  fn draw(&mut self, f: &mut Frame<'_>, area: Rect, buffers: &crate::buffers::Buffers) -> Result<()>;
 }

src/components/buflist.rs

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2023  Valentin Lorentz
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+use color_eyre::eyre::{Result, WrapErr};
+use ratatui::{prelude::*, widgets::*};
+use tokio::sync::mpsc::UnboundedSender;
+use tokio::sync::OnceCell;
+
+use super::Component;
+use crate::{
+  action::Action,
+  config::{Config, KeyBindings},
+};
+
+#[derive(Default)]
+pub struct Buflist {
+  command_tx: Option<UnboundedSender<Action>>,
+  config: OnceCell<Config>,
+}
+impl Buflist {
+  pub fn new() -> Self {
+    Self::default()
+  }
+}
+
+impl Component for Buflist {
+  fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
+    self.command_tx = Some(tx);
+    Ok(())
+  }
+
+  fn register_config_handler(&mut self, config: Config) -> Result<()> {
+    self
+      .config
+      .set(config)
+      .context("Buflist config was already set")
+  }
+
+  fn update(&mut self, action: &Action) -> Result<Option<Action>> {
+    match action {
+      Action::Tick => {},
+      _ => {},
+    }
+    Ok(None)
+  }
+
+  fn draw(&mut self, frame: &mut Frame<'_>, area: Rect, buffers: &crate::buffers::Buffers) -> Result<()> {
+    frame.render_widget(
+      Paragraph::new(buffers.iter().map(|buf| buf.short_name()).collect::<Vec<_>>().join("\n")).block(Block::new().borders(Borders::ALL)),
+      area,
+    );
+
+    Ok(())
+  }
+}

src/components/fps.rs

@@ -61,7 +61,7 @@ impl FpsCounter {
 }
 
 impl Component for FpsCounter {
-  fn update(&mut self, action: Action) -> Result<Option<Action>> {
+  fn update(&mut self, action: &Action) -> Result<Option<Action>> {
     if let Action::Tick = action {
       self.app_tick()?
     };
@@ -71,7 +71,7 @@ impl Component for FpsCounter {
     Ok(None)
   }
 
-  fn draw(&mut self, f: &mut Frame<'_>, rect: Rect) -> Result<()> {
+  fn draw(&mut self, f: &mut Frame<'_>, rect: Rect, _buffers: &crate::buffers::Buffers) -> Result<()> {
     let rects = Layout::default()
       .direction(Direction::Vertical)
       .constraints(vec![

src/components/home.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::OnceCell;
 
-use super::Component;
+use super::{Buflist, Component};
 use crate::{
   action::Action,
   config::{Config, KeyBindings},
@@ -17,6 +17,7 @@ use crate::{
 pub struct Home {
   command_tx: Option<UnboundedSender<Action>>,
   config: OnceCell<Config>,
+  buflist: Buflist,
 }
 
 impl Home {
@@ -27,18 +28,22 @@ impl Home {
 
 impl Component for Home {
   fn register_action_handler(&mut self, tx: UnboundedSender<Action>) -> Result<()> {
+    self.buflist.register_action_handler(tx.clone())?;
     self.command_tx = Some(tx);
     Ok(())
   }
 
   fn register_config_handler(&mut self, config: Config) -> Result<()> {
+    self.buflist.register_config_handler(config.clone())?;
     self
       .config
       .set(config)
-      .context("Home config was already set")
+      .context("Home config was already set")?;
+    Ok(())
   }
 
-  fn update(&mut self, action: Action) -> Result<Option<Action>> {
+  fn update(&mut self, action: &Action) -> Result<Option<Action>> {
+    self.buflist.update(action)?;
     match action {
       Action::Tick => {},
       _ => {},
@@ -46,8 +51,17 @@ impl Component for Home {
     Ok(None)
   }
 
-  fn draw(&mut self, f: &mut Frame<'_>, area: Rect) -> Result<()> {
-    f.render_widget(Paragraph::new("hello world"), area);
+  fn draw(&mut self, frame: &mut Frame<'_>, area: Rect, buffers: &crate::buffers::Buffers) -> Result<()> {
+    let layout = Layout::default()
+      .direction(Direction::Horizontal)
+      .constraints(vec![Constraint::Percentage(20), Constraint::Percentage(80)])
+      .split(area);
+
+    self.buflist.draw(frame, layout[0], buffers).context("Error drawing buflist")?;
+    frame.render_widget(
+      Paragraph::new("buffer goes here").block(Block::new().borders(Borders::ALL)),
+      layout[1],
+    );
     Ok(())
   }
 }

src/main.rs

@@ -4,6 +4,7 @@
 
 pub mod action;
 pub mod app;
+pub mod buffers;
 pub mod cli;
 pub mod commands;
 pub mod components;