GNOME.org
 

[evince] libgd: Update from libgd git master

commit 5bc3704283b2732c305da2edcb164a9e63efec69
Author: Bastien Nocera <hadess hadess net>
Date:   Wed Jul 19 18:06:57 2017 +0200

    libgd: Update from libgd git master
    
    https://bugzilla.gnome.org/show_bug.cgi?id=784913

 cut-n-paste/libgd/gd-icon-utils.c         |  265 ++++++++++++++++++++++++++---
 cut-n-paste/libgd/gd-icon-utils.h         |   24 ++-
 cut-n-paste/libgd/gd-two-lines-renderer.c |   48 +++++-
 shell/ev-recent-view.c                    |    6 +-
 4 files changed, 306 insertions(+), 37 deletions(-)
---
diff --git a/cut-n-paste/libgd/gd-icon-utils.c b/cut-n-paste/libgd/gd-icon-utils.c
index dc6e704..6c9dd40 100644
--- a/cut-n-paste/libgd/gd-icon-utils.c
+++ b/cut-n-paste/libgd/gd-icon-utils.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2012 Red Hat, Inc.
+ * Copyright (c) 2011, 2012, 2015, 2016 Red Hat, Inc.
  *
  * Gnome Documents is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by the
@@ -29,17 +29,161 @@
 #define _EMBLEM_MIN_SIZE 8
 
 /**
- * gd_create_symbolic_icon:
+ * gd_copy_image_surface:
+ * @surface:
+ *
+ * Returns: (transfer full):
+ */
+cairo_surface_t *
+gd_copy_image_surface (cairo_surface_t *surface)
+{
+  cairo_surface_t *copy = NULL;
+  cairo_t *cr;
+  gdouble scale_x;
+  gdouble scale_y;
+
+  copy = cairo_surface_create_similar_image (surface, CAIRO_FORMAT_ARGB32,
+                                             cairo_image_surface_get_width (surface),
+                                             cairo_image_surface_get_height (surface));
+  cairo_surface_get_device_scale (surface, &scale_x, &scale_y);
+  cairo_surface_set_device_scale (copy, scale_x, scale_y);
+
+  cr = cairo_create (copy);
+  cairo_set_source_surface (cr, surface, 0, 0);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+  return copy;
+}
+
+/**
+ * gd_create_surface_with_counter:
+ * @widget:
+ * @base:
+ * @number:
+ *
+ * Returns: (transfer full):
+ */
+cairo_surface_t *
+gd_create_surface_with_counter (GtkWidget *widget, cairo_surface_t *base, gint number)
+{
+  GtkStyleContext *context;
+  cairo_t *cr, *emblem_cr;
+  cairo_surface_t *emblem_surface;
+  cairo_surface_t *surface;
+  gint height;
+  gint height_scaled;
+  gint width;
+  gint width_scaled;
+  gint layout_width, layout_height;
+  gint emblem_size;
+  gint emblem_size_scaled;
+  gdouble scale;
+  gdouble scale_x;
+  gdouble scale_y;
+  gchar *str;
+  PangoLayout *layout;
+  PangoAttrList *attr_list;
+  PangoAttribute *attr;
+  PangoFontDescription *desc;
+  GdkRGBA color;
+
+  context = gtk_widget_get_style_context (GTK_WIDGET (widget));
+  gtk_style_context_save (context);
+  gtk_style_context_add_class (context, "documents-counter");
+
+  width_scaled = cairo_image_surface_get_width (base);
+  height_scaled = cairo_image_surface_get_height (base);
+  cairo_surface_get_device_scale (base, &scale_x, &scale_y);
+
+  width = width_scaled / (gint) floor (scale_x),
+  height = height_scaled / (gint) floor (scale_y);
+
+  surface = cairo_surface_create_similar_image (base, CAIRO_FORMAT_ARGB32,
+                                                width_scaled, height_scaled);
+  cairo_surface_set_device_scale (surface, scale_x, scale_y);
+
+  cr = cairo_create (surface);
+  cairo_set_source_surface (cr, base, 0, 0);
+  cairo_paint (cr);
+
+  emblem_size_scaled = MIN (width_scaled / 2, height_scaled / 2);
+  emblem_size = MIN (width / 2, height / 2);
+
+  emblem_surface = cairo_surface_create_similar_image (base, CAIRO_FORMAT_ARGB32,
+                                                       emblem_size_scaled, emblem_size_scaled);
+  cairo_surface_set_device_scale (emblem_surface, scale_x, scale_y);
+
+  emblem_cr = cairo_create (emblem_surface);
+  gtk_render_background (context, emblem_cr,
+                         0, 0, emblem_size, emblem_size);
+
+  if (number > 99)
+    number = 99;
+  if (number < -99)
+    number = -99;
+
+  str = g_strdup_printf ("%d", number);
+  layout = gtk_widget_create_pango_layout (GTK_WIDGET (widget), str);
+  g_free (str);
+
+  pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
+
+  /* scale the layout to be 0.5 of the size still available for drawing */
+  scale = (emblem_size * 0.50) / (MAX (layout_width, layout_height));
+  attr_list = pango_attr_list_new ();
+
+  attr = pango_attr_scale_new (scale);
+  pango_attr_list_insert (attr_list, attr);
+  pango_layout_set_attributes (layout, attr_list);
+
+  gtk_style_context_get (context, GTK_STATE_FLAG_NORMAL, "font", &desc, NULL);
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  gtk_style_context_get_color (context, 0, &color);
+  gdk_cairo_set_source_rgba (emblem_cr, &color);
+
+  /* update these values */
+  pango_layout_get_pixel_size (layout, &layout_width, &layout_height);
+
+  cairo_move_to (emblem_cr,
+                 emblem_size / 2 - layout_width / 2,
+                 emblem_size / 2 - layout_height / 2);
+
+  pango_cairo_show_layout (emblem_cr, layout);
+
+  g_object_unref (layout);
+  pango_attr_list_unref (attr_list);
+  cairo_destroy (emblem_cr);
+
+  cairo_set_source_surface (cr, emblem_surface, 
+                            width - emblem_size, height - emblem_size);
+  cairo_paint (cr);
+  cairo_destroy (cr);
+
+  cairo_surface_destroy (emblem_surface);
+  gtk_style_context_restore (context);
+
+  return surface;
+}
+
+/**
+ * gd_create_symbolic_icon_for_scale:
  * @name:
+ * @base_size:
+ * @scale:
  *
  * Returns: (transfer full):
  */
 GIcon *
