X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkthemingbackground.c;h=579d2be4dea32abe70be40ad73cd70fa39cd87b1;hb=ee44ed75ca50cb078ba8d5cb62c6a5d9d568f0e6;hp=882e4969fe38944dc2d18890206e554bf36c1393;hpb=4ba9be5b976df6f51b7ae0f81af5b29246b7ac80;p=~andy%2Fgtk diff --git a/gtk/gtkthemingbackground.c b/gtk/gtkthemingbackground.c index 882e4969f..579d2be4d 100644 --- a/gtk/gtkthemingbackground.c +++ b/gtk/gtkthemingbackground.c @@ -23,8 +23,13 @@ #include "gtkthemingbackgroundprivate.h" +#include "gtkcssarrayvalueprivate.h" +#include "gtkcssbgsizevalueprivate.h" #include "gtkcssenumvalueprivate.h" #include "gtkcssimagevalueprivate.h" +#include "gtkcssshadowsvalueprivate.h" +#include "gtkcsspositionvalueprivate.h" +#include "gtkcssrepeatvalueprivate.h" #include "gtkcsstypesprivate.h" #include "gtkthemingengineprivate.h" @@ -37,260 +42,224 @@ */ #include "fallback-c89.c" -static void -_gtk_theming_background_apply_window_background (GtkThemingBackground *bg, - cairo_t *cr) +static const GtkRoundedBox * +gtk_theming_background_get_box (GtkThemingBackground *bg, + GtkCssArea area) { - if (gtk_style_context_has_class (bg->context, "background")) + switch (area) { - cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0); /* transparent */ - cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); - cairo_paint (cr); - } + case GTK_CSS_AREA_BORDER_BOX: + return &bg->border_box; + case GTK_CSS_AREA_PADDING_BOX: + return &bg->padding_box; + case GTK_CSS_AREA_CONTENT_BOX: + return &bg->content_box; + default: + g_return_val_if_reached (&bg->border_box); + } } static void -_gtk_theming_background_apply_origin (GtkThemingBackground *bg) +_gtk_theming_background_paint_color (GtkThemingBackground *bg, + cairo_t *cr, + GtkCssValue *background_image) { - GtkCssArea origin; - cairo_rectangle_t image_rect; - - origin = _gtk_css_area_value_get (_gtk_style_context_peek_property (bg->context, "background-clip")); - - /* The default size of the background image depends on the - background-origin value as this affects the top left - and the bottom right corners. */ - switch (origin) { - case GTK_CSS_AREA_BORDER_BOX: - image_rect.x = 0; - image_rect.y = 0; - image_rect.width = bg->paint_area.width; - image_rect.height = bg->paint_area.height; - break; - case GTK_CSS_AREA_CONTENT_BOX: - image_rect.x = bg->border.left + bg->padding.left; - image_rect.y = bg->border.top + bg->padding.top; - image_rect.width = bg->paint_area.width - bg->border.left - bg->border.right - bg->padding.left - bg->padding.right; - image_rect.height = bg->paint_area.height - bg->border.top - bg->border.bottom - bg->padding.top - bg->padding.bottom; - break; - case GTK_CSS_AREA_PADDING_BOX: - default: - image_rect.x = bg->border.left; - image_rect.y = bg->border.top; - image_rect.width = bg->paint_area.width - bg->border.left - bg->border.right; - image_rect.height = bg->paint_area.height - bg->border.top - bg->border.bottom; - break; - } + gint n_values = _gtk_css_array_value_get_n_values (background_image); + GtkCssArea clip = _gtk_css_area_value_get + (_gtk_css_array_value_get_nth + (_gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_CLIP), + n_values - 1)); - /* XXX: image_rect might have negative width/height here. - * Do we need to do something about it? */ - bg->image_rect = image_rect; -} + cairo_save (cr); + _gtk_rounded_box_path (gtk_theming_background_get_box (bg, clip), cr); + cairo_clip (cr); -static void -_gtk_theming_background_apply_clip (GtkThemingBackground *bg) -{ - GtkCssArea clip = _gtk_css_area_value_get (_gtk_style_context_peek_property (bg->context, "background-clip")); + gdk_cairo_set_source_rgba (cr, &bg->bg_color); + cairo_paint (cr); - if (clip == GTK_CSS_AREA_PADDING_BOX) - { - _gtk_rounded_box_shrink (&bg->clip_box, - bg->border.top, bg->border.right, - bg->border.bottom, bg->border.left); - } - else if (clip == GTK_CSS_AREA_CONTENT_BOX) - { - _gtk_rounded_box_shrink (&bg->clip_box, - bg->border.top + bg->padding.top, - bg->border.right + bg->padding.right, - bg->border.bottom + bg->padding.bottom, - bg->border.left + bg->padding.left); - } + cairo_restore (cr); } static void -_gtk_theming_background_get_cover_contain (GtkCssImage *image, - gboolean cover, - double width, - double height, - double *concrete_width, - double *concrete_height) +_gtk_theming_background_paint_layer (GtkThemingBackground *bg, + guint idx, + cairo_t *cr) { - double aspect, image_aspect; - - image_aspect = _gtk_css_image_get_aspect_ratio (image); - if (image_aspect == 0.0) - { - *concrete_width = width; - *concrete_height = height; - return; - } + GtkCssRepeatStyle hrepeat, vrepeat; + const GtkCssValue *pos, *repeat; + GtkCssImage *image; + const GtkRoundedBox *origin; + double image_width, image_height; + double width, height; + + pos = _gtk_css_array_value_get_nth (_gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_POSITION), idx); + repeat = _gtk_css_array_value_get_nth (_gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_REPEAT), idx); + hrepeat = _gtk_css_background_repeat_value_get_x (repeat); + vrepeat = _gtk_css_background_repeat_value_get_y (repeat); + image = _gtk_css_image_value_get_image ( + _gtk_css_array_value_get_nth ( + _gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_IMAGE), + idx)); + origin = gtk_theming_background_get_box ( + bg, + _gtk_css_area_value_get ( + _gtk_css_array_value_get_nth ( + _gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_ORIGIN), + idx))); + width = origin->box.width; + height = origin->box.height; + + if (image == NULL || width <= 0 || height <= 0) + return; + + _gtk_css_bg_size_value_compute_size (_gtk_css_array_value_get_nth (_gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_SIZE), idx), + image, + width, + height, + &image_width, + &image_height); + + if (image_width <= 0 || image_height <= 0) + return; + + /* optimization */ + if (image_width == width) + hrepeat = GTK_CSS_REPEAT_STYLE_NO_REPEAT; + if (image_height == height) + vrepeat = GTK_CSS_REPEAT_STYLE_NO_REPEAT; + + + cairo_save (cr); + + _gtk_rounded_box_path ( + gtk_theming_background_get_box ( + bg, + _gtk_css_area_value_get ( + _gtk_css_array_value_get_nth ( + _gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_CLIP), + idx))), + cr); + cairo_clip (cr); + - aspect = width / height; + cairo_translate (cr, origin->box.x, origin->box.y); - if ((aspect >= image_aspect && cover) || - (aspect < image_aspect && !cover)) + if (hrepeat == GTK_CSS_REPEAT_STYLE_NO_REPEAT && vrepeat == GTK_CSS_REPEAT_STYLE_NO_REPEAT) { - *concrete_width = width; - *concrete_height = width / image_aspect; + cairo_translate (cr, + _gtk_css_position_value_get_x (pos, width - image_width), + _gtk_css_position_value_get_y (pos, height - image_height)); + /* shortcut for normal case */ + _gtk_css_image_draw (image, cr, image_width, image_height); } else { - *concrete_height = height; - *concrete_width = height * image_aspect; - } -} + int surface_width, surface_height; + cairo_rectangle_t fill_rect; + cairo_surface_t *surface; + cairo_t *cr2; + + /* If ‘background-repeat’ is ‘round’ for one (or both) dimensions, + * there is a second step. The UA must scale the image in that + * dimension (or both dimensions) so that it fits a whole number of + * times in the background positioning area. In the case of the width + * (height is analogous): + * + * If X ≠ 0 is the width of the image after step one and W is the width + * of the background positioning area, then the rounded width + * X' = W / round(W / X) where round() is a function that returns the + * nearest natural number (integer greater than zero). + * + * If ‘background-repeat’ is ‘round’ for one dimension only and if + * ‘background-size’ is ‘auto’ for the other dimension, then there is + * a third step: that other dimension is scaled so that the original + * aspect ratio is restored. + */ + if (hrepeat == GTK_CSS_REPEAT_STYLE_ROUND) + { + double n = round (width / image_width); -static void -_gtk_theming_background_paint (GtkThemingBackground *bg, - cairo_t *cr) -{ - cairo_save (cr); + n = MAX (1, n); - _gtk_rounded_box_path (&bg->clip_box, cr); - cairo_clip (cr); + if (vrepeat != GTK_CSS_REPEAT_STYLE_ROUND + /* && vsize == auto (it is by default) */) + image_height *= width / (image_width * n); + image_width = width / n; + } + if (vrepeat == GTK_CSS_REPEAT_STYLE_ROUND) + { + double n = round (height / image_height); - gdk_cairo_set_source_rgba (cr, &bg->bg_color); - cairo_paint (cr); + n = MAX (1, n); - if (bg->image - && bg->image_rect.width > 0 - && bg->image_rect.height > 0) - { - GtkCssBackgroundRepeat hrepeat, vrepeat; - const GtkCssBackgroundSize *size; - const GtkCssBackgroundPosition *pos; - double image_width, image_height; - double width, height; - - size = _gtk_css_value_get_background_size (_gtk_style_context_peek_property (bg->context, "background-size")); - pos = _gtk_css_value_get_background_position (_gtk_style_context_peek_property (bg->context, "background-position")); - gtk_style_context_get (bg->context, bg->flags, - "background-repeat", &hrepeat, - NULL); - vrepeat = GTK_CSS_BACKGROUND_VERTICAL (hrepeat); - hrepeat = GTK_CSS_BACKGROUND_HORIZONTAL (hrepeat); - width = bg->image_rect.width; - height = bg->image_rect.height; - - if (size->contain || size->cover) - _gtk_theming_background_get_cover_contain (bg->image, - size->cover, - width, - height, - &image_width, - &image_height); + if (hrepeat != GTK_CSS_REPEAT_STYLE_ROUND + /* && hsize == auto (it is by default) */) + image_width *= height / (image_height * n); + image_height = height / n; + } + + /* if hrepeat or vrepeat is 'space', we create a somewhat larger surface + * to store the extra space. */ + if (hrepeat == GTK_CSS_REPEAT_STYLE_SPACE) + { + double n = floor (width / image_width); + surface_width = n ? round (width / n) : 0; + } + else + surface_width = round (image_width); + + if (vrepeat == GTK_CSS_REPEAT_STYLE_SPACE) + { + double n = floor (height / image_height); + surface_height = n ? round (height / n) : 0; + } else - _gtk_css_image_get_concrete_size (bg->image, - /* note: 0 does the right thing here for 'auto' */ - _gtk_css_number_get (&size->width, width), - _gtk_css_number_get (&size->height, height), - width, height, - &image_width, &image_height); - - /* optimization */ - if (image_width == width) - hrepeat = GTK_CSS_BACKGROUND_NO_REPEAT; - if (image_height == height) - vrepeat = GTK_CSS_BACKGROUND_NO_REPEAT; - - cairo_translate (cr, bg->image_rect.x, bg->image_rect.y); - - if (hrepeat == GTK_CSS_BACKGROUND_NO_REPEAT && vrepeat == GTK_CSS_BACKGROUND_NO_REPEAT) + surface_height = round (image_height); + + surface = cairo_surface_create_similar (cairo_get_target (cr), + CAIRO_CONTENT_COLOR_ALPHA, + surface_width, surface_height); + cr2 = cairo_create (surface); + cairo_translate (cr2, + 0.5 * (surface_width - image_width), + 0.5 * (surface_height - image_height)); + _gtk_css_image_draw (image, cr2, image_width, image_height); + cairo_destroy (cr2); + + cairo_set_source_surface (cr, surface, + _gtk_css_position_value_get_x (pos, width - image_width), + _gtk_css_position_value_get_y (pos, height - image_height)); + cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT); + cairo_surface_destroy (surface); + + if (hrepeat == GTK_CSS_REPEAT_STYLE_NO_REPEAT) { - cairo_translate (cr, - _gtk_css_number_get (&pos->x, bg->image_rect.width - image_width), - _gtk_css_number_get (&pos->y, bg->image_rect.height - image_height)); - /* shortcut for normal case */ - _gtk_css_image_draw (bg->image, cr, image_width, image_height); + fill_rect.x = _gtk_css_position_value_get_x (pos, width - image_width); + fill_rect.width = image_width; } else { - int surface_width, surface_height; - cairo_surface_t *surface; - cairo_t *cr2; - - /* If ‘background-repeat’ is ‘round’ for one (or both) dimensions, - * there is a second step. The UA must scale the image in that - * dimension (or both dimensions) so that it fits a whole number of - * times in the background positioning area. In the case of the width - * (height is analogous): - * - * If X ≠ 0 is the width of the image after step one and W is the width - * of the background positioning area, then the rounded width - * X' = W / round(W / X) where round() is a function that returns the - * nearest natural number (integer greater than zero). - * - * If ‘background-repeat’ is ‘round’ for one dimension only and if - * ‘background-size’ is ‘auto’ for the other dimension, then there is - * a third step: that other dimension is scaled so that the original - * aspect ratio is restored. - */ - if (hrepeat == GTK_CSS_BACKGROUND_ROUND) - { - double n = round (width / image_width); - - n = MAX (1, n); - - if (vrepeat != GTK_CSS_BACKGROUND_ROUND - /* && vsize == auto (it is by default) */) - image_height *= width / (image_width * n); - image_width = width / n; - } - if (vrepeat == GTK_CSS_BACKGROUND_ROUND) - { - double n = round (height / image_height); - - n = MAX (1, n); - - if (hrepeat != GTK_CSS_BACKGROUND_ROUND - /* && hsize == auto (it is by default) */) - image_width *= height / (image_height * n); - image_height = height / n; - } - - /* if hrepeat or vrepeat is 'space', we create a somewhat larger surface - * to store the extra space. */ - if (hrepeat == GTK_CSS_BACKGROUND_SPACE) - { - double n = floor (width / image_width); - surface_width = n ? round (width / n) : 0; - } - else - surface_width = round (image_width); - - if (vrepeat == GTK_CSS_BACKGROUND_SPACE) - { - double n = floor (height / image_height); - surface_height = n ? round (height / n) : 0; - } - else - surface_height = round (image_height); - - surface = cairo_surface_create_similar (cairo_get_target (cr), - CAIRO_CONTENT_COLOR_ALPHA, - surface_width, surface_height); - cr2 = cairo_create (surface); - cairo_translate (cr2, - 0.5 * (surface_width - image_width), - 0.5 * (surface_height - image_height)); - _gtk_css_image_draw (bg->image, cr2, image_width, image_height); - cairo_destroy (cr2); - - cairo_set_source_surface (cr, surface, - _gtk_css_number_get (&pos->x, bg->image_rect.width - image_width), - _gtk_css_number_get (&pos->y, bg->image_rect.height - image_height)); - cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT); - cairo_surface_destroy (surface); - - cairo_rectangle (cr, - 0, 0, - hrepeat == GTK_CSS_BACKGROUND_NO_REPEAT ? image_width : width, - vrepeat == GTK_CSS_BACKGROUND_NO_REPEAT ? image_height : height); - cairo_fill (cr); + fill_rect.x = 0; + fill_rect.width = width; + } + + if (vrepeat == GTK_CSS_REPEAT_STYLE_NO_REPEAT) + { + fill_rect.y = _gtk_css_position_value_get_y (pos, height - image_height); + fill_rect.height = image_height; } + else + { + fill_rect.y = 0; + fill_rect.height = height; + } + + cairo_rectangle (cr, fill_rect.x, fill_rect.y, + fill_rect.width, fill_rect.height); + cairo_fill (cr); } + cairo_restore (cr); } @@ -298,19 +267,20 @@ static void _gtk_theming_background_apply_shadow (GtkThemingBackground *bg, cairo_t *cr) { - _gtk_css_shadow_value_paint_box (_gtk_style_context_peek_property (bg->context, "box-shadow"), - cr, - &bg->padding_box); + _gtk_css_shadows_value_paint_box (_gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BOX_SHADOW), + cr, + &bg->padding_box); } static void _gtk_theming_background_init_context (GtkThemingBackground *bg) { - bg->flags = gtk_style_context_get_state (bg->context); + GtkStateFlags flags = gtk_style_context_get_state (bg->context); + GtkBorder border, padding; - gtk_style_context_get_border (bg->context, bg->flags, &bg->border); - gtk_style_context_get_padding (bg->context, bg->flags, &bg->padding); - gtk_style_context_get_background_color (bg->context, bg->flags, &bg->bg_color); + gtk_style_context_get_border (bg->context, flags, &border); + gtk_style_context_get_padding (bg->context, flags, &padding); + gtk_style_context_get_background_color (bg->context, flags, &bg->bg_color); /* In the CSS box model, by default the background positioning area is * the padding-box, i.e. all the border-box minus the borders themselves, @@ -320,19 +290,18 @@ _gtk_theming_background_init_context (GtkThemingBackground *bg) * In the future we might want to support different origins or clips, but * right now we just shrink to the default. */ - _gtk_rounded_box_init_rect (&bg->padding_box, 0, 0, bg->paint_area.width, bg->paint_area.height); - - _gtk_rounded_box_apply_border_radius_for_context (&bg->padding_box, bg->context, bg->flags, bg->junction); + _gtk_rounded_box_init_rect (&bg->border_box, 0, 0, bg->paint_area.width, bg->paint_area.height); + _gtk_rounded_box_apply_border_radius_for_context (&bg->border_box, bg->context, bg->junction); - bg->clip_box = bg->padding_box; + bg->padding_box = bg->border_box; _gtk_rounded_box_shrink (&bg->padding_box, - bg->border.top, bg->border.right, - bg->border.bottom, bg->border.left); + border.top, border.right, + border.bottom, border.left); - _gtk_theming_background_apply_clip (bg); - _gtk_theming_background_apply_origin (bg); - - bg->image = _gtk_css_image_value_get_image (_gtk_style_context_peek_property (bg->context, "background-image")); + bg->content_box = bg->padding_box; + _gtk_rounded_box_shrink (&bg->content_box, + padding.top, padding.right, + padding.bottom, padding.left); } void @@ -372,7 +341,6 @@ _gtk_theming_background_init_from_context (GtkThemingBackground *bg, bg->paint_area.width = width; bg->paint_area.height = height; - bg->image = NULL; bg->junction = junction; _gtk_theming_background_init_context (bg); @@ -382,11 +350,21 @@ void _gtk_theming_background_render (GtkThemingBackground *bg, cairo_t *cr) { + gint idx; + GtkCssValue *background_image; + + background_image = _gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_IMAGE); + cairo_save (cr); cairo_translate (cr, bg->paint_area.x, bg->paint_area.y); - _gtk_theming_background_apply_window_background (bg, cr); - _gtk_theming_background_paint (bg, cr); + _gtk_theming_background_paint_color (bg, cr, background_image); + + for (idx = _gtk_css_array_value_get_n_values (background_image) - 1; idx >= 0; idx--) + { + _gtk_theming_background_paint_layer (bg, idx, cr); + } + _gtk_theming_background_apply_shadow (bg, cr); cairo_restore (cr); @@ -395,5 +373,12 @@ _gtk_theming_background_render (GtkThemingBackground *bg, gboolean _gtk_theming_background_has_background_image (GtkThemingBackground *bg) { - return (bg->image != NULL) ? TRUE : FALSE; + GtkCssImage *image; + GtkCssValue *value = _gtk_style_context_peek_property (bg->context, GTK_CSS_PROPERTY_BACKGROUND_IMAGE); + + if (_gtk_css_array_value_get_n_values (value) == 0) + return FALSE; + + image = _gtk_css_image_value_get_image (_gtk_css_array_value_get_nth (value, 0)); + return (image != NULL); }