gtk2/gtk/gtkwidgetpaintable.c

/*
 * Copyright © 2018 Benjamin Otte
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors: Benjamin Otte <otte@gnome.org>
 */

#include "config.h"

#include "gtkwidgetpaintableprivate.h"

#include "gtkintl.h"
#include "gtksnapshot.h"
#include "gtkrendernodepaintableprivate.h"
#include "gtkwidgetprivate.h"

/**
 * SECTION:gtkwidgetpaintable
 * @Short_description: Drawing a widget elsewhere
 * @Title: GtkWidgetPaintable
 * @see_also: #GtkWidget, #GdkPaintable
 *
 * GtkWidgetPaintable is an implementation of the #GdkPaintable interface 
 * that allows displaying the contents of a #GtkWidget.
 *
 * GtkWidgetPaintable will also take care of the widget not being in a
 * state where it can be drawn (like when it isn't shown) and just draw
 * nothing or where it does not have a size (like when it is hidden) and
 * report no size in that case.
 *
 * Of course, GtkWidgetPaintable allows you to monitor widgets for size
 * changes by emitting the #GdkPaintable::invalidate-size signal whenever
 * the size of the widget changes as well as for visual changes by
 * emitting the #GdkPaintable::invalidate-contents signal whenever the
 * widget changes.
 *
 * You can of course use a GtkWidgetPaintable everywhere a
 * #GdkPaintable is allowed, including using it on a #GtkPicture (or one
 * of its parents) that it was set on itself via gtk_picture_set_paintable().
 * The paintable will take care of recursion when this happens. If you do
 * this however, ensure the #GtkPicture:can-shrink property is set to
 * %TRUE or you might end up with an infinitely growing widget.
 */
struct _GtkWidgetPaintable
{
  GObject parent_instance;

  GtkWidget *widget;
  guint snapshot_count;

  GdkPaintable *current_image;          /* the image that we are presenting */
  GdkPaintable *pending_image;          /* the image that we should be presenting */
  guint         pending_update_cb;      /* the idle source that updates the valid image to be the new current image */
};

struct _GtkWidgetPaintableClass
{
  GObjectClass parent_class;
};

enum {
  PROP_0,
  PROP_WIDGET,

  N_PROPS,
};

static GParamSpec *properties[N_PROPS] = { NULL, };

static void
gtk_widget_paintable_paintable_snapshot (GdkPaintable *paintable,
                                         GdkSnapshot  *snapshot,
                                         double        width,
                                         double        height)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (paintable);

  if (self->snapshot_count > 4)
    return;
  else if (self->snapshot_count > 0)
    {
      graphene_matrix_t transform;
      graphene_rect_t bounds;

      gtk_snapshot_push_clip (snapshot,
                              &GRAPHENE_RECT_INIT(0, 0, width, height));
      gtk_widget_compute_bounds (self->widget, self->widget, &bounds);
      graphene_matrix_init_from_2d (&transform,
                                    width / bounds.size.width, 0.0,
                                    0.0, height / bounds.size.height,
                                    bounds.origin.x, bounds.origin.y);
      gtk_snapshot_push_transform (snapshot, &transform);

      gtk_widget_snapshot (self->widget, snapshot);

      gtk_snapshot_pop (snapshot);
      gtk_snapshot_pop (snapshot);
    }
  else
    {
      gdk_paintable_snapshot (self->current_image, snapshot, width, height);
    }
}

static GdkPaintable *
gtk_widget_paintable_paintable_get_current_image (GdkPaintable *paintable)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (paintable);

  return g_object_ref (self->current_image);
}

static int
gtk_widget_paintable_paintable_get_intrinsic_width (GdkPaintable *paintable)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (paintable);

  return gdk_paintable_get_intrinsic_width (self->current_image);
}

static int
gtk_widget_paintable_paintable_get_intrinsic_height (GdkPaintable *paintable)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (paintable);

  return gdk_paintable_get_intrinsic_height (self->current_image);
}

static void
gtk_widget_paintable_paintable_init (GdkPaintableInterface *iface)
{
  iface->snapshot = gtk_widget_paintable_paintable_snapshot;
  iface->get_current_image = gtk_widget_paintable_paintable_get_current_image;
  iface->get_intrinsic_width = gtk_widget_paintable_paintable_get_intrinsic_width;
  iface->get_intrinsic_height = gtk_widget_paintable_paintable_get_intrinsic_height;
}

G_DEFINE_TYPE_EXTENDED (GtkWidgetPaintable, gtk_widget_paintable, G_TYPE_OBJECT, 0,
                        G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
                                               gtk_widget_paintable_paintable_init))

static void
gtk_widget_paintable_set_property (GObject      *object,
                                   guint         prop_id,
                                   const GValue *value,
                                   GParamSpec   *pspec)

