rlottie: Add support of animated stickers

Author: yuraiz

Cargo.lock

@@ -22,3 +22,4 @@ regex = "1.7"
 tdlib = { version = "0.4", default-features = false }
 temp-dir = "0.1"
 thiserror = "1.0"
+rlt = { package="gtk-rlottie", git="https://github.com/YuraIz/gtk-rlottie-rs" }

Cargo.toml

@@ -36,6 +36,18 @@
         "*.a"
     ],
     "modules": [
+        {
+            "name": "rlottie",
+            "buildsystem": "meson",
+            "config-opts": ["-Dwerror=false"],
+            "sources": [
+                {
+                    "type": "git",
+                    "url": "https://github.com/melix99/rlottie",
+                    "branch": "fix-build"
+                }
+            ]
+        },
         {
             "name": "gtk",
             "buildsystem": "meson",

build-aux/com.github.melix99.telegrand.Devel.json

@@ -1,13 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
   <template class="ContentMessageSticker" parent="ContentMessageBase">
-    <property name="layout-manager">
-      <object class="GtkBinLayout"/>
-    </property>
     <child>
-      <object class="GtkOverlay">
+      <object class="GtkOverlay" id="overlay">
         <child>
-          <object class="ContentStickerPicture" id="picture"/>
+          <object class="AdwBin" id="bin"/>
         </child>
         <child type="overlay">
           <object class="MessageIndicators" id="indicators">

data/resources/ui/content-message-sticker.ui

@@ -1,7 +1,9 @@
 mod avatar;
 mod message_entry;
 mod snow;
+mod vector_path;
 
 pub(crate) use self::avatar::Avatar;
 pub(crate) use self::message_entry::MessageEntry;
 pub(crate) use self::snow::Snow;
+pub(crate) use self::vector_path::StickerPreview;

src/session/components/mod.rs

@@ -0,0 +1,76 @@
+use gtk::glib;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+
+use tdlib::types::ClosedVectorPath;
+
+mod imp {
+    use super::*;
+    use gtk::graphene;
+    use std::cell::RefCell;
+    use tdlib::enums::VectorPathCommand::{CubicBezierCurve, Line};
+    use tdlib::types::VectorPathCommandCubicBezierCurve as Curve;
+
+    #[derive(Default)]
+    pub struct StickerPreview {
+        pub(super) path: RefCell<Vec<ClosedVectorPath>>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for StickerPreview {
+        const NAME: &'static str = "ComponentsVectorPath";
+        type Type = super::StickerPreview;
+        type ParentType = gtk::Widget;
+    }
+
+    impl ObjectImpl for StickerPreview {}
+
+    impl WidgetImpl for StickerPreview {
+        fn snapshot(&self, snapshot: &gtk::Snapshot) {
+            let widget = self.obj();
+
+            let context = snapshot.append_cairo(&graphene::Rect::new(0.0, 0.0, 512.0, 512.0));
+
+            let scale = widget.width().max(widget.height()) as f64 / 512.0;
+            context.scale(scale, scale);
+
+            context.set_source_rgba(0.5, 0.5, 0.5, 0.4);
+
+            let outline = &*self.path.borrow();
+
+            for closed_path in outline {
+                for command in &closed_path.commands {
+                    match command {
+                        Line(line) => {
+                            let e = &line.end_point;
+                            context.line_to(e.x, e.y);
+                        }
+                        CubicBezierCurve(curve) => {
+                            let Curve {
+                                start_control_point: sc,
+                                end_control_point: ec,
+                                end_point: e,
+                            } = curve;
+
+                            context.curve_to(sc.x, sc.y, ec.x, ec.y, e.x, e.y);
+                        }
+                    }
+                }
+                _ = context.fill();
+            }
+        }
+    }
+}
+
+glib::wrapper! {
+    pub struct StickerPreview(ObjectSubclass<imp::StickerPreview>)
+        @extends gtk::Widget;
+}
+
+impl StickerPreview {
+    pub fn new(outline: Vec<ClosedVectorPath>) -> Self {
+        let obj: Self = glib::Object::new(&[]);
+        obj.imp().path.replace(outline);
+        obj
+    }
+}

src/session/components/vector_path.rs

@@ -320,7 +320,7 @@ impl MessageRow {
                     self.update_specific_content::<_, MessagePhoto>(message_.clone());
                 }
                 MessageContent::MessageSticker(data)
-                    if data.sticker.format == StickerFormat::Webp =>
+                    if matches!(data.sticker.format, StickerFormat::Webp | StickerFormat::Tgs) =>
                 {
                     self.update_specific_content::<_, MessageSticker>(message_.clone());
                 }

src/session/content/message_row/mod.rs

@@ -1,16 +1,15 @@
+use adw::prelude::*;
 use glib::clone;
-use gtk::prelude::*;
 use gtk::subclass::prelude::*;
 use gtk::{gdk, gio, glib, CompositeTemplate};
 use image::io::Reader as ImageReader;
 use image::ImageFormat;
 use std::io::Cursor;
-use tdlib::enums::MessageContent;
+use tdlib::enums::{MessageContent, StickerFormat};
 use tdlib::types::File;
 
-use crate::session::content::message_row::{
-    MessageBase, MessageBaseImpl, MessageIndicators, StickerPicture,
-};
+use crate::session::components::StickerPreview;
+use crate::session::content::message_row::{MessageBase, MessageBaseImpl, MessageIndicators};
 use crate::tdlib::Message;
 use crate::utils::spawn;
 
@@ -19,14 +18,19 @@ use super::base::MessageBaseExt;
 mod imp {
     use super::*;
     use once_cell::sync::Lazy;
-    use std::cell::RefCell;
+    use once_cell::unsync::OnceCell;
+    use std::cell::{Cell, RefCell};
 
     #[derive(Debug, Default, CompositeTemplate)]
     #[template(resource = "/com/github/melix99/telegrand/ui/content-message-sticker.ui")]
     pub(crate) struct MessageSticker {
+        pub(super) format: OnceCell<StickerFormat>,
+        pub(super) aspect_ratio: Cell<f64>,
         pub(super) message: RefCell<Option<Message>>,
         #[template_child]
-        pub(super) picture: TemplateChild<StickerPicture>,
+        pub(super) overlay: TemplateChild<gtk::Overlay>,
+        #[template_child]
+        pub(super) bin: TemplateChild<adw::Bin>,
         #[template_child]
         pub(super) indicators: TemplateChild<MessageIndicators>,
     }
@@ -74,7 +78,31 @@ mod imp {
         }
     }
 
-    impl WidgetImpl for MessageSticker {}
+    impl WidgetImpl for MessageSticker {
+        fn measure(&self, orientation: gtk::Orientation, for_size: i32) -> (i32, i32, i32, i32) {
+            const SIZE: i32 = 208;
+            let aspect_ratio = self.aspect_ratio.get();
+            let min_size = self.overlay.measure(orientation, for_size).0;
+            let size = if let gtk::Orientation::Horizontal = orientation {
+                if aspect_ratio >= 1.0 {
+                    SIZE
+                } else {
+                    (SIZE as f64 * aspect_ratio) as i32
+                }
+            } else if aspect_ratio >= 1.0 {
+                (SIZE as f64 / aspect_ratio) as i32
+            } else {
+                SIZE
+            }
+            .max(min_size);
+
+            (size, size, -1, -1)
+        }
+
+        fn size_allocate(&self, width: i32, height: i32, baseline: i32) {
+            self.overlay.allocate(width, height, baseline, None);
+        }
+    }
     impl MessageBaseImpl for MessageSticker {}
 }
 
@@ -95,15 +123,19 @@ impl MessageBaseExt for MessageSticker {
 
         imp.indicators.set_message(message.clone().upcast());
 
-        imp.picture.set_texture(None);
-
         if let MessageContent::MessageSticker(data) = message.content().0 {
-            self.imp()
-                .picture
-                .set_aspect_ratio(data.sticker.width as f64 / data.sticker.height as f64);
+            let sticker = data.sticker;
 
-            if data.sticker.sticker.local.is_downloading_completed {
-                self.load_sticker(&data.sticker.sticker.local.path);
+            imp.format.set(sticker.format).unwrap();
+
+            imp.aspect_ratio
+                .set(sticker.width as f64 / sticker.height as f64);
+
+            let preview = StickerPreview::new(sticker.outline.clone());
+            self.imp().bin.set_child(Some(&preview));
+
+            if sticker.sticker.local.is_downloading_completed {
+                self.load_sticker(&sticker.sticker.local.path);
             } else {
                 let (sender, receiver) =
                     glib::MainContext::sync_channel::<File>(Default::default(), 5);
@@ -122,45 +154,67 @@ impl MessageBaseExt for MessageSticker {
                 message
                     .chat()
                     .session()
-                    .download_file(data.sticker.sticker.id, sender);
+                    .download_file(sticker.sticker.id, sender);
             }
         }
-
         imp.message.replace(Some(message));
+
         self.notify("message");
     }
 }
 
 impl MessageSticker {
     fn load_sticker(&self, path: &str) {
-        let picture = &*self.imp().picture;
-        let file = gio::File::for_path(path);
-        spawn(clone!(@weak picture => async move {
-            match file.load_bytes_future().await {
-                Ok((bytes, _)) => {
-                    let flat_samples = ImageReader::with_format(Cursor::new(bytes), ImageFormat::WebP)
-                        .decode()
-                        .unwrap()
-                        .into_rgba8()
-                        .into_flat_samples();
-
-                    let (stride, width, height) = flat_samples.extents();
-                    let gtk_stride = stride * width;
-
-                    let bytes = glib::Bytes::from_owned(flat_samples.samples);
-                    let texture = gdk::MemoryTexture::new(
-                        width as i32,
-                        height as i32,
-                        gdk::MemoryFormat::R8g8b8a8,
-                        &bytes,
-                        gtk_stride,
-                    );
-                    picture.set_texture(Some(texture.upcast()));
-                }
-                Err(e) => {
-                    log::warn!("Failed to load a sticker: {}", e);
+        let path = path.to_owned();
+        spawn(clone!(@weak self as obj => async move {
+            let widget: gtk::Widget = match obj.imp().format.get().unwrap() {
+            StickerFormat::Tgs => {
+                let animation = rlt::Animation::from_filename(&path);
+                animation.set_loop(true);
+                animation.use_cache(true);
+                animation.play();
+                animation.upcast()
+            }
+            StickerFormat::Webp => {
+                let file = gio::File::for_path(&path);
+                match file.load_bytes_future().await {
+                    Ok((bytes, _)) => {
+                        let flat_samples =
+                            ImageReader::with_format(Cursor::new(bytes), ImageFormat::WebP)
+                                .decode()
+                                .unwrap()
+                                .into_rgba8()
+                                .into_flat_samples();
+
+                        let (stride, width, height) = flat_samples.extents();
+                        let gtk_stride = stride * width;
+
+                        let bytes = glib::Bytes::from_owned(flat_samples.samples);
+                        let texture = gdk::MemoryTexture::new(
+                            width as i32,
+                            height as i32,
+                            gdk::MemoryFormat::R8g8b8a8,
+                            &bytes,
+                            gtk_stride,
+                        );
+
+                        let picture = gtk::Picture::new();
+
+                        picture.set_paintable(Some(&texture));
+
+                        picture.upcast()
+                    }
+                    Err(e) => {
+                        log::warn!("Failed to load a sticker: {}", e);
+                        return;
+                    }
                 }
             }
+            _ => unimplemented!(),
+        };
+
+        obj.imp().bin.set_child(Some(&widget));
+
         }));
     }
 }