-gd_create_symbolic_icon (const gchar *name,
-                         gint base_size)
+gd_create_symbolic_icon_for_scale (const gchar *name,
+                                   gint base_size,
+                                   gint scale)
 {
   gchar *symbolic_name;
   GIcon *icon, *retval = NULL;
+  cairo_surface_t *icon_surface;
   cairo_surface_t *surface;
   cairo_t *cr;
   GtkStyleContext *style;
@@ -50,12 +194,16 @@ gd_create_symbolic_icon (const gchar *name,
   gint bg_size;
   gint emblem_size;
   gint total_size;
+  gint total_size_scaled;
 
   total_size = base_size / 2;
+  total_size_scaled = total_size * scale;
+
   bg_size = MAX (total_size / 2, _BG_MIN_SIZE);
   emblem_size = MAX (bg_size - 8, _EMBLEM_MIN_SIZE);
 
-  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, total_size, total_size);
+  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, total_size_scaled, total_size_scaled);
+  cairo_surface_set_device_scale (surface, (gdouble) scale, (gdouble) scale);
   cr = cairo_create (surface);
 
   style = gtk_style_context_new ();
@@ -74,8 +222,8 @@ gd_create_symbolic_icon (const gchar *name,
   g_free (symbolic_name);
 
   theme = gtk_icon_theme_get_default();
-  info = gtk_icon_theme_lookup_by_gicon (theme, icon, emblem_size,
-                                         GTK_ICON_LOOKUP_FORCE_SIZE);
+  info = gtk_icon_theme_lookup_by_gicon_for_scale (theme, icon, emblem_size, scale,
+                                                   GTK_ICON_LOOKUP_FORCE_SIZE);
   g_object_unref (icon);
 
   if (info == NULL)
@@ -87,10 +235,13 @@ gd_create_symbolic_icon (const gchar *name,
   if (pixbuf == NULL)
     goto out;
 
-  gtk_render_icon (style, cr, pixbuf, (total_size - emblem_size) / 2,  (total_size - emblem_size) / 2);
+  icon_surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale, NULL);
   g_object_unref (pixbuf);
 
-  retval = G_ICON (gdk_pixbuf_get_from_surface (surface, 0, 0, total_size, total_size));
+  gtk_render_icon_surface (style, cr, icon_surface, (total_size - emblem_size) / 2,  (total_size - 
emblem_size) / 2);
+  cairo_surface_destroy (icon_surface);
+
+  retval = G_ICON (gdk_pixbuf_get_from_surface (surface, 0, 0, total_size_scaled, total_size_scaled));
 
  out:
   g_object_unref (style);
@@ -101,7 +252,21 @@ gd_create_symbolic_icon (const gchar *name,
 }
 
 /**
- * gd_embed_image_in_frame:
+ * gd_create_symbolic_icon:
+ * @name:
+ * @base_size:
+ *
+ * Returns: (transfer full):
+ */
+GIcon *
+gd_create_symbolic_icon (const gchar *name,
+                         gint base_size)
+{
+  return gd_create_symbolic_icon_for_scale (name, base_size, 1);
+}
+
+/**
+ * gd_embed_surface_in_frame:
  * @source_image:
  * @frame_image_url:
  * @slice_width:
@@ -110,27 +275,25 @@ gd_create_symbolic_icon (const gchar *name,
  * Returns: (transfer full):
  */
 cairo_surface_t *
-gd_embed_image_in_frame (cairo_surface_t *source_image,
-                         const gchar *frame_image_url,
-                         GtkBorder *slice_width,
-                         GtkBorder *border_width)
+gd_embed_surface_in_frame (cairo_surface_t *source_image,
+                           const gchar *frame_image_url,
+                           GtkBorder *slice_width,
+                           GtkBorder *border_width)
 {
   cairo_surface_t *surface;
   cairo_t *cr;
   int source_width, source_height;
-  int dest_width, dest_height;
   gchar *css_str;
   GtkCssProvider *provider;
   GtkStyleContext *context;
   GError *error = NULL;
-  GdkPixbuf *retval;
   GtkWidgetPath *path;
+  gdouble scale_x, scale_y;
 
-  source_width = cairo_image_surface_get_width (source_image);
-  source_height = cairo_image_surface_get_height (source_image);
+  cairo_surface_get_device_scale (source_image, &scale_x, &scale_y);
 
-  dest_width = source_width +  border_width->left + border_width->right;
-  dest_height = source_height + border_width->top + border_width->bottom;
+  source_width = cairo_image_surface_get_width (source_image) / (gint) floor (scale_x),
+  source_height = cairo_image_surface_get_height (source_image) / (gint) floor (scale_y);
 
   css_str = g_strdup_printf (".embedded-image { border-image: url(\"%s\") %d %d %d %d / %dpx %dpx %dpx %dpx 
}",
                              frame_image_url,
@@ -145,10 +308,12 @@ gd_embed_image_in_frame (cairo_surface_t *source_image,
       g_error_free (error);
       g_free (css_str);
 
-      return cairo_surface_reference (source_image);
+      return g_object_ref (source_image);
     }
 
-  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, dest_width, dest_height);
+  surface = cairo_surface_create_similar (source_image,
+                                          CAIRO_CONTENT_COLOR_ALPHA,
+                                          source_width, source_height);
   cr = cairo_create (surface);
 
   context = gtk_style_context_new ();
@@ -156,18 +321,28 @@ gd_embed_image_in_frame (cairo_surface_t *source_image,
   gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW);
 
   gtk_style_context_set_path (context, path);
-  gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (provider), 600);
-
+  gtk_style_context_add_provider (context,
+                                  GTK_STYLE_PROVIDER (provider),
+                                  GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+  cairo_save (cr);
+  cairo_rectangle (cr,
+                  border_width->left,
+                  border_width->top,
+                  source_width - border_width->left - border_width->right,
+                  source_height - border_width->top - border_width->bottom);
+  cairo_clip (cr);
   gtk_render_icon_surface (context, cr,
                            source_image,
-                           border_width->left, border_width->top);
+                           0, 0);
+  cairo_restore (cr);
 
   gtk_style_context_save (context);
   gtk_style_context_add_class (context, "embedded-image");
 
   gtk_render_frame (context, cr,
                     0, 0,
-                    dest_width, dest_height);
+                    source_width, source_height);
 
   gtk_style_context_restore (context);
   cairo_destroy (cr);
