Merge pull request #501 from melix99/melix99/reply-followups

Reply addition followups

Author: melix99

data/resources/style.css

@@ -161,8 +161,7 @@ messagebubble messageindicators {
   opacity: 0.7;
 }
 
-messagebubble.text > overlay,
-messagebubble.document > overlay {
+messagebubble > overlay {
   padding: 6px 9px;
 }
 
@@ -198,19 +197,22 @@ messagebubble.document .file:active > image {
 messagebubble.media mediapicture {
   min-width: 150px;
   min-height: 100px;
-  /* Message bubble border-radius (15px) - margin (1px)  */
+  /* Negate margins to achieve 1px padding with the message bubble */
+  margin: -5px -8px;
+  /* Message bubble border-radius (15px) - padding (1px)  */
   border-radius: 14px;
-  margin: 1px;
+}
+
+messagebubble.media.with-reply mediapicture {
+  border-top-right-radius: 0;
+  border-top-left-radius: 0;
+  margin-top: 3px;
 }
 
 messagebubble.media.with-label mediapicture {
   border-bottom-right-radius: 0;
   border-bottom-left-radius: 0;
-  margin: 1px 1px 0;
-}
-
-messagebubble.media messagelabel {
-  margin: 6px 9px;
+  margin-bottom: 6px;
 }
 
 messageindicators image {
@@ -225,7 +227,6 @@ messagesticker messageindicators,
   opacity: 1; /* Reset opacity from message bubble */
   border-radius: 9999px;
   padding: 2px 6px;
-  margin: 6px;
 }
 
 messageindicators,

src/session/content/message_row/bubble.rs

@@ -199,16 +199,16 @@ impl MessageBubble {
 
         // Handle MessageReply
         if message.reply_to_message_id() != 0 {
-            let reply = MessageReply::new(
-                message.chat(),
-                message.reply_to_message_id(),
-                message.is_outgoing(),
-            );
+            let reply = MessageReply::new(message);
 
             // FIXME: Do not show message reply when message is being deleted
             imp.message_reply_bin.set_child(Some(&reply));
+
+            self.add_css_class("with-reply");
         } else {
             imp.message_reply_bin.set_child(gtk::Widget::NONE);
+
+            self.remove_css_class("with-reply");
         }
 
         // Show sender label, if needed

src/session/content/message_row/reply.rs

@@ -4,14 +4,14 @@ use gtk::subclass::prelude::*;
 use gtk::CompositeTemplate;
 
 use crate::strings;
-use crate::tdlib::{Chat, ChatType, Message, MessageSender};
+use crate::tdlib::{ChatType, Message, MessageSender};
 use crate::utils::spawn;
 
 mod imp {
     use gtk::glib::{ParamSpec, Properties, Value};
 
     use super::*;
-    use std::cell::{Cell, RefCell};
+    use std::cell::RefCell;
 
     #[derive(Debug, Default, Properties, CompositeTemplate)]
     #[properties(wrapper_type = super::MessageReply)]
@@ -47,14 +47,9 @@ mod imp {
     pub(crate) struct MessageReply {
         pub(super) sender_color_class: RefCell<Option<String>>,
         pub(super) bindings: RefCell<Vec<gtk::ExpressionWatch>>,
-        pub(super) is_loading: Cell<bool>,
 
         #[property(get, set, construct_only)]
-        pub(super) chat: RefCell<Option<Chat>>,
-        #[property(get, set, construct_only)]
-        pub(super) reply_id: Cell<i64>,
-        #[property(get, set, construct_only)]
-        pub(super) is_outgoing: Cell<bool>,
+        pub(super) message: RefCell<Option<Message>>,
 
         #[template_child]
         pub(super) separator: TemplateChild<gtk::Separator>,
@@ -97,10 +92,13 @@ mod imp {
         }
 
         fn constructed(&self) {
-            self.is_loading.set(true);
             self.message_label
                 .set_label(&gettextrs::gettext("Loading ..."));
-            self.obj().load_message();
+
+            let obj = self.obj();
+            spawn(clone!(@weak obj => async move {
+                obj.load_replied_message().await;
+            }));
         }
 
         fn dispose(&self) {
@@ -117,44 +115,35 @@ glib::wrapper! {
 }
 
 impl MessageReply {
-    pub(crate) fn new(chat: Chat, reply_id: i64, is_outgoing: bool) -> Self {
-        glib::Object::builder()
-            .property("chat", chat)
-            .property("reply-id", reply_id)
-            .property("is-outgoing", is_outgoing)
-            .build()
+    pub(crate) fn new(message: &Message) -> Self {
+        glib::Object::builder().property("message", message).build()
     }
 
-    fn load_message(&self) {
+    async fn load_replied_message(&self) {
         let imp = self.imp();
 
-        let reply_id = imp.reply_id.get();
-        let chat = self.chat().unwrap();
+        let message = self.message().unwrap();
+        let reply_to_message_id = message.reply_to_message_id();
+        let is_outgoing = message.is_outgoing();
+        let chat = if message.reply_in_chat_id() != 0 {
+            message.chat().session().chat(message.reply_in_chat_id())
+        } else {
+            message.chat()
+        };
 
-        if let Some(message) = chat.message(reply_id) {
-            self.update_from_message(&message);
+        if let Ok(message) = chat.fetch_message(reply_to_message_id).await {
+            self.update_from_message(&message, is_outgoing);
         } else {
-            spawn(clone!(@weak self as obj => async move {
-                let chat = obj.imp().chat.borrow().clone().unwrap();
-                if let Ok(message) = chat.fetch_message(reply_id).await {
-                    obj.update_from_message(&message);
-                } else {
-                    // Message doesn't exist, so we should remove "Loading..." caption
-                    // TODO: Impelent it properly using signals
-                    obj.imp().message_label.set_label("Deleted message");
-                }
-            }));
+            imp.message_label.set_label("Deleted message");
         }
-
-        imp.is_loading.set(false);
     }
 
     pub(crate) fn set_max_char_width(&self, n_chars: i32) {
         self.imp().message_label.set_max_width_chars(n_chars);
         self.imp().sender_label.set_max_width_chars(n_chars);
     }
 
-    fn update_from_message(&self, message: &Message) {
+    fn update_from_message(&self, replied_message: &Message, is_outgoing: bool) {
         let imp = self.imp();
         let mut bindings = imp.bindings.borrow_mut();
         while let Some(binding) = bindings.pop() {
@@ -168,19 +157,19 @@ impl MessageReply {
         }
         // Show sender label, if needed
         let show_sender = !matches!(
-            message.chat().type_(),
+            replied_message.chat().type_(),
             ChatType::Supergroup(data) if data.is_channel()
         );
         if show_sender {
-            let sender_name_expression = message.sender_name_expression();
+            let sender_name_expression = replied_message.sender_name_expression();
             let sender_binding =
                 sender_name_expression.bind(&*imp.sender_label, "label", glib::Object::NONE);
 
             bindings.push(sender_binding);
 
-            if !imp.is_outgoing.get() {
+            if !is_outgoing {
                 // Color sender label
-                if let MessageSender::User(user) = message.sender() {
+                if let MessageSender::User(user) = replied_message.sender() {
                     let classes = vec![
                         "sender-text-red",
                         "sender-text-orange",
@@ -202,9 +191,7 @@ impl MessageReply {
 
         // Set content label expression
 
-        let caption = strings::message_content(message.clone().as_ref());
+        let caption = strings::message_content(replied_message.clone().as_ref());
         imp.message_label.set_label(&caption);
-
-        self.imp().is_loading.set(false);
     }
 }

src/session/content/message_row/sticker.rs

@@ -102,11 +102,7 @@ impl MessageBaseExt for MessageSticker {
         imp.indicators.set_message(message.clone().upcast());
 
         if message.reply_to_message_id() != 0 {
-            let reply = MessageReply::new(
-                message.chat(),
-                message.reply_to_message_id(),
-                message.is_outgoing(),
-            );
+            let reply = MessageReply::new(message);
             reply.set_valign(gtk::Align::Start);
             reply.set_max_char_width(MAX_REPLY_CHAR_WIDTH);
 

src/tdlib/message.rs

@@ -68,6 +68,7 @@ mod imp {
         pub(super) interaction_info: OnceCell<MessageInteractionInfo>,
         pub(super) chat: WeakRef<Chat>,
         pub(super) forward_info: OnceCell<Option<MessageForwardInfo>>,
+        pub(super) reply_in_chat_id: Cell<i64>,
         pub(super) reply_to_message_id: Cell<i64>,
     }
 
@@ -116,6 +117,9 @@ mod imp {
                     glib::ParamSpecObject::builder::<MessageForwardInfo>("forward-info")
                         .read_only()
                         .build(),
+                    glib::ParamSpecInt64::builder("reply-in-chat-id")
+                        .read_only()
+                        .build(),
                     glib::ParamSpecInt64::builder("reply-to-message-id")
                         .read_only()
                         .build(),
@@ -141,6 +145,7 @@ mod imp {
                 "interaction-info" => obj.interaction_info().to_value(),
                 "chat" => obj.chat().to_value(),
                 "forward-info" => obj.forward_info().to_value(),
+                "reply-in-chat-id" => obj.reply_in_chat_id().to_value(),
                 "reply-to-message-id" => obj.reply_to_message_id().to_value(),
                 _ => unimplemented!(),
             }
@@ -182,6 +187,7 @@ impl Message {
             .unwrap();
         imp.chat.set(Some(chat));
         imp.forward_info.set(forward_info).unwrap();
+        imp.reply_in_chat_id.set(td_message.reply_in_chat_id);
         imp.reply_to_message_id.set(td_message.reply_to_message_id);
 
         message
@@ -286,6 +292,10 @@ impl Message {
         self.imp().forward_info.get().unwrap().as_ref()
     }
 
+    pub(crate) fn reply_in_chat_id(&self) -> i64 {
+        self.imp().reply_in_chat_id.get()
+    }
+
     pub(crate) fn reply_to_message_id(&self) -> i64 {
         self.imp().reply_to_message_id.get()
     }