[gtk+/border-image: 1/6] border-image: change Gtk9Slice to GtkBorderImage
- From: Cosimo Cecchi <cosimoc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk+/border-image: 1/6] border-image: change Gtk9Slice to GtkBorderImage
- Date: Wed, 1 Jun 2011 17:39:34 +0000 (UTC)
commit f84dcfbe73191ea24a4e5f197e63cd73e2a703cb
Author: Cosimo Cecchi <cosimoc gnome org>
Date: Thu May 26 15:53:28 2011 -0400
border-image: change Gtk9Slice to GtkBorderImage
It's a similar private type, which is much more powerful, and respects
the CSS rendering specification for border-image.
https://bugzilla.gnome.org/show_bug.cgi?id=651194
gtk/Makefile.am | 4 +-
gtk/gtk9slice.c | 375 -----------------------
gtk/gtk9slice.h | 59 ----
gtk/gtkborderimage.c | 685 +++++++++++++++++++++++++++++++++++++++++++
gtk/gtkborderimageprivate.h | 80 +++++
gtk/gtkenums.h | 7 +
gtk/gtkthemingengine.c | 15 +-
7 files changed, 783 insertions(+), 442 deletions(-)
---
diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index a9e623e..5c2af46 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -375,7 +375,6 @@ endif
# GTK+ header files that don't get installed
gtk_private_h_sources = \
- gtk9slice.h \
gtkaccelgroupprivate.h \
gtkaccessibleprivate.h \
gtkanimationdescription.h \
@@ -383,6 +382,7 @@ gtk_private_h_sources = \
gtkappchoosermodule.h \
gtkappchooseronline.h \
gtkbindingsprivate.h \
+ gtkborderimageprivate.h \
gtkbuilderprivate.h \
gtkbuttonprivate.h \
gtkcellareaboxcontextprivate.h \
@@ -455,7 +455,6 @@ gtk_private_h_sources = \
# GTK+ C sources to build the library from
gtk_base_c_sources = \
- gtk9slice.c \
gtkquery.c \
gtksearchengine.c \
gtksearchenginesimple.c \
@@ -485,6 +484,7 @@ gtk_base_c_sources = \
gtkbin.c \
gtkbindings.c \
gtkborder.c \
+ gtkborderimage.c \
gtkbox.c \
gtkbuildable.c \
gtkbuilder.c \
diff --git a/gtk/gtkborderimage.c b/gtk/gtkborderimage.c
new file mode 100644
index 0000000..80ec800
--- /dev/null
+++ b/gtk/gtkborderimage.c
@@ -0,0 +1,685 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2010 Carlos Garnacho <carlosg gnome org>
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * Authors: Carlos Garnacho <carlosg gnome org>
+ * Cosimo Cecchi <cosimoc gnome org>
+ *
+ * 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 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, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <cairo-gobject.h>
+
+#include <math.h>
+
+#include "gtkborderimageprivate.h"
+
+static GtkBorderImageRepeat *
+_gtk_border_image_repeat_copy (const GtkBorderImageRepeat *repeat)
+{
+ GtkBorderImageRepeat *retval;
+
+ retval = g_slice_new0 (GtkBorderImageRepeat);
+ *retval = *repeat;
+
+ return retval;
+}
+
+static void
+_gtk_border_image_repeat_free (GtkBorderImageRepeat *repeat)
+{
+ g_slice_free (GtkBorderImageRepeat, repeat);
+}
+
+G_DEFINE_BOXED_TYPE (GtkBorderImageRepeat, _gtk_border_image_repeat,
+ _gtk_border_image_repeat_copy, _gtk_border_image_repeat_free)
+
+G_DEFINE_BOXED_TYPE (GtkBorderImage, _gtk_border_image,
+ _gtk_border_image_ref, _gtk_border_image_unref)
+
+enum {
+ BORDER_LEFT,
+ BORDER_MIDDLE,
+ BORDER_RIGHT,
+ BORDER_LAST,
+ BORDER_TOP = BORDER_LEFT,
+ BORDER_BOTTOM = BORDER_RIGHT
+};
+
+enum {
+ SIDE_TOP,
+ SIDE_RIGHT,
+ SIDE_BOTTOM,
+ SIDE_LEFT
+};
+
+struct _GtkBorderImage {
+ cairo_pattern_t *source;
+ GtkGradient *source_gradient;
+
+ GtkBorder slice;
+ GtkBorderImageRepeat repeat;
+
+ gint ref_count;
+ gboolean resolved;
+
+ cairo_surface_t *surfaces[BORDER_LAST][BORDER_LAST];
+};
+
+static void
+_gtk_border_image_ensure_slices (GtkBorderImage *image,
+ gdouble width,
+ gdouble height)
+{
+ cairo_surface_t *surface;
+ cairo_t *cr;
+
+ if (image->surfaces[0][0] != NULL)
+ return;
+
+ if (cairo_pattern_get_type (image->source) != CAIRO_PATTERN_TYPE_SURFACE)
+ {
+ cairo_matrix_t matrix;
+
+ cairo_matrix_init_scale (&matrix, 1 / width, 1 / height);
+ cairo_pattern_set_matrix (image->source, &matrix);
+
+ surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+ cr = cairo_create (surface);
+ cairo_set_source (cr, image->source);
+ cairo_paint (cr);
+
+ cairo_destroy (cr);
+ }
+ else
+ {
+ cairo_pattern_get_surface (image->source, &surface);
+ cairo_surface_reference (surface);
+
+ width = cairo_image_surface_get_width (surface);
+ height = cairo_image_surface_get_height (surface);
+ }
+
+ /* Top /left corner */
+ image->surfaces[BORDER_LEFT][BORDER_TOP] =
+ cairo_surface_create_similar (surface, CAIRO_CONTENT_COLOR_ALPHA,
+ image->slice.left, image->slice.top);
+ cr = cairo_create (image->surfaces[BORDER_LEFT][BORDER_TOP]);
+ cairo_set_source_surface (cr, surface, 0, 0);
+ cairo_paint (cr);
+
+ cairo_destroy (cr);
+
+ /* Top/right corner */
+ image->surfaces[BORDER_RIGHT][BORDER_TOP] =
+ cairo_surface_create_similar (surface, CAIRO_CONTENT_COLOR_ALPHA,
+ image->slice.right, image->slice.top);
+ cr = cairo_create (image->surfaces[BORDER_RIGHT][BORDER_TOP]);
+ cairo_set_source_surface (cr, surface,
+ - width + image->slice.right,
+ 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ /* Bottom/left corner */
+ image->surfaces[BORDER_LEFT][BORDER_BOTTOM] =
+ cairo_surface_create_similar (surface, CAIRO_CONTENT_COLOR_ALPHA,
+ image->slice.left, image->slice.bottom);
+ cr = cairo_create (image->surfaces[BORDER_LEFT][BORDER_BOTTOM]);
+ cairo_set_source_surface (cr, surface,
+ 0,
+ - height + image->slice.bottom);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ /* Bottom/right corner */
+ image->surfaces[BORDER_RIGHT][BORDER_BOTTOM] =
+ cairo_surface_create_similar (surface, CAIRO_CONTENT_COLOR_ALPHA,
+ image->slice.right, image->slice.bottom);
+ cr = cairo_create (image->surfaces[BORDER_RIGHT][BORDER_BOTTOM]);
+ cairo_set_source_surface (cr, surface,
+ - width + image->slice.right,
+ - height + image->slice.bottom);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ if ((image->slice.left + image->slice.right) < width)
+ {
+ /* Top side */
+ image->surfaces[BORDER_MIDDLE][BORDER_TOP] =
+ cairo_surface_create_similar (surface,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ width - image->slice.left - image->slice.right,
+ image->slice.top);
+ cr = cairo_create (image->surfaces[BORDER_MIDDLE][BORDER_TOP]);
+ cairo_set_source_surface (cr, surface,
+ - image->slice.left,
+ 0);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ /* Bottom side */
+ image->surfaces[BORDER_MIDDLE][BORDER_BOTTOM] =
+ cairo_surface_create_similar (surface,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ width - image->slice.left - image->slice.right,
+ image->slice.bottom);
+ cr = cairo_create (image->surfaces[BORDER_MIDDLE][BORDER_BOTTOM]);
+ cairo_set_source_surface (cr, surface,
+ - image->slice.left,
+ - height + image->slice.bottom);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+ }
+
+ if ((image->slice.top + image->slice.bottom) < height)
+ {
+ /* Left side */
+ image->surfaces[BORDER_LEFT][BORDER_MIDDLE] =
+ cairo_surface_create_similar (surface,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ image->slice.left,
+ height - image->slice.top - image->slice.bottom);
+ cr = cairo_create (image->surfaces[BORDER_LEFT][BORDER_MIDDLE]);
+ cairo_set_source_surface (cr, surface,
+ 0,
+ - image->slice.top);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+
+ /* Right side */
+ image->surfaces[BORDER_RIGHT][BORDER_MIDDLE] =
+ cairo_surface_create_similar (surface,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ image->slice.right,
+ height - image->slice.top - image->slice.bottom);
+ cr = cairo_create (image->surfaces[BORDER_RIGHT][BORDER_MIDDLE]);
+ cairo_set_source_surface (cr, surface,
+ - width + image->slice.right,
+ - image->slice.top);
+ cairo_paint (cr);
+ cairo_destroy (cr);
+ }
+
+ cairo_surface_destroy (surface);
+}
+
+GtkBorderImage *
+_gtk_border_image_new (cairo_pattern_t *pattern,
+ GtkBorder *slice,
+ GtkBorderImageRepeat *repeat)
+{
+ GtkBorderImage *image;
+
+ image = g_slice_new0 (GtkBorderImage);
+ image->ref_count = 1;
+
+ if (pattern != NULL)
+ image->source = cairo_pattern_reference (pattern);
+
+ if (slice != NULL)
+ image->slice = *slice;
+
+ if (repeat != NULL)
+ image->repeat = *repeat;
+
+ image->resolved = TRUE;
+
+ return image;
+}
+
+GtkBorderImage *
+_gtk_border_image_new_for_gradient (GtkGradient *gradient,
+ GtkBorder *slice,
+ GtkBorderImageRepeat *repeat)
+{
+ GtkBorderImage *image;
+
+ image = g_slice_new0 (GtkBorderImage);
+ image->ref_count = 1;
+
+ if (gradient != NULL)
+ image->source_gradient = gtk_gradient_ref (gradient);
+
+ if (slice != NULL)
+ image->slice = *slice;
+
+ if (repeat != NULL)
+ image->repeat = *repeat;
+
+ image->resolved = FALSE;
+
+ return image;
+}
+
+gboolean
+_gtk_border_image_get_resolved (GtkBorderImage *image)
+{
+ return image->resolved;
+}
+
+GtkBorderImage *
+_gtk_border_image_resolve (GtkBorderImage *image,
+ GtkStyleProperties *props)
+{
+ GtkBorderImage *resolved_image;
+ cairo_pattern_t *pattern;
+
+ if (image->resolved)
+ return _gtk_border_image_ref (image);
+
+ if (!gtk_gradient_resolve (image->source_gradient, props, &pattern))
+ return NULL;
+
+ resolved_image = _gtk_border_image_new (pattern, &image->slice, &image->repeat);
+
+ return resolved_image;
+}
+
+GtkBorderImage *
+_gtk_border_image_ref (GtkBorderImage *image)
+{
+ g_return_val_if_fail (image != NULL, NULL);
+
+ image->ref_count++;
+
+ return image;
+}
+
+void
+_gtk_border_image_unref (GtkBorderImage *image)
+{
+ g_return_if_fail (image != NULL);
+
+ image->ref_count--;
+
+ if (image->ref_count == 0)
+ {
+ if (image->source != NULL)
+ cairo_pattern_destroy (image->source);
+
+ if (image->source_gradient != NULL)
+ gtk_gradient_unref (image->source_gradient);
+
+ g_slice_free (GtkBorderImage, image);
+ }
+}
+
+GParameter *
+_gtk_border_image_unpack (const GValue *value,
+ guint *n_params)
+{
+ GParameter *parameter = g_new0 (GParameter, 3);
+ GtkBorderImage *image = g_value_get_boxed (value);
+
+ parameter[0].name = "border-image-source";
+ g_value_init (¶meter[0].value, CAIRO_GOBJECT_TYPE_PATTERN);
+ g_value_set_boxed (¶meter[0].value, image->source);
+
+ parameter[1].name = "border-image-slice";
+ g_value_init (¶meter[1].value, GTK_TYPE_BORDER);
+ g_value_set_boxed (¶meter[1].value, &image->slice);
+
+ parameter[2].name = "border-image-repeat";
+ g_value_init (¶meter[2].value, GTK_TYPE_BORDER_IMAGE_REPEAT);
+ g_value_set_boxed (¶meter[2].value, &image->repeat);
+
+ *n_params = 3;
+ return parameter;
+}
+
+void
+_gtk_border_image_pack (GValue *value,
+ GtkStyleProperties *props,
+ GtkStateFlags state)
+{
+ GtkBorderImage *image;
+ cairo_pattern_t *source;
+ GtkBorder *slice;
+ GtkBorderImageRepeat *repeat;
+
+ gtk_style_properties_get (props, state,
+ "border-image-source", &source,
+ "border-image-slice", &slice,
+ "border-image-repeat", &repeat,
+ NULL);
+
+ if (source == NULL)
+ {
+ g_value_take_boxed (value, NULL);
+ }
+ else
+ {
+ image = _gtk_border_image_new (source, slice, repeat);
+ g_value_take_boxed (value, image);
+
+ cairo_pattern_destroy (source);
+ }
+
+ if (slice != NULL)
+ gtk_border_free (slice);
+
+ if (repeat != NULL)
+ _gtk_border_image_repeat_free (repeat);
+}
+
+static void
+render_corner (cairo_t *cr,
+ cairo_surface_t *surface,
+ gdouble x,
+ gdouble y,
+ gdouble width,
+ gdouble height)
+{
+ gint image_width, image_height;
+
+ if (width == 0 || height == 0)
+ return;
+
+ cairo_save (cr);
+
+ image_width = cairo_image_surface_get_width (surface);
+ image_height = cairo_image_surface_get_height (surface);
+
+ cairo_translate (cr, x, y);
+ cairo_scale (cr,
+ width / image_width,
+ height / image_height);
+ cairo_set_source_surface (cr, surface, 0, 0);
+
+ /* use the nearest filter for scaling, to avoid color blending */
+ cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
+
+ cairo_paint (cr);
+
+ cairo_restore (cr);
+}
+
+static cairo_surface_t *
+create_spaced_surface (cairo_surface_t *tile,
+ gdouble width,
+ gdouble height,
+ GtkOrientation orientation)
+{
+ gint n_repeats, idx;
+ gint tile_width, tile_height;
+ gdouble avail_space, step;
+ cairo_surface_t *retval;
+ cairo_t *cr;
+
+ tile_width = cairo_image_surface_get_width (tile);
+ tile_height = cairo_image_surface_get_height (tile);
+
+ n_repeats = (orientation == GTK_ORIENTATION_HORIZONTAL) ?
+ (gint) floor (width / tile_width) :
+ (gint) floor (height / tile_height);
+
+ avail_space = (orientation == GTK_ORIENTATION_HORIZONTAL) ?
+ width - (n_repeats * tile_width) :
+ height - (n_repeats * tile_height);
+ step = avail_space / (n_repeats + 2);
+
+ retval = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
+ width, height);
+ cr = cairo_create (retval);
+ idx = 0;
+
+ while (idx < n_repeats)
+ {
+ cairo_save (cr);
+
+ if (orientation == GTK_ORIENTATION_HORIZONTAL)
+ cairo_set_source_surface (cr, tile,
+ ((idx + 1) * step) + (idx * tile_width), 0);
+ else
+ cairo_set_source_surface (cr, tile,
+ 0, ((idx + 1 ) * step) + (idx * tile_height));
+
+ cairo_paint (cr);
+ cairo_restore (cr);
+
+ idx++;
+ }
+
+ cairo_destroy (cr);
+
+ return retval;
+}
+
+static void
+render_border (cairo_t *cr,
+ cairo_surface_t *surface,
+ gdouble total_width,
+ gdouble total_height,
+ guint side,
+ GtkBorder *border_area,
+ GtkBorderImageRepeat *repeat)
+{
+ gdouble target_x, target_y;
+ gdouble target_width, target_height;
+ gint original_width, original_height;
+ GdkRectangle image_area;
+ cairo_pattern_t *pattern;
+ gboolean repeat_pattern;
+
+ if (surface == NULL)
+ return;
+
+ cairo_surface_reference (surface);
+ repeat_pattern = FALSE;
+
+ original_width = cairo_image_surface_get_width (surface);
+ original_height = cairo_image_surface_get_height (surface);
+
+ if (side == SIDE_TOP || side == SIDE_BOTTOM)
+ {
+ target_height = (side == SIDE_TOP) ? (border_area->top) : (border_area->bottom);
+ target_width = original_width * (target_height / original_height);
+ }
+ else
+ {
+ target_width = (side == SIDE_LEFT) ? (border_area->left) : (border_area->right);
+ target_height = original_height * (target_width / original_width);
+ }
+
+ if (side == SIDE_TOP || side == SIDE_BOTTOM)
+ {
+ image_area.x = border_area->left;
+ image_area.y = (side == SIDE_TOP) ? 0 : (total_height - border_area->bottom);
+ image_area.width = total_width - border_area->left - border_area->right;
+ image_area.height = (side == SIDE_TOP) ? border_area->top : border_area->bottom;
+
+ target_x = border_area->left;
+ target_y = (side == SIDE_TOP) ? 0 : (total_height - border_area->bottom);
+
+ if (repeat->vrepeat == GTK_REPEAT_STYLE_NONE)
+ {
+ target_width = image_area.width;
+ }
+ else if (repeat->vrepeat == GTK_REPEAT_STYLE_REPEAT)
+ {
+ repeat_pattern = TRUE;
+
+ target_x = border_area->left + (total_width - border_area->left - border_area->right) / 2;
+ target_y = ((side == SIDE_TOP) ? 0 : (total_height - border_area->bottom)) / 2;
+ }
+ else if (repeat->vrepeat == GTK_REPEAT_STYLE_ROUND)
+ {
+ gint n_repeats;
+
+ repeat_pattern = TRUE;
+
+ n_repeats = (gint) floor (image_area.width / original_width);
+ target_width = image_area.width / n_repeats;
+ }
+ else if (repeat->vrepeat == GTK_REPEAT_STYLE_SPACE)
+ {
+ cairo_surface_t *spaced_surface;
+
+ spaced_surface = create_spaced_surface (surface,
+ image_area.width, original_height,
+ GTK_ORIENTATION_HORIZONTAL);
+ cairo_surface_destroy (surface);
+ surface = spaced_surface;
+
+ /* short-circuit hscaling */
+ target_width = original_width = cairo_image_surface_get_width (surface);
+ }
+ }
+ else
+ {
+ image_area.x = (side == SIDE_LEFT) ? 0 : (total_width - border_area->right);
+ image_area.y = border_area->top;
+ image_area.width = (side == SIDE_LEFT) ? border_area->left : border_area->right;
+ image_area.height = total_height - border_area->top - border_area->bottom;
+
+ target_x = (side == SIDE_LEFT) ? 0 : (total_width - border_area->right);
+ target_y = border_area->top;
+
+ if (repeat->hrepeat == GTK_REPEAT_STYLE_NONE)
+ {
+ target_height = total_height - border_area->top - border_area->bottom;
+ }
+ else if (repeat->hrepeat == GTK_REPEAT_STYLE_REPEAT)
+ {
+ repeat_pattern = TRUE;
+
+ target_height = total_height - border_area->top - border_area->bottom;
+ target_x = (side == SIDE_LEFT) ? 0 : (total_width - border_area->right) / 2;
+ target_y = border_area->top + (total_height - border_area->top - border_area->bottom) / 2;
+ }
+ else if (repeat->hrepeat == GTK_REPEAT_STYLE_ROUND)
+ {
+ gint n_repeats;
+
+ repeat_pattern = TRUE;
+
+ n_repeats = (gint) floor (image_area.height / original_height);
+ target_height = image_area.height / n_repeats;
+ }
+ else if (repeat->hrepeat == GTK_REPEAT_STYLE_SPACE)
+ {
+ cairo_surface_t *spaced_surface;
+
+ spaced_surface = create_spaced_surface (surface,
+ original_width, image_area.height,
+ GTK_ORIENTATION_VERTICAL);
+ cairo_surface_destroy (surface);
+ surface = spaced_surface;
+
+ /* short-circuit vscaling */
+ target_height = original_height = cairo_image_surface_get_height (surface);
+ }
+ }
+
+ if (target_width == 0 || target_height == 0)
+ return;
+
+ cairo_save (cr);
+
+ pattern = cairo_pattern_create_for_surface (surface);
+
+ gdk_cairo_rectangle (cr, &image_area);
+ cairo_clip (cr);
+
+ cairo_translate (cr,
+ target_x, target_y);
+
+ /* use the nearest filter for scaling, to avoid color blending */
+ cairo_pattern_set_filter (pattern, CAIRO_FILTER_NEAREST);
+
+ if (repeat_pattern)
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+
+ cairo_scale (cr,
+ target_width / original_width,
+ target_height / original_height);
+
+ cairo_set_source (cr, pattern);
+ cairo_paint (cr);
+
+ cairo_restore (cr);
+
+ cairo_pattern_destroy (pattern);
+}
+
+void
+_gtk_border_image_render (GtkBorderImage *image,
+ GtkBorder *border_width,
+ cairo_t *cr,
+ gdouble x,
+ gdouble y,
+ gdouble width,
+ gdouble height)
+{
+ cairo_surface_t *surface;
+
+ _gtk_border_image_ensure_slices (image, width, height);
+
+ cairo_save (cr);
+ cairo_translate (cr, x, y);
+
+ /* Top side */
+ surface = image->surfaces[BORDER_MIDDLE][BORDER_TOP];
+ render_border (cr, surface,
+ width, height, SIDE_TOP,
+ border_width, &image->repeat);
+
+ /* Bottom side */
+ surface = image->surfaces[BORDER_MIDDLE][BORDER_BOTTOM];
+ render_border (cr, surface,
+ width, height, SIDE_BOTTOM,
+ border_width, &image->repeat);
+
+ /* Left side */
+ surface = image->surfaces[BORDER_LEFT][BORDER_MIDDLE];
+ render_border (cr, surface,
+ width, height, SIDE_LEFT,
+ border_width, &image->repeat);
+
+ /* Right side */
+ surface = image->surfaces[BORDER_RIGHT][BORDER_MIDDLE];
+ render_border (cr, surface,
+ width, height, SIDE_RIGHT,
+ border_width, &image->repeat);
+
+ /* Top/Left corner */
+ surface = image->surfaces[BORDER_LEFT][BORDER_TOP];
+ render_corner (cr, surface,
+ 0, 0,
+ border_width->left, border_width->top);
+
+ /* Top/right corner */
+ surface = image->surfaces[BORDER_RIGHT][BORDER_TOP];
+ render_corner (cr, surface,
+ width - border_width->right, 0,
+ border_width->right, border_width->top);
+
+ /* Bottom/left corner */
+ surface = image->surfaces[BORDER_LEFT][BORDER_BOTTOM];
+ render_corner (cr, surface,
+ 0, height - border_width->bottom,
+ border_width->left, border_width->bottom);
+
+ /* Bottom/right corner */
+ surface = image->surfaces[BORDER_RIGHT][BORDER_BOTTOM];
+ render_corner (cr, surface,
+ width - border_width->right, height - border_width->bottom,
+ border_width->right, border_width->bottom);
+
+ cairo_restore (cr);
+}
diff --git a/gtk/gtkborderimageprivate.h b/gtk/gtkborderimageprivate.h
new file mode 100644
index 0000000..2eddd93
--- /dev/null
+++ b/gtk/gtkborderimageprivate.h
@@ -0,0 +1,80 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2010 Carlos Garnacho <carlosg gnome org>
+ * Copyright (C) 2011 Red Hat, Inc.
+ *
+ * Authors: Carlos Garnacho <carlosg gnome org>
+ * Cosimo Cecchi <cosimoc gnome org>
+ *
+ * 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 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, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_BORDER_IMAGE_H__
+#define __GTK_BORDER_IMAGE_H__
+
+#include <gtk/gtkborder.h>
+#include <gtk/gtkenums.h>
+#include <gtk/gtkgradient.h>
+#include <gtk/gtkstyleproperties.h>
+#include <gtk/gtkthemingengine.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_BORDER_IMAGE_REPEAT (_gtk_border_image_repeat_get_type ())
+
+GType _gtk_border_image_repeat_get_type (void) G_GNUC_CONST;
+
+typedef struct {
+ GtkRepeatStyle vrepeat;
+ GtkRepeatStyle hrepeat;
+} GtkBorderImageRepeat;
+
+typedef struct _GtkBorderImage GtkBorderImage;
+
+#define GTK_TYPE_BORDER_IMAGE (_gtk_border_image_get_type ())
+
+GType _gtk_border_image_get_type (void) G_GNUC_CONST;
+
+GtkBorderImage * _gtk_border_image_new (cairo_pattern_t *source,
+ GtkBorder *slice,
+ GtkBorderImageRepeat *repeat);
+GtkBorderImage * _gtk_border_image_new_for_gradient (GtkGradient *gradient,
+ GtkBorder *slice,
+ GtkBorderImageRepeat *repeat);
+
+GtkBorderImage * _gtk_border_image_resolve (GtkBorderImage *image,
+ GtkStyleProperties *props);
+gboolean _gtk_border_image_get_resolved (GtkBorderImage *image);
+
+GtkBorderImage * _gtk_border_image_ref (GtkBorderImage *image);
+void _gtk_border_image_unref (GtkBorderImage *image);
+
+void _gtk_border_image_render (GtkBorderImage *image,
+ GtkBorder *border_width,
+ cairo_t *cr,
+ gdouble x,
+ gdouble y,
+ gdouble width,
+ gdouble height);
+
+GParameter * _gtk_border_image_unpack (const GValue *value,
+ guint *n_params);
+void _gtk_border_image_pack (GValue *value,
+ GtkStyleProperties *props,
+ GtkStateFlags state);
+
+G_END_DECLS
+
+#endif /* __GTK_BORDER_IMAGE_H__ */
diff --git a/gtk/gtkenums.h b/gtk/gtkenums.h
index 33e3aea..2a4c700 100644
--- a/gtk/gtkenums.h
+++ b/gtk/gtkenums.h
@@ -916,6 +916,13 @@ typedef enum {
GTK_BORDER_STYLE_OUTSET
} GtkBorderStyle;
+typedef enum {
+ GTK_REPEAT_STYLE_NONE,
+ GTK_REPEAT_STYLE_REPEAT,
+ GTK_REPEAT_STYLE_ROUND,
+ GTK_REPEAT_STYLE_SPACE
+} GtkRepeatStyle;
+
G_END_DECLS
diff --git a/gtk/gtkthemingengine.c b/gtk/gtkthemingengine.c
index 47833a3..3776ab3 100644
--- a/gtk/gtkthemingengine.c
+++ b/gtk/gtkthemingengine.c
@@ -27,7 +27,7 @@
#include <gtk/gtkintl.h>
#include "gtkprivate.h"
-#include "gtk9slice.h"
+#include "gtkborderimageprivate.h"
#include "gtkpango.h"
#include "gtkshadowprivate.h"
@@ -2085,22 +2085,25 @@ gtk_theming_engine_render_frame (GtkThemingEngine *engine,
gdouble height)
{
GtkStateFlags flags;
- Gtk9Slice *slice;
GtkBorderStyle border_style;
GtkJunctionSides junction;
+ GtkBorderImage *border_image;
+ GtkBorder border;
flags = gtk_theming_engine_get_state (engine);
junction = gtk_theming_engine_get_junction_sides (engine);
+ gtk_theming_engine_get_border (engine, flags, &border);
gtk_theming_engine_get (engine, flags,
- "border-image", &slice,
+ "border-image", &border_image,
"border-style", &border_style,
NULL);
- if (slice)
+ if (border_image != NULL)
{
- _gtk_9slice_render (slice, cr, x, y, width, height);
- _gtk_9slice_unref (slice);
+ _gtk_border_image_render (border_image, &border,
+ cr, x, y, width, height);
+ _gtk_border_image_unref (border_image);
}
else if (border_style != GTK_BORDER_STYLE_NONE)
render_frame_internal (engine, cr,
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