{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (object);

  switch (prop_id)
    {
    case PROP_WIDGET:
      gtk_widget_paintable_set_widget (self, g_value_get_object (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
gtk_widget_paintable_get_property (GObject    *object,
                                   guint       prop_id,
                                   GValue     *value,
                                   GParamSpec *pspec)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (object);

  switch (prop_id)
    {
    case PROP_WIDGET:
      g_value_set_object (value, self->widget);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
gtk_widget_paintable_dispose (GObject *object)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (object);

  gtk_widget_paintable_set_widget (self, NULL);

  G_OBJECT_CLASS (gtk_widget_paintable_parent_class)->dispose (object);
}

static void
gtk_widget_paintable_finalize (GObject *object)
{
  GtkWidgetPaintable *self = GTK_WIDGET_PAINTABLE (object);

  g_object_unref (self->current_image);

  G_OBJECT_CLASS (gtk_widget_paintable_parent_class)->finalize (object);
}

static void
gtk_widget_paintable_class_init (GtkWidgetPaintableClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->get_property = gtk_widget_paintable_get_property;
  gobject_class->set_property = gtk_widget_paintable_set_property;
  gobject_class->dispose = gtk_widget_paintable_dispose;
  gobject_class->finalize = gtk_widget_paintable_finalize;

  /**
   * GtkWidgetPaintable:widget
   *
   * The observed widget or %NULL if none.
   */
  properties[PROP_WIDGET] =
    g_param_spec_object ("widget",
                         P_("Widget"),
                         P_("Observed widget"),
                         GTK_TYPE_WIDGET,
                         G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);

  g_object_class_install_properties (gobject_class, N_PROPS, properties);
}

static void
gtk_widget_paintable_init (GtkWidgetPaintable *self)
{
  self->current_image = gdk_paintable_new_empty (0, 0);
}

/**
 * gtk_widget_paintable_new:
 * @widget: (allow-none) (transfer none): a #GtkWidget or %NULL
 *
 * Creates a new widget paintable observing the given widget.
 *
 * Returns: (transfer full) (type GtkWidgetPaintable): a new #GtkWidgetPaintable
 **/
GdkPaintable *
gtk_widget_paintable_new (GtkWidget *widget)
{
  g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);

  return g_object_new (GTK_TYPE_WIDGET_PAINTABLE,
                       "widget", widget,
                       NULL);
}

static GdkPaintable *
gtk_widget_paintable_snapshot_widget (GtkWidgetPaintable *self)
{
  graphene_rect_t bounds;

  if (self->widget == NULL)
    return gdk_paintable_new_empty (0, 0);

  gtk_widget_compute_bounds (self->widget, self->widget, &bounds);

  if (self->widget->priv->render_node == NULL)
    return gdk_paintable_new_empty (bounds.size.width, bounds.size.height);
  
  return gtk_render_node_paintable_new (self->widget->priv->render_node, &bounds);
}

/**
 * gtk_widget_paintable_get_widget:
 * @self: a #GtkWidgetPaintable
 *
 * Returns the widget that is observed or %NULL
 * if none.
 *
 * Returns: (transfer none) (nullable): the observed widget.
 **/
GtkWidget *
gtk_widget_paintable_get_widget (GtkWidgetPaintable *self)
{
  g_return_val_if_fail (GTK_IS_WIDGET_PAINTABLE (self), NULL);

  return self->widget;
}

/**
 * gtk_widget_paintable_set_widget:
 * @self: a #GtkWidgetPaintable
 * @widget: (allow-none): the widget to observe or %NULL
 *
 * Sets the widget that should be observed.
 **/
void
gtk_widget_paintable_set_widget (GtkWidgetPaintable *self,
                                 GtkWidget          *widget)
{

  g_return_if_fail (GTK_IS_WIDGET_PAINTABLE (self));
  g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));

  if (self->widget == widget)
    return;

  if (self->widget)
    {
      self->widget->priv->paintables = g_slist_remove (self->widget->priv->paintables,
                                                       self);
    }

  /* We do not ref the widget to not cause ref cycles when a widget
   * is told to observe itself or one of its parent.
   */
  self->widget = widget;

  if (widget)
    {
      widget->priv->paintables = g_slist_prepend (widget->priv->paintables,
                                                  self);
    }

  g_object_unref (self->current_image);
  self->current_image = gtk_widget_paintable_snapshot_widget (self);
  g_clear_object (&self->pending_image);
  if (self->pending_update_cb)
    {
      g_source_remove (self->pending_update_cb);
      self->pending_update_cb = 0;
    }

  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_WIDGET]);
  gdk_paintable_invalidate_size (GDK_PAINTABLE (self));
  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
}

static gboolean
gtk_widget_paintable_update_func (gpointer data)
{
  GtkWidgetPaintable *self = data;
  GdkPaintable *old_image;

  if (self->current_image != self->pending_image)
    {
      old_image = self->current_image;
      self->current_image = self->pending_image;
      self->pending_image = NULL;
      self->pending_update_cb = 0;

      if (gdk_paintable_get_intrinsic_width (self->current_image) != gdk_paintable_get_intrinsic_width (old_image) ||
          gdk_paintable_get_intrinsic_height (self->current_image) != gdk_paintable_get_intrinsic_height (old_image))
        gdk_paintable_invalidate_size (GDK_PAINTABLE (self));

      g_object_unref (old_image);

      gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
    }
  else
    {
      g_clear_object (&self->pending_image);
      self->pending_update_cb = 0;
    }

  return G_SOURCE_REMOVE;
}

void
gtk_widget_paintable_update_image (GtkWidgetPaintable *self)
{
  GdkPaintable *pending_image;

  if (self->pending_update_cb == 0)
    {
      self->pending_update_cb = g_idle_add_full (G_PRIORITY_HIGH,
                                                 gtk_widget_paintable_update_func,
                                                 self,
                                                 NULL);
    }

  pending_image = gtk_widget_paintable_snapshot_widget (self);
  g_set_object (&self->pending_image, pending_image);
  g_object_unref (pending_image);
}

void
gtk_widget_paintable_push_snapshot_count (GtkWidgetPaintable *self)
{
  self->snapshot_count++;
}

void
gtk_widget_paintable_pop_snapshot_count (GtkWidgetPaintable *self)
{
  self->snapshot_count--;
}