forked from AuroraMiddleware/gtk
405 lines
12 KiB
C
405 lines
12 KiB
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_rect_t bounds;
|
|
|
|
gtk_snapshot_push_clip (snapshot,
|
|
&GRAPHENE_RECT_INIT(0, 0, width, height));
|
|
|
|
if (gtk_widget_compute_bounds (self->widget, self->widget, &bounds))
|
|
{
|
|
gtk_snapshot_scale (snapshot, width / bounds.size.width, height / bounds.size.height);
|
|
gtk_snapshot_translate (snapshot, &bounds.origin);
|
|
}
|
|
|
|
gtk_widget_snapshot (self->widget, 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);
|
|
|
|
if (!gtk_widget_compute_bounds (self->widget, self->widget, &bounds))
|
|
return gdk_paintable_new_empty (0, 0);
|
|
|
|
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--;
|
|
}
|
|
|