Add vector path for stickers

data/resources/style-dark.css

@@ -7,6 +7,10 @@ messagesticker.needs-repainting > overlay > widget > widget {
   filter: invert(1);
 }
 
+vectorpath {
+  color: alpha(#404040, 0.8);
+}
+
 .chat-list row .unread-count-muted {
   background-color: @dark_2;
 }

data/resources/style.css

@@ -318,6 +318,10 @@ messagesticker {
   border-spacing: 6px;
 }
 
+vectorpath {
+  color: alpha(black, 0.2);
+}
+
 .event-row {
   font-size: smaller;
   font-weight: bold;

src/components/mod.rs

@@ -2,8 +2,10 @@ mod avatar;
 mod message_entry;
 mod snow;
 mod sticker;
+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::sticker::Sticker;
+use self::vector_path::VectorPath;

src/components/sticker.rs

@@ -6,6 +6,7 @@ use gtk::{gio, glib};
 use tdlib::enums::StickerFormat;
 use tdlib::types::Sticker as TdSticker;
 
+use super::VectorPath;
 use crate::session::Session;
 use crate::utils::{decode_image_from_path, spawn};
 
@@ -52,11 +53,15 @@ mod imp {
     }
 
     impl WidgetImpl for Sticker {
-        fn measure(&self, orientation: gtk::Orientation, _for_size: i32) -> (i32, i32, i32, i32) {
+        fn measure(&self, orientation: gtk::Orientation, for_size: i32) -> (i32, i32, i32, i32) {
             let size = self.longer_side_size.get();
             let aspect_ratio = self.aspect_ratio.get();
 
-            let min_size = 1;
+            let min_size = if let Some(child) = &*self.child.borrow_mut() {
+                child.measure(orientation, for_size).0
+            } else {
+                1
+            };
 
             let size = if let gtk::Orientation::Horizontal = orientation {
                 if aspect_ratio >= 1.0 {
@@ -103,8 +108,7 @@ impl Sticker {
             return;
         }
 
-        // TODO: draw sticker outline with cairo
-        self.set_child(None);
+        self.set_child(Some(VectorPath::new(&sticker.outline).upcast()));
 
         let aspect_ratio = sticker.width as f64 / sticker.height as f64;
         imp.aspect_ratio.set(aspect_ratio);

src/components/vector_path.rs

@@ -0,0 +1,95 @@
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+use gtk::{glib, graphene, gsk};
+use tdlib::types::ClosedVectorPath;
+
+use crate::utils::color_matrix_from_color;
+
+mod imp {
+    use super::*;
+    use std::cell::RefCell;
+
+    #[derive(Default)]
+    pub(crate) struct VectorPath {
+        pub(super) node: RefCell<Option<gsk::RenderNode>>,
+    }
+
+    #[glib::object_subclass]
+    impl ObjectSubclass for VectorPath {
+        const NAME: &'static str = "ComponentsVectorPath";
+        type Type = super::VectorPath;
+        type ParentType = gtk::Widget;
+
+        fn class_init(klass: &mut Self::Class) {
+            klass.set_css_name("vectorpath");
+        }
+    }
+
+    impl ObjectImpl for VectorPath {}
+
+    impl WidgetImpl for VectorPath {
+        fn snapshot(&self, snapshot: &gtk::Snapshot) {
+            let widget = self.obj();
+
+            let factor = (widget.width() as f32).max(widget.height() as f32) / 512.0;
+            snapshot.scale(factor, factor);
+
+            let (color_matrix, color_offset) = color_matrix_from_color(widget.color());
+            snapshot.push_color_matrix(&color_matrix, &color_offset);
+            if let Some(node) = &*self.node.borrow() {
+                snapshot.append_node(node);
+            }
+            snapshot.pop();
+        }
+    }
+}
+
+glib::wrapper! {
+    pub(crate) struct VectorPath(ObjectSubclass<imp::VectorPath>)
+        @extends gtk::Widget;
+}
+
+impl VectorPath {
+    pub fn new(outline: &[ClosedVectorPath]) -> Self {
+        let obj: Self = glib::Object::new();
+        obj.imp().node.replace(path_node(outline));
+        obj
+    }
+}
+
+fn path_node(outline: &[ClosedVectorPath]) -> Option<gsk::RenderNode> {
+    use tdlib::enums::VectorPathCommand::{CubicBezierCurve, Line};
+    use tdlib::types::VectorPathCommandCubicBezierCurve as Curve;
+
+    let snapshot = gtk::Snapshot::new();
+    let context = snapshot.append_cairo(&graphene::Rect::new(0.0, 0.0, 512.0, 512.0));
+
+    for closed_path in outline {
+        let e = match closed_path.commands.iter().last().unwrap() {
+            Line(line) => &line.end_point,
+            CubicBezierCurve(curve) => &curve.end_point,
+        };
+        context.move_to(e.x, e.y);
+
+        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();
+
+    snapshot.to_node()
+}

src/utils.rs

@@ -1,5 +1,5 @@
 use gettextrs::gettext;
-use gtk::{gdk, glib};
+use gtk::{gdk, glib, graphene};
 use image::io::Reader as ImageReader;
 use locale_config::Locale;
 use once_cell::sync::Lazy;
@@ -278,3 +278,12 @@ pub(crate) fn decode_image_from_path(path: &str) -> Result<gdk::MemoryTexture, D
 
     Ok(texture)
 }
+
+pub fn color_matrix_from_color(color: gdk::RGBA) -> (graphene::Matrix, graphene::Vec4) {
+    let color_offset = graphene::Vec4::new(color.red(), color.green(), color.blue(), 0.0);
+    let mut matrix = [0.0; 16];
+    matrix[15] = color.alpha();
+    let color_matrix = graphene::Matrix::from_float(matrix);
+
+    (color_matrix, color_offset)
+}