@@ -179,3 +354,41 @@ gd_embed_image_in_frame (cairo_surface_t *source_image,
 
   return surface;
 }
+
+/**
+ * gd_embed_image_in_frame:
+ * @source_image:
+ * @frame_image_url:
+ * @slice_width:
+ * @border_width:
+ *
+ * Returns: (transfer full):
+ */
+GdkPixbuf *
+gd_embed_image_in_frame (GdkPixbuf *source_image,
+                         const gchar *frame_image_url,
+                         GtkBorder *slice_width,
+                         GtkBorder *border_width)
+{
+  cairo_surface_t *surface, *embedded_surface;
+  GdkPixbuf *retval;
+
+  surface = gdk_cairo_surface_create_from_pixbuf (source_image,
+                                                  0, NULL);
+
+  /* Force the device scale to 1.0, since pixbufs are always in unscaled
+   * dimensions.
+   */
+  cairo_surface_set_device_scale (surface, 1.0, 1.0);
+  embedded_surface = gd_embed_surface_in_frame (surface, frame_image_url,
+                                                slice_width, border_width);
+  retval = gdk_pixbuf_get_from_surface (embedded_surface,
+                                        0, 0,
+                                        cairo_image_surface_get_width (embedded_surface),
+                                        cairo_image_surface_get_height (embedded_surface));
+
+  cairo_surface_destroy (embedded_surface);
+  cairo_surface_destroy (surface);
+
+  return retval;
+}
diff --git a/cut-n-paste/libgd/gd-icon-utils.h b/cut-n-paste/libgd/gd-icon-utils.h
index 92abbe1..12f4f06 100644
--- a/cut-n-paste/libgd/gd-icon-utils.h
+++ b/cut-n-paste/libgd/gd-icon-utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2012 Red Hat, Inc.
+ * Copyright (c) 2011, 2012, 2015, 2016 Red Hat, Inc.
  *
  * Gnome Documents is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by the
