static int
gtk_css_image_cross_fade_get_height (GtkCssImage *image)
{
GtkCssImageCrossFade *cross_fade = GTK_CSS_IMAGE_CROSS_FADE (image);
int start_height, end_height;
if (cross_fade->start)
{
start_height = _gtk_css_image_get_height (cross_fade->start);
/* no intrinsic height, what now? */
if (start_height == 0)
return 0;
}
else
start_height = 0;
if (cross_fade->end)
{
end_height = _gtk_css_image_get_height (cross_fade->end);
/* no intrinsic height, what now? */
if (end_height == 0)
return 0;
}
else
end_height = 0;
return start_height + (end_height - start_height) * cross_fade->progress;
}
static int
gtk_css_image_url_get_height (GtkCssImage *image)
{
GtkCssImageUrl *url = GTK_CSS_IMAGE_URL (image);
return _gtk_css_image_get_height (gtk_css_image_url_load_image (url, NULL));
}
static int
gtk_css_image_fallback_get_height (GtkCssImage *image)
{
GtkCssImageFallback *fallback = GTK_CSS_IMAGE_FALLBACK (image);
if (fallback->used < 0)
return 0;
return _gtk_css_image_get_height (fallback->images[fallback->used]);
}
static double
gtk_css_image_real_get_aspect_ratio (GtkCssImage *image)
{
int width, height;
width = _gtk_css_image_get_width (image);
height = _gtk_css_image_get_height (image);
if (width && height)
return (double) width / height;
else
return 0;
}
static GtkCssImage *
gtk_css_image_fallback_compute (GtkCssImage *image,
guint property_id,
GtkStyleProviderPrivate *provider,
GtkCssStyle *style,
GtkCssStyle *parent_style)
{
GtkCssImageFallback *fallback = GTK_CSS_IMAGE_FALLBACK (image);
GtkCssImageFallback *copy;
int i;
if (fallback->used < 0)
{
copy = g_object_new (_gtk_css_image_fallback_get_type (), NULL);
copy->n_images = fallback->n_images;
copy->images = g_new (GtkCssImage *, fallback->n_images);
for (i = 0; i < fallback->n_images; i++)
{
copy->images[i] = _gtk_css_image_compute (fallback->images[i],
property_id,
provider,
style,
parent_style);
/* Assume that failing to load an image leaves a 0x0 surface image */
if (GTK_IS_CSS_IMAGE_SURFACE (copy->images[i]) &&
_gtk_css_image_get_width (copy->images[i]) == 0 &&
_gtk_css_image_get_height (copy->images[i]) == 0)
continue;
if (copy->used < 0)
copy->used = i;
}
if (fallback->color)
copy->color = _gtk_css_value_compute (fallback->color,
property_id,
provider,
style,
parent_style);
else
copy->color = NULL;
return GTK_CSS_IMAGE (copy);
}
/* Applies the algorithm outlined in
* http://dev.w3.org/csswg/css3-images/#default-sizing
*/
void
_gtk_css_image_get_concrete_size (GtkCssImage *image,
double specified_width,
double specified_height,
double default_width,
double default_height,
double *concrete_width,
double *concrete_height)
{
double image_width, image_height, image_aspect;
g_return_if_fail (GTK_IS_CSS_IMAGE (image));
g_return_if_fail (specified_width >= 0);
g_return_if_fail (specified_height >= 0);
g_return_if_fail (default_width > 0);
g_return_if_fail (default_height > 0);
g_return_if_fail (concrete_width != NULL);
g_return_if_fail (concrete_height != NULL);
/* If the specified size is a definite width and height,
* the concrete object size is given that width and height.
*/
if (specified_width && specified_height)
{
*concrete_width = specified_width;
*concrete_height = specified_height;
return;
}
image_width = _gtk_css_image_get_width (image);
image_height = _gtk_css_image_get_height (image);
image_aspect = _gtk_css_image_get_aspect_ratio (image);
/* If the specified size has neither a definite width nor height,
* and has no additional contraints, the dimensions of the concrete
* object size are calculated as follows:
*/
if (specified_width == 0.0 && specified_height == 0.0)
{
/* If the object has only an intrinsic aspect ratio,
* the concrete object size must have that aspect ratio,
* and additionally be as large as possible without either
* its height or width exceeding the height or width of the
* default object size.
*/
if (image_aspect > 0 && image_width == 0 && image_height == 0)
{
if (image_aspect * default_height > default_width)
{
*concrete_width = default_height * image_aspect;
*concrete_height = default_height;
}
else
{
*concrete_width = default_width;
*concrete_height = default_width / image_aspect;
}
}
/* Otherwise, the width and height of the concrete object
* size is the same as the object's intrinsic width and
* intrinsic height, if they exist.
* If the concrete object size is still missing a width or
* height, and the object has an intrinsic aspect ratio,
* the missing dimension is calculated from the present
* dimension and the intrinsic aspect ratio.
* Otherwise, the missing dimension is taken from the default
* object size.
*/
if (image_width)
*concrete_width = image_width;
else if (image_aspect)
*concrete_width = image_height * image_aspect;
else
*concrete_width = default_width;
if (image_height)
*concrete_height = image_height;
else if (image_aspect)
*concrete_height = image_width / image_aspect;
else
*concrete_height = default_height;
return;
}
/* If the specified size has only a width or height, but not both,
* then the concrete object size is given that specified width or height.
* The other dimension is calculated as follows:
* If the object has an intrinsic aspect ratio, the missing dimension of
* the concrete object size is calculated using the intrinsic aspect-ratio
* and the present dimension.
* Otherwise, if the missing dimension is present in the object's intrinsic
* dimensions, the missing dimension is taken from the object's intrinsic
* dimensions.
* Otherwise, the missing dimension of the concrete object size is taken
* from the default object size.
*/
if (specified_width)
{
*concrete_width = specified_width;
if (image_aspect)
*concrete_height = specified_width / image_aspect;
else if (image_height)
*concrete_height = image_height;
else
*concrete_height = default_height;
}
else
{
*concrete_height = specified_height;
if (image_aspect)
*concrete_width = specified_height * image_aspect;
else if (image_width)
*concrete_width = image_width;
else
*concrete_width = default_width;
}
}
