From: Benjamin Otte Date: Sat, 17 Feb 2018 19:29:25 +0000 (+0100) Subject: cssimage: Add GtkCssImagePaintable X-Git-Tag: archive/raspbian/4.4.1+ds1-2+rpi1^2~18^2~22^2~951 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=3faa7e04dbc69ec8f5a60f7bcc18c1b701796137;p=gtk4.git cssimage: Add GtkCssImagePaintable This type can hold any GdkPaintable. Use it to replace GtkCssImageSurface, which used to hold a GdkTexture. --- diff --git a/gtk/gtkcssimagefallback.c b/gtk/gtkcssimagefallback.c index 75b3d4dd9a..8f869ccac3 100644 --- a/gtk/gtkcssimagefallback.c +++ b/gtk/gtkcssimagefallback.c @@ -20,7 +20,6 @@ #include "config.h" #include "gtkcssimagefallbackprivate.h" -#include "gtkcssimagesurfaceprivate.h" #include "gtkcsscolorvalueprivate.h" #include "gtkcssrgbavalueprivate.h" diff --git a/gtk/gtkcssimagepaintable.c b/gtk/gtkcssimagepaintable.c new file mode 100644 index 0000000000..327ca90862 --- /dev/null +++ b/gtk/gtkcssimagepaintable.c @@ -0,0 +1,193 @@ +/* + * Copyright © 2018 Red Hat Inc. + * + * 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 . + * + * Authors: Benjamin Otte + */ + +#include "config.h" + +#include "gtkcssimagepaintableprivate.h" + +#include "gtkprivate.h" + +G_DEFINE_TYPE (GtkCssImagePaintable, gtk_css_image_paintable, GTK_TYPE_CSS_IMAGE) + +static inline GdkPaintable * +get_paintable (GtkCssImagePaintable *paintable) +{ + if (paintable->static_paintable) + return paintable->static_paintable; + + return paintable->paintable; +} + +static int +gtk_css_image_paintable_get_width (GtkCssImage *image) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (image); + + return gdk_paintable_get_intrinsic_width (get_paintable (paintable)); +} + +static int +gtk_css_image_paintable_get_height (GtkCssImage *image) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (image); + + return gdk_paintable_get_intrinsic_height (get_paintable (paintable)); +} + +static double +gtk_css_image_paintable_get_aspect_ratio (GtkCssImage *image) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (image); + + return gdk_paintable_get_intrinsic_aspect_ratio (get_paintable (paintable)); +} + +static void +gtk_css_image_paintable_snapshot (GtkCssImage *image, + GtkSnapshot *snapshot, + double width, + double height) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (image); + + return gdk_paintable_snapshot (get_paintable (paintable), + snapshot, + width, height); +} + +static GtkCssImage * +gtk_css_image_paintable_get_static_image (GtkCssImage *image) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (image); + GdkPaintable *static_image; + GtkCssImage *result; + + static_image = gdk_paintable_get_current_image (paintable->paintable); + + if (paintable->static_paintable == static_image) + { + result = g_object_ref (image); + } + else + { + result = gtk_css_image_paintable_new (paintable->paintable, + static_image); + } + + g_object_unref (static_image); + + return result; +} + +static GtkCssImage * +gtk_css_image_paintable_compute (GtkCssImage *image, + guint property_id, + GtkStyleProvider *provider, + GtkCssStyle *style, + GtkCssStyle *parent_style) +{ + return gtk_css_image_paintable_get_static_image (image); +} + +static gboolean +gtk_css_image_paintable_equal (GtkCssImage *image1, + GtkCssImage *image2) +{ + GtkCssImagePaintable *paintable1 = GTK_CSS_IMAGE_PAINTABLE (image1); + GtkCssImagePaintable *paintable2 = GTK_CSS_IMAGE_PAINTABLE (image2); + + return paintable1->paintable == paintable2->paintable + && paintable1->static_paintable == paintable2->static_paintable; +} + +#define GDK_PAINTABLE_IMMUTABLE (GDK_PAINTABLE_STATIC_SIZE | GDK_PAINTABLE_STATIC_CONTENTS) +static gboolean +gtk_css_image_paintable_is_dynamic (GtkCssImage *image) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (image); + + return (gdk_paintable_get_flags (paintable->paintable) & GDK_PAINTABLE_IMMUTABLE) == GDK_PAINTABLE_IMMUTABLE; +} + +static GtkCssImage * +gtk_css_image_paintable_get_dynamic_image (GtkCssImage *image, + gint64 monotonic_time) +{ + return gtk_css_image_paintable_get_static_image (image); +} + +static void +gtk_css_image_paintable_print (GtkCssImage *image, + GString *string) +{ + g_string_append (string, "none /* FIXME */"); +} + +static void +gtk_css_image_paintable_dispose (GObject *object) +{ + GtkCssImagePaintable *paintable = GTK_CSS_IMAGE_PAINTABLE (object); + + g_clear_object (&paintable->paintable); + g_clear_object (&paintable->static_paintable); + + G_OBJECT_CLASS (gtk_css_image_paintable_parent_class)->dispose (object); +} + +static void +gtk_css_image_paintable_class_init (GtkCssImagePaintableClass *klass) +{ + GtkCssImageClass *image_class = GTK_CSS_IMAGE_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + image_class->get_width = gtk_css_image_paintable_get_width; + image_class->get_height = gtk_css_image_paintable_get_height; + image_class->get_aspect_ratio = gtk_css_image_paintable_get_aspect_ratio; + image_class->snapshot = gtk_css_image_paintable_snapshot; + image_class->print = gtk_css_image_paintable_print; + image_class->compute = gtk_css_image_paintable_compute; + image_class->equal = gtk_css_image_paintable_equal; + image_class->is_dynamic = gtk_css_image_paintable_is_dynamic; + image_class->get_dynamic_image = gtk_css_image_paintable_get_dynamic_image; + + object_class->dispose = gtk_css_image_paintable_dispose; +} + +static void +gtk_css_image_paintable_init (GtkCssImagePaintable *image_paintable) +{ +} + +GtkCssImage * +gtk_css_image_paintable_new (GdkPaintable *paintable, + GdkPaintable *static_paintable) +{ + GtkCssImage *image; + + gtk_internal_return_val_if_fail (GDK_IS_PAINTABLE (paintable), NULL); + gtk_internal_return_val_if_fail (static_paintable == NULL || GDK_IS_PAINTABLE (static_paintable), NULL); + + image = g_object_new (GTK_TYPE_CSS_IMAGE_PAINTABLE, NULL); + + GTK_CSS_IMAGE_PAINTABLE (image)->paintable = g_object_ref (paintable); + if (static_paintable) + GTK_CSS_IMAGE_PAINTABLE (image)->static_paintable = g_object_ref (static_paintable); + + return image; +} diff --git a/gtk/gtkcssimagepaintableprivate.h b/gtk/gtkcssimagepaintableprivate.h new file mode 100644 index 0000000000..5b3dbf4145 --- /dev/null +++ b/gtk/gtkcssimagepaintableprivate.h @@ -0,0 +1,57 @@ +/* + * Copyright © 2018 Red Hat Inc. + * + * 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 . + * + * Authors: Benjamin Otte + */ + +#ifndef __GTK_CSS_IMAGE_PAINTABLE_PRIVATE_H__ +#define __GTK_CSS_IMAGE_PAINTABLE_PRIVATE_H__ + +#include "gtk/gtkcssimageprivate.h" + +G_BEGIN_DECLS + +#define GTK_TYPE_CSS_IMAGE_PAINTABLE (gtk_css_image_paintable_get_type ()) +#define GTK_CSS_IMAGE_PAINTABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GTK_TYPE_CSS_IMAGE_PAINTABLE, GtkCssImagePaintable)) +#define GTK_CSS_IMAGE_PAINTABLE_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GTK_TYPE_CSS_IMAGE_PAINTABLE, GtkCssImagePaintableClass)) +#define GTK_IS_CSS_IMAGE_PAINTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GTK_TYPE_CSS_IMAGE_PAINTABLE)) +#define GTK_IS_CSS_IMAGE_PAINTABLE_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GTK_TYPE_CSS_IMAGE_PAINTABLE)) +#define GTK_CSS_IMAGE_PAINTABLE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CSS_IMAGE_PAINTABLE, GtkCssImagePaintableClass)) + +typedef struct _GtkCssImagePaintable GtkCssImagePaintable; +typedef struct _GtkCssImagePaintableClass GtkCssImagePaintableClass; + +struct _GtkCssImagePaintable +{ + GtkCssImage parent; + + GdkPaintable *paintable; /* the paintable we observe */ + GdkPaintable *static_paintable; /* the paintable we render (only set for computed values) */ +}; + +struct _GtkCssImagePaintableClass +{ + GtkCssImageClass parent_class; +}; + +GType gtk_css_image_paintable_get_type (void) G_GNUC_CONST; + +GtkCssImage * gtk_css_image_paintable_new (GdkPaintable *paintable, + GdkPaintable *static_paintable); + +G_END_DECLS + +#endif /* __GTK_CSS_IMAGE_PAINTABLE_PRIVATE_H__ */ diff --git a/gtk/gtkcssimagerecolor.c b/gtk/gtkcssimagerecolor.c index b3c3423d97..41c95e99f4 100644 --- a/gtk/gtkcssimagerecolor.c +++ b/gtk/gtkcssimagerecolor.c @@ -21,7 +21,6 @@ #include "gtkcssimagerecolorprivate.h" #include "gtkcssimageprivate.h" -#include "gtkcssimagesurfaceprivate.h" #include "gtkcsspalettevalueprivate.h" #include "gtkcssrgbavalueprivate.h" #include "gtkiconthemeprivate.h" diff --git a/gtk/gtkcssimagesurface.c b/gtk/gtkcssimagesurface.c deleted file mode 100644 index 202d850b77..0000000000 --- a/gtk/gtkcssimagesurface.c +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright © 2011 Red Hat Inc. - * - * 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 . - * - * Authors: Benjamin Otte - */ - -#include "config.h" - -#include "gtkcssimagesurfaceprivate.h" - -G_DEFINE_TYPE (GtkCssImageSurface, _gtk_css_image_surface, GTK_TYPE_CSS_IMAGE) - -static int -gtk_css_image_surface_get_width (GtkCssImage *image) -{ - GtkCssImageSurface *surface = GTK_CSS_IMAGE_SURFACE (image); - - if (surface->texture == NULL) - return 0; - - return gdk_texture_get_width (surface->texture); -} - -static int -gtk_css_image_surface_get_height (GtkCssImage *image) -{ - GtkCssImageSurface *surface = GTK_CSS_IMAGE_SURFACE (image); - - if (surface->texture == NULL) - return 0; - - return gdk_texture_get_height (surface->texture); -} - -static void -gtk_css_image_surface_snapshot (GtkCssImage *image, - GtkSnapshot *snapshot, - double width, - double height) -{ - GtkCssImageSurface *surface = GTK_CSS_IMAGE_SURFACE (image); - - if (surface->texture == NULL) - return; - - gtk_snapshot_append_texture (snapshot, - surface->texture, - &GRAPHENE_RECT_INIT (0, 0, width, height), - "Surface Image %dx%d", - gdk_texture_get_width (surface->texture), - gdk_texture_get_height (surface->texture)); -} - -static void -gtk_css_image_surface_print (GtkCssImage *image, - GString *string) -{ - g_string_append (string, "none /* FIXME */"); -} - -static void -gtk_css_image_surface_dispose (GObject *object) -{ - GtkCssImageSurface *surface = GTK_CSS_IMAGE_SURFACE (object); - - g_clear_object (&surface->texture); - - G_OBJECT_CLASS (_gtk_css_image_surface_parent_class)->dispose (object); -} - -static void -_gtk_css_image_surface_class_init (GtkCssImageSurfaceClass *klass) -{ - GtkCssImageClass *image_class = GTK_CSS_IMAGE_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - image_class->get_width = gtk_css_image_surface_get_width; - image_class->get_height = gtk_css_image_surface_get_height; - image_class->snapshot = gtk_css_image_surface_snapshot; - image_class->print = gtk_css_image_surface_print; - - object_class->dispose = gtk_css_image_surface_dispose; -} - -static void -_gtk_css_image_surface_init (GtkCssImageSurface *image_surface) -{ -} - -GtkCssImage * -gtk_css_image_surface_new (GdkTexture *texture) -{ - GtkCssImage *image; - - image = g_object_new (GTK_TYPE_CSS_IMAGE_SURFACE, NULL); - - if (texture) - GTK_CSS_IMAGE_SURFACE (image)->texture = g_object_ref (texture); - - return image; -} diff --git a/gtk/gtkcssimagesurfaceprivate.h b/gtk/gtkcssimagesurfaceprivate.h deleted file mode 100644 index e820a08663..0000000000 --- a/gtk/gtkcssimagesurfaceprivate.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright © 2011 Red Hat Inc. - * - * 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 . - * - * Authors: Benjamin Otte - */ - -#ifndef __GTK_CSS_IMAGE_SURFACE_PRIVATE_H__ -#define __GTK_CSS_IMAGE_SURFACE_PRIVATE_H__ - -#include "gtk/gtkcssimageprivate.h" - -G_BEGIN_DECLS - -#define GTK_TYPE_CSS_IMAGE_SURFACE (_gtk_css_image_surface_get_type ()) -#define GTK_CSS_IMAGE_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST (obj, GTK_TYPE_CSS_IMAGE_SURFACE, GtkCssImageSurface)) -#define GTK_CSS_IMAGE_SURFACE_CLASS(cls) (G_TYPE_CHECK_CLASS_CAST (cls, GTK_TYPE_CSS_IMAGE_SURFACE, GtkCssImageSurfaceClass)) -#define GTK_IS_CSS_IMAGE_SURFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE (obj, GTK_TYPE_CSS_IMAGE_SURFACE)) -#define GTK_IS_CSS_IMAGE_SURFACE_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE (obj, GTK_TYPE_CSS_IMAGE_SURFACE)) -#define GTK_CSS_IMAGE_SURFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CSS_IMAGE_SURFACE, GtkCssImageSurfaceClass)) - -typedef struct _GtkCssImageSurface GtkCssImageSurface; -typedef struct _GtkCssImageSurfaceClass GtkCssImageSurfaceClass; - -struct _GtkCssImageSurface -{ - GtkCssImage parent; - - GdkTexture *texture; /* the texture we render */ -}; - -struct _GtkCssImageSurfaceClass -{ - GtkCssImageClass parent_class; -}; - -GType _gtk_css_image_surface_get_type (void) G_GNUC_CONST; - -GtkCssImage * gtk_css_image_surface_new (GdkTexture *texture); - -G_END_DECLS - -#endif /* __GTK_CSS_IMAGE_SURFACE_PRIVATE_H__ */ diff --git a/gtk/gtkcssimageurl.c b/gtk/gtkcssimageurl.c index 690afc473d..042ade52ff 100644 --- a/gtk/gtkcssimageurl.c +++ b/gtk/gtkcssimageurl.c @@ -24,7 +24,7 @@ #include "gtkcssimageurlprivate.h" #include "gtkcssimageinvalidprivate.h" -#include "gtkcssimagesurfaceprivate.h" +#include "gtkcssimagepaintableprivate.h" #include "gtkstyleproviderprivate.h" G_DEFINE_TYPE (GtkCssImageUrl, _gtk_css_image_url, GTK_TYPE_CSS_IMAGE) @@ -75,7 +75,7 @@ gtk_css_image_url_load_image (GtkCssImageUrl *url, } else { - url->loaded_image = gtk_css_image_surface_new (texture); + url->loaded_image = gtk_css_image_paintable_new (GDK_PAINTABLE (texture), GDK_PAINTABLE (texture)); g_object_unref (texture); } diff --git a/gtk/meson.build b/gtk/meson.build index 112d110910..63b374c848 100644 --- a/gtk/meson.build +++ b/gtk/meson.build @@ -48,10 +48,10 @@ gtk_private_sources = files([ 'gtkcssimageicontheme.c', 'gtkcssimageinvalid.c', 'gtkcssimagelinear.c', + 'gtkcssimagepaintable.c', 'gtkcssimageradial.c', 'gtkcssimagerecolor.c', 'gtkcssimagescaled.c', - 'gtkcssimagesurface.c', 'gtkcssimageurl.c', 'gtkcssimagevalue.c', 'gtkcssimagewin32.c',