@@ -22,14 +22,28 @@
 #ifndef __GD_CREATE_SYMBOLIC_ICON_H__
 #define __GD_CREATE_SYMBOLIC_ICON_H__
 
+#include <cairo.h>
 #include <gtk/gtk.h>
 
+cairo_surface_t *gd_copy_image_surface (cairo_surface_t *surface);
+
+cairo_surface_t *gd_create_surface_with_counter (GtkWidget *widget,
+                                                 cairo_surface_t *base,
+                                                 gint number);
+
 GIcon *gd_create_symbolic_icon (const gchar *name,
                                 gint base_size);
+GIcon *gd_create_symbolic_icon_for_scale (const gchar *name,
+                                          gint base_size,
+                                          gint scale);
 
-cairo_surface_t *gd_embed_image_in_frame (cairo_surface_t *source_image,
-                                          const gchar *frame_image_url,
-                                          GtkBorder *slice_width,
-                                          GtkBorder *border_width);
+GdkPixbuf *gd_embed_image_in_frame (GdkPixbuf *source_image,
+                                    const gchar *frame_image_url,
+                                    GtkBorder *slice_width,
+                                    GtkBorder *border_width);
+cairo_surface_t *gd_embed_surface_in_frame (cairo_surface_t *source_image,
+                                            const gchar *frame_image_url,
+                                            GtkBorder *slice_width,
+                                            GtkBorder *border_width);
 
 #endif /* __GD_CREATE_SYMBOLIC_ICON_H__ */
diff --git a/cut-n-paste/libgd/gd-two-lines-renderer.c b/cut-n-paste/libgd/gd-two-lines-renderer.c
index aeb8a6f..5a029f7 100644
--- a/cut-n-paste/libgd/gd-two-lines-renderer.c
+++ b/cut-n-paste/libgd/gd-two-lines-renderer.c
@@ -22,6 +22,9 @@
 #include "gd-two-lines-renderer.h"
 #include <string.h>
 
