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)
+}