Render images in reactions

Author: VAWVAW

src/base.rs

@@ -13,6 +13,8 @@ use std::time::{Duration, Instant};
 
 use emojis::Emoji;
 use matrix_sdk::ruma::events::receipt::ReceiptThread;
+use matrix_sdk::ruma::events::room::MediaSource;
+use matrix_sdk::ruma::OwnedMxcUri;
 use ratatui::{
     buffer::Buffer,
     layout::{Alignment, Rect},
@@ -90,9 +92,9 @@ use modalkit::{
     prelude::{CommandType, WordStyle},
 };
 
-use crate::config::ImagePreviewProtocolValues;
+use crate::config::{ImagePreviewProtocolValues, ImagePreviewSize};
 use crate::notifications::NotificationHandle;
-use crate::preview::{source_from_event, PreviewManager};
+use crate::preview::{source_from_event, PreviewKind, PreviewManager};
 use crate::{
     message::{Message, MessageEvent, MessageKey, MessageTimeStamp, Messages},
     worker::Requester,
@@ -682,7 +684,7 @@ pub type IambResult<T> = UIResult<T, IambInfo>;
 ///
 /// The event identifier used as a key here is the ID for the reaction, and not for the message
 /// it's reacting to.
-pub type MessageReactions = HashMap<OwnedEventId, (String, OwnedUserId)>;
+pub type MessageReactions = HashMap<OwnedEventId, (String, OwnedUserId, Option<MediaSource>)>;
 
 /// Errors encountered during application use.
 #[derive(thiserror::Error, Debug)]
@@ -984,22 +986,25 @@ impl RoomInfo {
     }
 
     /// Get the reactions and their counts for a message.
-    pub fn get_reactions(&self, event_id: &EventId) -> Vec<(&str, usize)> {
+    pub fn get_reactions(&self, event_id: &EventId) -> Vec<(&str, usize, &Option<MediaSource>)> {
         if let Some(reacts) = self.reactions.get(event_id) {
             let mut counts = HashMap::new();
 
             let mut seen_user_reactions = BTreeSet::new();
 
-            for (key, user) in reacts.values() {
+            for (key, user, source) in reacts.values() {
                 if !seen_user_reactions.contains(&(key, user)) {
                     seen_user_reactions.insert((key, user));
-                    let count = counts.entry(key.as_str()).or_default();
-                    *count += 1;
+                    let count = counts.entry(key.as_str()).or_insert((0, source));
+                    count.0 += 1;
                 }
             }
 
-            let mut reactions = counts.into_iter().collect::<Vec<_>>();
-            reactions.sort();
+            let mut reactions = counts
+                .into_iter()
+                .map(|(key, (count, source))| (key, count, source))
+                .collect::<Vec<_>>();
+            reactions.sort_by_key(|item| (item.0, item.1));
 
             reactions
         } else {
@@ -1060,24 +1065,46 @@ impl RoomInfo {
     }
 
     /// Insert a reaction to a message.
-    pub fn insert_reaction(&mut self, react: ReactionEvent) {
-        match react {
-            MessageLikeEvent::Original(react) => {
-                let rel_id = react.content.relates_to.event_id;
-                let key = react.content.relates_to.key;
+    fn insert_reaction(&mut self, react: ReactionEvent, source: Option<MediaSource>) {
+        let MessageLikeEvent::Original(react) = react else {
+            return;
+        };
+        let rel_id = react.content.relates_to.event_id;
+        let key = react.content.relates_to.key;
 
-                let message = self.reactions.entry(rel_id.clone()).or_default();
-                let event_id = react.event_id;
-                let user_id = react.sender;
+        let message = self.reactions.entry(rel_id.clone()).or_default();
+        let event_id = react.event_id;
+        let user_id = react.sender;
 
-                message.insert(event_id.clone(), (key, user_id));
+        message.insert(event_id.clone(), (key, user_id, source));
 
-                let loc = EventLocation::Reaction(rel_id);
-                self.keys.insert(event_id, loc);
-            },
-            MessageLikeEvent::Redacted(_) => {
-                return;
-            },
+        let loc = EventLocation::Reaction(rel_id);
+        self.keys.insert(event_id, loc);
+    }
+
+    /// Insert a reaction to a message.
+    pub fn insert_reaction_with_preview(
+        &mut self,
+        react: ReactionEvent,
+        settings: &ApplicationSettings,
+        previews: &mut PreviewManager,
+        worker: &Requester,
+    ) {
+        let MessageLikeEvent::Original(ref orig_react) = react else {
+            return;
+        };
+        let image_uri = OwnedMxcUri::from(orig_react.content.relates_to.key.as_str());
+        let source = if image_uri.is_valid() && settings.tunables.image_preview.is_some() {
+            Some(MediaSource::Plain(image_uri))
+        } else {
+            None
+        };
+
+        self.insert_reaction(react, source.clone());
+
+        if let (Some(source), Some(_)) = (source, &settings.tunables.image_preview) {
+            let size = ImagePreviewSize { width: 2, height: 1 };
+            previews.register_preview(settings, source, PreviewKind::Reaction, size, worker);
         }
     }
 
@@ -1219,7 +1246,13 @@ impl RoomInfo {
                 (self.get_event_mut(&event_id), &settings.tunables.image_preview)
             {
                 msg.image_preview = Some(source.clone());
-                previews.register_preview(settings, source, image_preview.size, worker)
+                previews.register_preview(
+                    settings,
+                    source,
+                    PreviewKind::Message,
+                    image_preview.size,
+                    worker,
+                )
             }
         }
     }
@@ -1376,7 +1409,7 @@ impl RoomInfo {
         if let Some(reactions) = self.reactions.get(event_id) {
             reactions
                 .values()
-                .any(|(annotation, user)| annotation == emoji && user == user_id)
+                .any(|(annotation, user, _)| annotation == emoji && user == user_id)
         } else {
             false
         }
@@ -2129,16 +2162,17 @@ pub mod tests {
 
         for i in 0..3 {
             let event_id = format!("$house_{}", i);
-            info.insert_reaction(MessageLikeEvent::Original(
-                matrix_sdk::ruma::events::OriginalMessageLikeEvent {
+            info.insert_reaction(
+                MessageLikeEvent::Original(matrix_sdk::ruma::events::OriginalMessageLikeEvent {
                     content: content.clone(),
                     event_id: OwnedEventId::from_str(&event_id).unwrap(),
                     sender: owned_user_id!("@foo:example.org"),
                     origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
                     room_id: owned_room_id!("!foo:example.org"),
                     unsigned: MessageLikeUnsigned::new(),
-                },
-            ));
+                }),
+                None,
+            );
         }
 
         let content = ReactionEventContent::new(Annotation::new(
@@ -2148,36 +2182,40 @@ pub mod tests {
 
         for i in 0..2 {
             let event_id = format!("$smile_{}", i);
-            info.insert_reaction(MessageLikeEvent::Original(
-                matrix_sdk::ruma::events::OriginalMessageLikeEvent {
+            info.insert_reaction(
+                MessageLikeEvent::Original(matrix_sdk::ruma::events::OriginalMessageLikeEvent {
                     content: content.clone(),
                     event_id: OwnedEventId::from_str(&event_id).unwrap(),
                     sender: owned_user_id!("@foo:example.org"),
                     origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
                     room_id: owned_room_id!("!foo:example.org"),
                     unsigned: MessageLikeUnsigned::new(),
-                },
-            ));
+                }),
+                None,
+            );
         }
 
         for i in 2..4 {
             let event_id = format!("$smile_{}", i);
-            info.insert_reaction(MessageLikeEvent::Original(
-                matrix_sdk::ruma::events::OriginalMessageLikeEvent {
+            info.insert_reaction(
+                MessageLikeEvent::Original(matrix_sdk::ruma::events::OriginalMessageLikeEvent {
                     content: content.clone(),
                     event_id: OwnedEventId::from_str(&event_id).unwrap(),
                     sender: owned_user_id!("@bar:example.org"),
                     origin_server_ts: MilliSecondsSinceUnixEpoch::now(),
                     room_id: owned_room_id!("!foo:example.org"),
                     unsigned: MessageLikeUnsigned::new(),
-                },
-            ));
+                }),
+                None,
+            );
         }
 
-        assert_eq!(info.get_reactions(&owned_event_id!("$my_reaction")), vec![
-            ("🏠", 1),
-            ("🙂", 2)
-        ]);
+        let reacts: Vec<_> = info
+            .get_reactions(&owned_event_id!("$my_reaction"))
+            .into_iter()
+            .map(|(key, count, _)| (key, count))
+            .collect();
+        assert_eq!(reacts, vec![("🏠", 1), ("🙂", 2)]);
     }
 
     #[test]

src/message/mod.rs

@@ -59,7 +59,7 @@ use modalkit::prelude::*;
 use ratatui_image::protocol::Protocol;
 
 use crate::config::ImagePreviewSize;
-use crate::preview::{ImageStatus, PreviewManager};
+use crate::preview::{ImageStatus, PreviewKind, PreviewManager};
 use crate::{
     base::RoomInfo,
     config::ApplicationSettings,
@@ -769,16 +769,37 @@ impl<'a> MessageFormatter<'a> {
         proto
     }
 
-    fn push_reactions(&mut self, counts: Vec<(&'a str, usize)>, style: Style, text: &mut Text<'a>) {
+    fn push_reactions(
+        &mut self,
+        counts: Vec<(&'a str, usize, &'a Option<MediaSource>)>,
+        style: Style,
+        text: &mut Text<'a>,
+        settings: &ApplicationSettings,
+        previews: &'a PreviewManager,
+    ) -> Vec<ProtocolPreview<'a>> {
         let mut emojis = printer::TextPrinter::new(self.width(), style, false, self.settings);
         let mut reactions = 0;
+        let mut protos = Vec::new();
 
-        for (key, count) in counts {
+        for (key, count, source) in counts {
             if reactions != 0 {
                 emojis.push_str(" ", style);
             }
 
-            let name = if self.settings.tunables.reaction_shortcode_display {
+            let proto = match source
+                .as_ref()
+                .and_then(|source| previews.get(source, PreviewKind::Reaction))
+            {
+                Some(ImageStatus::Loaded(backend)) => Some(Some(backend)),
+                // Use empty space as placeholder
+                Some(ImageStatus::Queued(_)) | Some(ImageStatus::Downloading(_)) => Some(None),
+                // Fall back to text
+                None | Some(ImageStatus::Error(_)) => None,
+            };
+
+            let name = if proto.is_some() {
+                "  "
+            } else if self.settings.tunables.reaction_shortcode_display {
                 if let Some(emoji) = emojis::get(key) {
                     if let Some(short) = emoji.shortcode() {
                         short
@@ -797,6 +818,13 @@ impl<'a> MessageFormatter<'a> {
             };
 
             emojis.push_str("[", style);
+            if let Some(Some(proto)) = proto {
+                let (x, y) = emojis.curosor_pos();
+                let y = (y + text.lines.len()) as u16;
+                let x = x as u16 + self.cols.user_gutter_width(settings);
+
+                protos.push((proto, x, y));
+            }
             emojis.push_str(name, style);
             emojis.push_str(" ", style);
             emojis.push_span_nobreak(Span::styled(count.to_string(), style));
@@ -808,6 +836,8 @@ impl<'a> MessageFormatter<'a> {
         if reactions > 0 {
             self.push_text(emojis.finish(), style, text);
         }
+
+        protos
     }
 
     fn push_thread_reply_count(&mut self, len: usize, text: &mut Text<'a>) {
@@ -1033,7 +1063,8 @@ impl Message {
 
         if settings.tunables.reaction_display {
             let reactions = info.get_reactions(self.event.event_id());
-            fmt.push_reactions(reactions, style, &mut text);
+            let react_protos = fmt.push_reactions(reactions, style, &mut text, settings, previews);
+            protos.extend(react_protos);
         }
 
         if let Some(thread) = info.get_thread(Some(self.event.event_id())) {
@@ -1076,21 +1107,24 @@ impl Message {
             }
 
             let mut proto = None;
-            let placeholder =
-                match self.image_preview.as_ref().and_then(|source| previews.get(source)) {
-                    None => None,
-                    Some(ImageStatus::Queued(image_preview_size)) => {
-                        placeholder_frame(Some("Queued..."), width, image_preview_size)
-                    },
-                    Some(ImageStatus::Downloading(image_preview_size)) => {
-                        placeholder_frame(Some("Downloading..."), width, image_preview_size)
-                    },
-                    Some(ImageStatus::Loaded(backend)) => {
-                        proto = Some(backend);
-                        placeholder_frame(Some("Cut off..."), width, &backend.area().into())
-                    },
-                    Some(ImageStatus::Error(err)) => Some(format!("[Image error: {err}]\n")),
-                };
+            let placeholder = match self
+                .image_preview
+                .as_ref()
+                .and_then(|source| previews.get(source, PreviewKind::Message))
+            {
+                None => None,
+                Some(ImageStatus::Queued(image_preview_size)) => {
+                    placeholder_frame(Some("Queued..."), width, image_preview_size)
+                },
+                Some(ImageStatus::Downloading(image_preview_size)) => {
+                    placeholder_frame(Some("Downloading..."), width, image_preview_size)
+                },
+                Some(ImageStatus::Loaded(backend)) => {
+                    proto = Some(backend);
+                    placeholder_frame(Some("Cut off..."), width, &backend.area().into())
+                },
+                Some(ImageStatus::Error(err)) => Some(format!("[Image error: {err}]\n")),
+            };
 
             if let Some(placeholder) = placeholder {
                 msg.to_mut().insert_str(0, &placeholder);

src/message/printer.rs

@@ -57,6 +57,11 @@ impl<'a> TextPrinter<'a> {
         }
     }
 
+    /// The position where the next text will be printed. (x, y)
+    pub fn curosor_pos(&self) -> (usize, usize) {
+        (self.curr_width, self.text.lines.len().saturating_sub(1))
+    }
+
     /// Configure the alignment for each line.
     pub fn align(mut self, alignment: Alignment) -> Self {
         self.alignment = alignment;