gtk2/gtk/gtkcssimagecrossfade.c
Benjamin Otte a76f515569 cssimagecrossfade: Don't abort() when failing to parse image
The code wasn't checking if parsing an image failed and just returning
success.

Testcase from bug is attached.

Fixes #4101
2021-07-16 17:50:09 +02:00

500 lines
14 KiB
C

/*
* Copyright © 2012 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 <http://www.gnu.org/licenses/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
*/
#include "config.h"
#include <math.h>
#include <string.h>
#include "gtkcssimagecrossfadeprivate.h"
#include "gtkcssnumbervalueprivate.h"
#include "gtkcssimagefallbackprivate.h"
#include "gtkcsscolorvalueprivate.h"
typedef struct _CrossFadeEntry CrossFadeEntry;
struct _CrossFadeEntry
{
double progress;
gboolean has_progress;
GtkCssImage *image;
};
G_DEFINE_TYPE (GtkCssImageCrossFade, gtk_css_image_cross_fade, GTK_TYPE_CSS_IMAGE)
static void
cross_fade_entry_clear (gpointer data)
{
CrossFadeEntry *entry = data;
g_clear_object (&entry->image);
}
static void
gtk_css_image_cross_fade_recalculate_progress (GtkCssImageCrossFade *self)
{
double total_progress;
guint n_no_progress;
guint i;
total_progress = 0.0;
n_no_progress = 0;
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
if (entry->has_progress)
total_progress += entry->progress;
else
n_no_progress++;
}
if (n_no_progress)
{
double progress;
if (total_progress >= 1.0)
{
progress = 0.0;
}
else
{
progress = (1.0 - total_progress) / n_no_progress;
total_progress = 1.0;
}
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
if (!entry->has_progress)
entry->progress = progress;
}
}
self->total_progress = total_progress;
}
static void
gtk_css_image_cross_fade_add (GtkCssImageCrossFade *self,
gboolean has_progress,
double progress,
GtkCssImage *image)
{
CrossFadeEntry entry;
entry.has_progress = has_progress;
entry.progress = progress;
entry.image = image;
g_array_append_val (self->images, entry);
gtk_css_image_cross_fade_recalculate_progress (self);
}
static GtkCssImageCrossFade *
gtk_css_image_cross_fade_new_empty (void)
{
return g_object_new (GTK_TYPE_CSS_IMAGE_CROSS_FADE, NULL);
}
/* XXX: The following is not correct, it should actually run the
* CSS sizing algorithm for every child, not just query height and
* width independently.
*/
static int
gtk_css_image_cross_fade_get_width (GtkCssImage *image)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
double sum_width, sum_progress;
guint i;
sum_width = 0.0;
sum_progress = 0.0;
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
int image_width;
image_width = _gtk_css_image_get_width (entry->image);
if (image_width == 0)
continue;
sum_width += image_width * entry->progress;
sum_progress += entry->progress;
}
if (sum_progress <= 0.0)
return 0;
return ceil (sum_width / sum_progress);
}
static int
gtk_css_image_cross_fade_get_height (GtkCssImage *image)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
double sum_height, sum_progress;
guint i;
sum_height = 0.0;
sum_progress = 0.0;
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
int image_height;
image_height = _gtk_css_image_get_height (entry->image);
if (image_height == 0)
continue;
sum_height += image_height * entry->progress;
sum_progress += entry->progress;
}
if (sum_progress <= 0.0)
return 0;
return ceil (sum_height / sum_progress);
}
static gboolean
gtk_css_image_cross_fade_equal (GtkCssImage *image1,
GtkCssImage *image2)
{
GtkCssImageCrossFade *cross_fade1 = GTK_CSS_IMAGE_CROSS_FADE (image1);
GtkCssImageCrossFade *cross_fade2 = GTK_CSS_IMAGE_CROSS_FADE (image2);
guint i;
if (cross_fade1->images->len != cross_fade2->images->len)
return FALSE;
for (i = 0; i < cross_fade1->images->len; i++)
{
CrossFadeEntry *entry1 = &g_array_index (cross_fade1->images, CrossFadeEntry, i);
CrossFadeEntry *entry2 = &g_array_index (cross_fade2->images, CrossFadeEntry, i);
if (entry1->progress != entry2->progress ||
!_gtk_css_image_equal (entry1->image, entry2->image))
return FALSE;
}
return TRUE;
}
static gboolean
gtk_css_image_cross_fade_is_dynamic (GtkCssImage *image)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
guint i;
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
if (gtk_css_image_is_dynamic (entry->image))
return TRUE;
}
return FALSE;
}
static GtkCssImage *
gtk_css_image_cross_fade_get_dynamic_image (GtkCssImage *image,
gint64 monotonic_time)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
GtkCssImageCrossFade *result;
guint i;
result = gtk_css_image_cross_fade_new_empty ();
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
gtk_css_image_cross_fade_add (result,
entry->has_progress,
entry->progress,
gtk_css_image_get_dynamic_image (entry->image, monotonic_time));
}
return GTK_CSS_IMAGE (result);
}
static void
gtk_css_image_cross_fade_snapshot (GtkCssImage *image,
GtkSnapshot *snapshot,
double width,
double height)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
double remaining;
guint i, n_cross_fades;
if (self->total_progress < 1.0)
{
n_cross_fades = self->images->len;
remaining = 1.0;
}
else
{
n_cross_fades = self->images->len - 1;
remaining = self->total_progress;
}
for (i = 0; i < n_cross_fades; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
gtk_snapshot_push_cross_fade (snapshot, 1.0 - entry->progress / remaining);
remaining -= entry->progress;
gtk_css_image_snapshot (entry->image, snapshot, width, height);
gtk_snapshot_pop (snapshot);
}
if (n_cross_fades < self->images->len)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, self->images->len - 1);
gtk_css_image_snapshot (entry->image, snapshot, width, height);
}
for (i = 0; i < n_cross_fades; i++)
{
gtk_snapshot_pop (snapshot);
}
}
static gboolean
parse_progress (GtkCssParser *parser,
gpointer option_data,
gpointer user_data)
{
double *progress = option_data;
GtkCssValue *number;
number = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_PERCENT | GTK_CSS_POSITIVE_ONLY);
if (number == NULL)
return FALSE;
*progress = _gtk_css_number_value_get (number, 1);
_gtk_css_value_unref (number);
if (*progress > 1.0)
{
gtk_css_parser_error_value (parser, "Percentages over 100%% are not allowed. Given value: %f", *progress);
return FALSE;
}
return TRUE;
}
static gboolean
parse_image (GtkCssParser *parser,
gpointer option_data,
gpointer user_data)
{
GtkCssImage **image = option_data;
if (_gtk_css_image_can_parse (parser))
{
*image = _gtk_css_image_new_parse (parser);
if (*image == NULL)
return FALSE;
return TRUE;
}
else if (gtk_css_color_value_can_parse (parser))
{
GtkCssValue *color;
color = _gtk_css_color_value_parse (parser);
if (color == NULL)
return FALSE;
*image = _gtk_css_image_fallback_new_for_color (color);
return TRUE;
}
return FALSE;
}
static guint
gtk_css_image_cross_fade_parse_arg (GtkCssParser *parser,
guint arg,
gpointer data)
{
GtkCssImageCrossFade *self = data;
double progress = -1.0;
GtkCssImage *image = NULL;
GtkCssParseOption options[] =
{
{ (void *)gtk_css_number_value_can_parse, parse_progress, &progress },
{ NULL, parse_image, &image },
};
if (!gtk_css_parser_consume_any (parser, options, G_N_ELEMENTS (options), self))
return 0;
g_assert (image != NULL);
if (progress < 0.0)
gtk_css_image_cross_fade_add (self, FALSE, 0.0, image);
else
gtk_css_image_cross_fade_add (self, TRUE, progress, image);
return 1;
}
static gboolean
gtk_css_image_cross_fade_parse (GtkCssImage *image,
GtkCssParser *parser)
{
if (!gtk_css_parser_has_function (parser, "cross-fade"))
{
gtk_css_parser_error_syntax (parser, "Expected 'cross-fade('");
return FALSE;
}
return gtk_css_parser_consume_function (parser, 1, G_MAXUINT, gtk_css_image_cross_fade_parse_arg, image);
}
static void
gtk_css_image_cross_fade_print (GtkCssImage *image,
GString *string)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
guint i;
g_string_append (string, "cross-fade(");
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
if (i > 0)
g_string_append_printf (string, ", ");
if (entry->has_progress)
g_string_append_printf (string, "%g%% ", entry->progress * 100.0);
_gtk_css_image_print (entry->image, string);
}
g_string_append (string, ")");
}
static GtkCssImage *
gtk_css_image_cross_fade_compute (GtkCssImage *image,
guint property_id,
GtkStyleProvider *provider,
GtkCssStyle *style,
GtkCssStyle *parent_style)
{
GtkCssImageCrossFade *self = GTK_CSS_IMAGE_CROSS_FADE (image);
GtkCssImageCrossFade *result;
guint i;
result = gtk_css_image_cross_fade_new_empty ();
for (i = 0; i < self->images->len; i++)
{
CrossFadeEntry *entry = &g_array_index (self->images, CrossFadeEntry, i);
gtk_css_image_cross_fade_add (result,
entry->has_progress,
entry->progress,
_gtk_css_image_compute (entry->image, property_id, provider, style, parent_style));
}
return GTK_CSS_IMAGE (result);
}
static void
gtk_css_image_cross_fade_dispose (GObject *object)
{
GtkCssImageCrossFade *cross_fade = GTK_CSS_IMAGE_CROSS_FADE (object);
g_clear_pointer (&cross_fade->images, g_array_unref);
G_OBJECT_CLASS (gtk_css_image_cross_fade_parent_class)->dispose (object);
}
static gboolean
gtk_css_image_cross_fade_is_computed (GtkCssImage *image)
{
GtkCssImageCrossFade *cross_fade = GTK_CSS_IMAGE_CROSS_FADE (image);
guint i;
for (i = 0; i < cross_fade->images->len; i++)
{
const CrossFadeEntry *entry = &g_array_index (cross_fade->images, CrossFadeEntry, i);
if (!gtk_css_image_is_computed (entry->image))
return FALSE;
}
return TRUE;
}
static void
gtk_css_image_cross_fade_class_init (GtkCssImageCrossFadeClass *klass)
{
GtkCssImageClass *image_class = GTK_CSS_IMAGE_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
image_class->get_width = gtk_css_image_cross_fade_get_width;
image_class->get_height = gtk_css_image_cross_fade_get_height;
image_class->compute = gtk_css_image_cross_fade_compute;
image_class->equal = gtk_css_image_cross_fade_equal;
image_class->snapshot = gtk_css_image_cross_fade_snapshot;
image_class->is_dynamic = gtk_css_image_cross_fade_is_dynamic;
image_class->get_dynamic_image = gtk_css_image_cross_fade_get_dynamic_image;
image_class->parse = gtk_css_image_cross_fade_parse;
image_class->print = gtk_css_image_cross_fade_print;
image_class->is_computed = gtk_css_image_cross_fade_is_computed;
object_class->dispose = gtk_css_image_cross_fade_dispose;
}
static void
gtk_css_image_cross_fade_init (GtkCssImageCrossFade *self)
{
self->images = g_array_new (FALSE, FALSE, sizeof (CrossFadeEntry));
g_array_set_clear_func (self->images, cross_fade_entry_clear);
}
GtkCssImage *
_gtk_css_image_cross_fade_new (GtkCssImage *start,
GtkCssImage *end,
double progress)
{
GtkCssImageCrossFade *self;
g_return_val_if_fail (start == NULL || GTK_IS_CSS_IMAGE (start), NULL);
g_return_val_if_fail (end == NULL || GTK_IS_CSS_IMAGE (end), NULL);
self = gtk_css_image_cross_fade_new_empty ();
if (start)
gtk_css_image_cross_fade_add (self, TRUE, 1.0 - progress, g_object_ref (start));
if (end)
gtk_css_image_cross_fade_add (self, TRUE, progress, g_object_ref (end));
return GTK_CSS_IMAGE (self);
}