+#define SUBTITLE_DIM_PERCENTAGE 0.55
+#define SUBTITLE_SIZE_PERCENTAGE 0.82
+
 G_DEFINE_TYPE (GdTwoLinesRenderer, gd_two_lines_renderer, GTK_TYPE_CELL_RENDERER_TEXT)
 
 struct _GdTwoLinesRendererPrivate {
@@ -79,6 +82,36 @@ create_layout_with_attrs (GtkWidget *widget,
 }
 
 static void
+apply_subtitle_style_to_layout (GtkStyleContext *context,
+                                PangoLayout     *layout,
+                                GtkStateFlags    flags)
+{
+  PangoFontDescription *desc;
+  PangoAttrList *layout_attr;
+  PangoAttribute *attr_alpha;
+
+  gtk_style_context_save (context);
+  gtk_style_context_set_state (context, flags);
+  gtk_style_context_get (context, gtk_style_context_get_state (context),
+                         "font", &desc,
+                         NULL);
+  gtk_style_context_restore (context);
+
+  /* Set the font size */
+  pango_font_description_set_size (desc, pango_font_description_get_size (desc) * SUBTITLE_SIZE_PERCENTAGE);
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  /* Set the font alpha */
+  layout_attr = pango_attr_list_new ();
+  attr_alpha = pango_attr_foreground_alpha_new (SUBTITLE_DIM_PERCENTAGE * 65535);
+  pango_attr_list_insert (layout_attr, attr_alpha);
+
+  pango_layout_set_attributes (layout, layout_attr);
+  pango_attr_list_unref (layout_attr);
+}
+
+static void
 gd_two_lines_renderer_prepare_layouts (GdTwoLinesRenderer *self,
                                        const GdkRectangle *cell_area,
                                        GtkWidget *widget,
@@ -106,9 +139,16 @@ gd_two_lines_renderer_prepare_layouts (GdTwoLinesRenderer *self,
     }
   else
     {
+      GtkStyleContext *context;
+
       line_two = create_layout_with_attrs (widget, cell_area,
                                            self, PANGO_ELLIPSIZE_END);
 
+      context = gtk_widget_get_style_context (widget);
+      gtk_style_context_save (context);
+      apply_subtitle_style_to_layout (context, line_two, GTK_STATE_FLAG_NORMAL);
+      gtk_style_context_restore (context);
+
       pango_layout_set_height (line_one, - (self->priv->text_lines - 1));
       pango_layout_set_height (line_two, -1);
       pango_layout_set_text (line_two, self->priv->line_two, -1);
@@ -278,7 +318,8 @@ gd_two_lines_renderer_render (GtkCellRenderer      *cell,
                                    NULL, &line_one_height);
 
       gtk_style_context_save (context);
-      gtk_style_context_add_class (context, "dim-label");
+
+      apply_subtitle_style_to_layout (context, layout_two, flags);
 
       state = gtk_cell_renderer_get_state (cell, widget, flags);
       gtk_style_context_set_state (context, state);
@@ -329,11 +370,12 @@ gd_two_lines_renderer_get_preferred_width (GtkCellRenderer *cell,
                                   NULL, 
                                   NULL, NULL, NULL);
 
-  /* Fetch the average size of a charachter */
+  /* Fetch the average size of a character */
   context = gtk_widget_get_pango_context (widget);
   gtk_style_context_save (style_context);
   gtk_style_context_set_state (style_context, 0);
-  gtk_style_context_get (style_context, 0, "font", &font_desc, NULL);
+  gtk_style_context_get (style_context, gtk_style_context_get_state (style_context),
+                         "font", &font_desc, NULL);
   gtk_style_context_restore (style_context);
   metrics = pango_context_get_metrics (context, font_desc,
                                        pango_context_get_language (context));
diff --git a/shell/ev-recent-view.c b/shell/ev-recent-view.c
index b194acc..953fee8 100644
--- a/shell/ev-recent-view.c
+++ b/shell/ev-recent-view.c
@@ -307,9 +307,9 @@ add_thumbnail_to_model (GetDocumentInfoAsyncData *data,
         border.top = 3;
         border.bottom = 6;
 
-        surface = gd_embed_image_in_frame (thumbnail,
-                                           "resource:///org/gnome/evince/shell/ui/thumbnail-frame.png",
-                                           &border, &border);
+        surface = gd_embed_surface_in_frame (thumbnail,
+                                             "resource:///org/gnome/evince/shell/ui/thumbnail-frame.png",
+                                             &border, &border);
 
         path = gtk_tree_row_reference_get_path (data->row);
         if (path != NULL) {
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]