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; } }