gnome-shell/src/st/st-theme-node-drawing.c

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
 * st-theme-node-drawing.c: Code to draw themed elements
 *
 * Copyright 2009, 2010 Red Hat, Inc.
 * Copyright 2009, 2010 Florian Müllner
 * Copyright 2010 Intel Corporation.
 *
 * Contains code derived from:
 *   rectangle.c: Rounded rectangle.
 *     Copyright 2008 litl, LLC.
 *   st-texture-frame.h: Expandible texture actor
 *     Copyright 2007 OpenedHand
 *     Copyright 2009 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU Lesser General Public License,
 * version 2.1, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope 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 program. If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <math.h>

#include "st-shadow.h"
#include "st-private.h"
#include "st-theme-private.h"
#include "st-theme-context.h"
#include "st-texture-cache.h"
#include "st-theme-node-private.h"

/****
 * Rounded corners
 ****/

typedef struct {
  ClutterColor   color;
  ClutterColor   border_color_1;
  ClutterColor   border_color_2;
  guint          radius;
  guint          border_width_1;
  guint          border_width_2;
} StCornerSpec;

static void
elliptical_arc (cairo_t *cr,
                double   x_center,
                double   y_center,
                double   x_radius,
                double   y_radius,
                double   angle1,
                double   angle2)
{
  cairo_save (cr);
  cairo_translate (cr, x_center, y_center);
  cairo_scale (cr, x_radius, y_radius);
  cairo_arc (cr, 0, 0, 1.0, angle1, angle2);
  cairo_restore (cr);
}

static CoglHandle
create_corner_material (StCornerSpec *corner)
{
  CoglHandle texture;
  cairo_t *cr;
  cairo_surface_t *surface;
  guint rowstride;
  guint8 *data;
  guint size;
  guint max_border_width;

  max_border_width = MAX(corner->border_width_2, corner->border_width_1);
  size = 2 * MAX(max_border_width, corner->radius);
  rowstride = size * 4;
  data = g_new0 (guint8, size * rowstride);

  surface = cairo_image_surface_create_for_data (data,
                                                 CAIRO_FORMAT_ARGB32,
                                                 size, size,
                                                 rowstride);
  cr = cairo_create (surface);
  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
  cairo_scale (cr, size, size);

  if (max_border_width <= corner->radius)
    {
      double x_radius, y_radius;

      if (max_border_width != 0)
        {
          cairo_set_source_rgba (cr,
                                 corner->border_color_1.red / 255.,
                                 corner->border_color_1.green / 255.,
                                 corner->border_color_1.blue / 255.,
                                 corner->border_color_1.alpha / 255.);

          cairo_arc (cr, 0.5, 0.5, 0.5, 0, 2 * M_PI);
          cairo_fill (cr);
        }

      cairo_set_source_rgba (cr,
                             corner->color.red / 255.,
                             corner->color.green / 255.,
                             corner->color.blue / 255.,
                             corner->color.alpha / 255.);

      x_radius = 0.5 * (1.0 - (double) corner->border_width_2 / corner->radius);
      y_radius = 0.5 * (1.0 - (double) corner->border_width_1 / corner->radius);

      /* TOPRIGHT */
      elliptical_arc (cr,
                      0.5, 0.5,
                      x_radius, y_radius,
                      3 * M_PI / 2, 2 * M_PI);

      /* BOTTOMRIGHT */
      elliptical_arc (cr,
                      0.5, 0.5,
                      x_radius, y_radius,
                      0, M_PI / 2);

      /* TOPLEFT */
      elliptical_arc (cr,
                      0.5, 0.5,
                      x_radius, y_radius,
                      M_PI, 3 * M_PI / 2);

      /* BOTTOMLEFT */
      elliptical_arc (cr,
                      0.5, 0.5,
                      x_radius, y_radius,
                      M_PI / 2, M_PI);

      cairo_fill (cr);
    }
  else
    {
      double radius;

      radius = (gdouble)corner->radius / max_border_width;

      cairo_set_source_rgba (cr,
                             corner->border_color_1.red / 255.,
                             corner->border_color_1.green / 255.,
                             corner->border_color_1.blue / 255.,
                             corner->border_color_1.alpha / 255.);

      cairo_arc (cr, radius, radius, radius, M_PI, 3 * M_PI / 2);
      cairo_line_to (cr, 1.0 - radius, 0.0);
      cairo_arc (cr, 1.0 - radius, radius, radius, 3 * M_PI / 2, 2 * M_PI);
      cairo_line_to (cr, 1.0, 1.0 - radius);
      cairo_arc (cr, 1.0 - radius, 1.0 - radius, radius, 0, M_PI / 2);
      cairo_line_to (cr, radius, 1.0);
      cairo_arc (cr, radius, 1.0 - radius, radius, M_PI / 2, M_PI);
      cairo_fill (cr);
    }
  cairo_destroy (cr);

  cairo_surface_destroy (surface);

  texture = cogl_texture_new_from_data (size, size,
                                        COGL_TEXTURE_NONE,
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
                                        COGL_PIXEL_FORMAT_BGRA_8888_PRE,
#else
                                        COGL_PIXEL_FORMAT_ARGB_8888_PRE,
#endif
                                        COGL_PIXEL_FORMAT_ANY,
                                        rowstride,
                                        data);
  g_free (data);
  g_assert (texture != COGL_INVALID_HANDLE);

  return texture;
}

static char *
corner_to_string (StCornerSpec *corner)
{
  return g_strdup_printf ("st-theme-node-corner:%02x%02x%02x%02x,%02x%02x%02x%02x,%02x%02x%02x%02x,%u,%u,%u",
                          corner->color.red, corner->color.blue, corner->color.green, corner->color.alpha,
                          corner->border_color_1.red, corner->border_color_1.green, corner->border_color_1.blue, corner->border_color_1.alpha,
                          corner->border_color_2.red, corner->border_color_2.green, corner->border_color_2.blue, corner->border_color_2.alpha,
                          corner->radius,
                          corner->border_width_1,
                          corner->border_width_2);
}

typedef struct {
  StThemeNode *node;
  StCornerSpec *corner;
} LoadCornerData;

static CoglHandle
load_corner (StTextureCache  *cache,
             const char      *key,
             void            *datap,
             GError         **error)
{
  LoadCornerData *data = datap;

  return create_corner_material (data->corner);
}

/* To match the CSS specification, we want the border to look like it was
 * drawn over the background. But actually drawing the border over the
 * background will produce slightly bad antialiasing at the edges, so
 * compute the effective border color instead.
 */
#define NORM(x) (t = (x) + 127, (t + (t >> 8)) >> 8)
#define MULT(c,a) NORM(c*a)

static void
premultiply (ClutterColor *color)
{
  guint t;
  color->red = MULT (color->red, color->alpha);
  color->green = MULT (color->green, color->alpha);
  color->blue = MULT (color->blue, color->alpha);
}

static void
unpremultiply (ClutterColor *color)
{
  if (color->alpha != 0)
    {
      color->red = (color->red * 255 + 127) / color->alpha;
      color->green = (color->green * 255 + 127) / color->alpha;
      color->blue = (color->blue * 255 + 127) / color->alpha;
    }
}

static void
over (const ClutterColor *source,
      const ClutterColor *destination,
      ClutterColor       *result)
{
  guint t;
  ClutterColor src = *source;
  ClutterColor dst = *destination;

  premultiply (&src);
  premultiply (&dst);

  result->alpha = src.alpha + NORM ((255 - src.alpha) * dst.alpha);
  result->red   = src.red +   NORM ((255 - src.alpha) * dst.red);
  result->green = src.green + NORM ((255 - src.alpha) * dst.green);
  result->blue  = src.blue +  NORM ((255 - src.alpha) * dst.blue);

  unpremultiply (result);
}

static void
st_theme_node_get_corner_border_widths (StThemeNode *node,
                                        StCorner     corner_id,
                                        guint       *border_width_1,
                                        guint       *border_width_2)
{
  switch (corner_id)
    {
      case ST_CORNER_TOPLEFT:
        if (border_width_1)
            *border_width_1 = node->border_width[ST_SIDE_TOP];
        if (border_width_2)
            *border_width_2 = node->border_width[ST_SIDE_LEFT];
        break;
      case ST_CORNER_TOPRIGHT:
        if (border_width_1)
            *border_width_1 = node->border_width[ST_SIDE_TOP];
        if (border_width_2)
            *border_width_2 = node->border_width[ST_SIDE_RIGHT];
        break;
      case ST_CORNER_BOTTOMRIGHT:
        if (border_width_1)
            *border_width_1 = node->border_width[ST_SIDE_BOTTOM];
        if (border_width_2)
            *border_width_2 = node->border_width[ST_SIDE_RIGHT];
        break;
      case ST_CORNER_BOTTOMLEFT:
        if (border_width_1)
            *border_width_1 = node->border_width[ST_SIDE_BOTTOM];
        if (border_width_2)
            *border_width_2 = node->border_width[ST_SIDE_LEFT];
        break;
    }
}

static CoglHandle
st_theme_node_lookup_corner (StThemeNode    *node,
                             StCorner        corner_id)
{
  CoglHandle texture, material;
  char *key;
  StTextureCache *cache;
  StCornerSpec corner;
  LoadCornerData data;

  if (node->border_radius[corner_id] == 0)
    return COGL_INVALID_HANDLE;

  cache = st_texture_cache_get_default ();

  corner.radius = node->border_radius[corner_id];
  corner.color = node->background_color;
  st_theme_node_get_corner_border_widths (node, corner_id,
                                          &corner.border_width_1,
                                          &corner.border_width_2);

  switch (corner_id)
    {
      case ST_CORNER_TOPLEFT:
        over (&node->border_color[ST_SIDE_TOP], &corner.color, &corner.border_color_1);
        over (&node->border_color[ST_SIDE_LEFT], &corner.color, &corner.border_color_2);
        break;
      case ST_CORNER_TOPRIGHT:
        over (&node->border_color[ST_SIDE_TOP], &corner.color, &corner.border_color_1);
        over (&node->border_color[ST_SIDE_RIGHT], &corner.color, &corner.border_color_2);
        break;
      case ST_CORNER_BOTTOMRIGHT:
        over (&node->border_color[ST_SIDE_BOTTOM], &corner.color, &corner.border_color_1);
        over (&node->border_color[ST_SIDE_RIGHT], &corner.color, &corner.border_color_2);
        break;
      case ST_CORNER_BOTTOMLEFT:
        over (&node->border_color[ST_SIDE_BOTTOM], &corner.color, &corner.border_color_1);
        over (&node->border_color[ST_SIDE_LEFT], &corner.color, &corner.border_color_2);
        break;
    }

  if (corner.color.alpha == 0 &&
      corner.border_color_1.alpha == 0 &&
      corner.border_color_2.alpha == 0)
    return COGL_INVALID_HANDLE;

  key = corner_to_string (&corner);

  data.node = node;
  data.corner = &corner;
  texture = st_texture_cache_load (cache, key, ST_TEXTURE_CACHE_POLICY_NONE, load_corner, &data, NULL);
  material = _st_create_texture_material (texture);
  cogl_handle_unref (texture);

  g_free (key);

  return material;
}

static void
get_background_position (StThemeNode             *self,
                         const ClutterActorBox   *allocation,
                         ClutterActorBox         *result)
{
  gfloat w, h;

  result->x1 = result->y1 = 0;
  result->x2 = allocation->x2 - allocation->x1;
  result->y2 = allocation->y2 - allocation->y1;

  w = cogl_texture_get_width (self->background_texture);
  h = cogl_texture_get_height (self->background_texture);

  /* scale the background into the allocated bounds, when not being absolutely positioned */
  if ((w > result->x2 || h > result->y2) && !self->background_position_set)
    {
      gint new_h, new_w, offset;
      gint box_w, box_h;

      box_w = (int) result->x2;
      box_h = (int) result->y2;

      /* scale to fit */
      new_h = (int)((h / w) * ((gfloat) box_w));
      new_w = (int)((w / h) * ((gfloat) box_h));

      if (new_h > box_h)
        {
          /* center for new width */
          offset = ((box_w) - new_w) * 0.5;
          result->x1 = offset;
          result->x2 = offset + new_w;

          result->y2 = box_h;
        }
      else
        {
          /* center for new height */
          offset = ((box_h) - new_h) * 0.5;
          result->y1 = offset;
          result->y2 = offset + new_h;

          result->x2 = box_w;
        }
    }
  else
    {
      /* honor the specified position if any */
      if (self->background_position_set)
        {
          result->x1 = self->background_position_x;
          result->y1 = self->background_position_y;
        }
      else
        {
          /* center the background on the widget */
          result->x1 = (int)(((allocation->x2 - allocation->x1) / 2) - (w / 2));
          result->y1 = (int)(((allocation->y2 - allocation->y1) / 2) - (h / 2));
        }
      result->x2 = result->x1 + w;
      result->y2 = result->y1 + h;
    }
}

/* Use of this function marks code which doesn't support
 * non-uniform colors.
 */
static void
get_arbitrary_border_color (StThemeNode   *node,
                            ClutterColor  *color)
{
  if (color)
    st_theme_node_get_border_color (node, ST_SIDE_TOP, color);
}

static gboolean
st_theme_node_has_visible_outline (StThemeNode *node)
{
  if (node->background_color.alpha > 0)
    return TRUE;

  if (node->background_gradient_end.alpha > 0)
    return TRUE;

  if (node->border_radius[ST_CORNER_TOPLEFT] > 0 ||
      node->border_radius[ST_CORNER_TOPRIGHT] > 0 ||
      node->border_radius[ST_CORNER_BOTTOMLEFT] > 0 ||
      node->border_radius[ST_CORNER_BOTTOMRIGHT] > 0)
    return TRUE;

  if (node->border_width[ST_SIDE_TOP] > 0 ||
      node->border_width[ST_SIDE_LEFT] > 0 ||
      node->border_width[ST_SIDE_RIGHT] > 0 ||
      node->border_width[ST_SIDE_BOTTOM] > 0)
    return TRUE;

  return FALSE;
}

static cairo_pattern_t *
create_cairo_pattern_of_background_gradient (StThemeNode *node)
{
  cairo_pattern_t *pattern;

  g_return_val_if_fail (node->background_gradient_type != ST_GRADIENT_NONE,
                        NULL);

  if (node->background_gradient_type == ST_GRADIENT_VERTICAL)
    pattern = cairo_pattern_create_linear (0, 0, 0, node->alloc_height);
  else if (node->background_gradient_type == ST_GRADIENT_HORIZONTAL)
    pattern = cairo_pattern_create_linear (0, 0, node->alloc_width, 0);
  else
    {
      gdouble cx, cy;

      cx = node->alloc_width / 2.;
      cy = node->alloc_height / 2.;
      pattern = cairo_pattern_create_radial (cx, cy, 0, cx, cy, MIN (cx, cy));
    }

  cairo_pattern_add_color_stop_rgba (pattern, 0,
                                     node->background_color.red / 255.,
                                     node->background_color.green / 255.,
                                     node->background_color.blue / 255.,
                                     node->background_color.alpha / 255.);
  cairo_pattern_add_color_stop_rgba (pattern, 1,
                                     node->background_gradient_end.red / 255.,
                                     node->background_gradient_end.green / 255.,
                                     node->background_gradient_end.blue / 255.,
                                     node->background_gradient_end.alpha / 255.);
  return pattern;
}

static cairo_pattern_t *
create_cairo_pattern_of_background_image (StThemeNode *node,
                                          gboolean    *needs_background_fill)
{
  cairo_surface_t *surface;
  cairo_pattern_t *pattern;
  cairo_content_t  content;
  cairo_matrix_t   matrix;
  const char *file;
  double height_ratio, width_ratio;
  int file_width;
  int file_height;

  StTextureCache *texture_cache;

  file = st_theme_node_get_background_image (node);

  texture_cache = st_texture_cache_get_default ();

  surface = st_texture_cache_load_file_to_cairo_surface (texture_cache, file);

  if (surface == NULL)
    return NULL;

  g_assert (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE);

  content = cairo_surface_get_content (surface);
  pattern = cairo_pattern_create_for_surface (surface);

  file_width = cairo_image_surface_get_width (surface);
  file_height = cairo_image_surface_get_height (surface);

  height_ratio = file_height / node->alloc_height;
  width_ratio = file_width / node->alloc_width;

  *needs_background_fill = TRUE;
  if ((file_width > node->alloc_width || file_height > node->alloc_height)
      && !node->background_position_set)
    {
      double scale_factor;
      double x_offset, y_offset;

      if (width_ratio > height_ratio)
        {
          double scaled_height;

          /* center vertically */

          scale_factor = width_ratio;
          scaled_height = file_height / scale_factor;

          x_offset = 0.;
          y_offset = - (node->alloc_height / 2. - scaled_height / 2.);
        }
      else
        {
          double scaled_width;

          /* center horizontally */

          scale_factor = height_ratio;
          scaled_width = file_width / scale_factor;

          y_offset = 0.;
          x_offset = - (node->alloc_width / 2. - scaled_width / 2.);
        }

      cairo_matrix_init_translate (&matrix, x_offset, y_offset);
      cairo_matrix_scale (&matrix, scale_factor, scale_factor);

      cairo_pattern_set_matrix (pattern, &matrix);

      /* If it's opaque, and when scaled, fills up the entire allocated
       * area, then don't bother doing a background fill first
       */
      if (content != CAIRO_CONTENT_COLOR_ALPHA && width_ratio == height_ratio)
        *needs_background_fill = FALSE;
    }
  else
    {
      double x_offset, y_offset;

      if (node->background_position_set)
        {
          x_offset = -node->background_position_x;
          y_offset = -node->background_position_y;
        }
      else
        {
          if (node->alloc_width > file_width)
            x_offset = - (node->alloc_width / 2.0 - file_width / 2.0);
          else
            x_offset = - (file_width / 2.0 - node->alloc_width / 2.0);

          if (node->alloc_height > file_height)
            y_offset = - (node->alloc_height / 2.0 - file_height / 2.0);
          else
            y_offset = - (file_height / 2.0 - node->alloc_height / 2.0);
        }

      /* If it's opaque, and when translated, fills up the entire allocated
       * area, then don't bother doing a background fill first
       */
      if (content != CAIRO_CONTENT_COLOR_ALPHA
          && -x_offset <= 0
          && -x_offset + file_width >= node->alloc_width
          && -y_offset <= 0
          && -y_offset + file_height >= node->alloc_height)
        *needs_background_fill = FALSE;

      cairo_matrix_init_translate (&matrix, x_offset, y_offset);
      cairo_pattern_set_matrix (pattern, &matrix);
    }

  return pattern;
}

/* fill_exterior = TRUE means that pattern is a surface pattern and
 * we should extend the pattern with a solid fill from its edges.
 * This is a bit of a hack; the alternative would be to make the
 * surface of the surface pattern 1 pixel bigger and use CAIRO_EXTEND_PAD.
 */
static void
paint_shadow_pattern_to_cairo_context (StShadow *shadow_spec,
                                       cairo_pattern_t *pattern,
                                       gboolean         fill_exterior,
                                       cairo_t         *cr,
                                       cairo_path_t    *interior_path,
                                       cairo_path_t    *outline_path)
{
  /* If there are borders, clip the shadow to the interior
   * of the borders; if there is a visible outline, clip the shadow to
   * that outline
   */
  cairo_path_t *path = (interior_path != NULL) ? interior_path : outline_path;
  double x1, x2, y1, y2;

  /* fill_exterior only makes sense if we're clipping the shadow - filling
   * to the edges of the surface would be silly */
  g_assert (!(fill_exterior && path == NULL));

  cairo_save (cr);
  if (path != NULL)
    {
      cairo_append_path (cr, path);

      /* There's no way to invert a path in cairo, so we need bounds for
       * the area we are drawing in order to create the "exterior" region.
       * Pixel align to hit fast paths.
       */
      if (fill_exterior)
        {
          cairo_path_extents (cr, &x1, &y1, &x2, &y2);
          x1 = floor (x1);
          y1 = floor (y1);
          x2 = ceil (x2);
          y2 = ceil (y2);
        }

      cairo_clip (cr);
    }

  cairo_set_source_rgba (cr,
                         shadow_spec->color.red / 255.0,
                         shadow_spec->color.green / 255.0,
                         shadow_spec->color.blue / 255.0,
                         shadow_spec->color.alpha / 255.0);
  if (fill_exterior)
    {
      cairo_surface_t *surface;
      int width, height;
      cairo_matrix_t matrix;

      cairo_save (cr);

      /* Start with a rectangle enclosing the bounds of the clipped
       * region */
      cairo_rectangle (cr, x1, y1, x2 - x1, y2 - y1);

      /* Then subtract out the bounds of the surface in the surface
       * pattern; we transform the context by the inverse of the
       * pattern matrix to get to surface coordinates */
      cairo_pattern_get_surface (pattern, &surface);
      width = cairo_image_surface_get_width  (surface);
      height = cairo_image_surface_get_height (surface);

      cairo_pattern_get_matrix (pattern, &matrix);
      cairo_matrix_invert (&matrix);
      cairo_transform (cr, &matrix);

      cairo_rectangle (cr, 0, height, width, - height);
      cairo_fill (cr);

      cairo_restore (cr);
    }

  cairo_mask (cr, pattern);
  cairo_restore (cr);
}

static void
paint_background_image_shadow_to_cairo_context (StThemeNode     *node,
                                                StShadow        *shadow_spec,
                                                cairo_pattern_t *pattern,
                                                cairo_t         *cr,
                                                cairo_path_t    *interior_path,
                                                cairo_path_t    *outline_path,
                                                int              x,
                                                int              y,
                                                int              width,
                                                int              height)
{
  cairo_pattern_t *shadow_pattern;

  g_assert (shadow_spec != NULL);
  g_assert (pattern != NULL);

  if (outline_path != NULL)
    {
      cairo_surface_t *clipped_surface;
      cairo_pattern_t *clipped_pattern;
      cairo_t *temp_cr;

      /* Prerender the pattern to a temporary surface,
       * so it's properly clipped before we create a shadow from it
       */
      clipped_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
      temp_cr = cairo_create (clipped_surface);

      cairo_set_operator (temp_cr, CAIRO_OPERATOR_CLEAR);
      cairo_paint (temp_cr);
      cairo_set_operator (temp_cr, CAIRO_OPERATOR_SOURCE);

      if (interior_path != NULL)
        {
          cairo_append_path (temp_cr, interior_path);
          cairo_clip (temp_cr);
        }

      cairo_append_path (temp_cr, outline_path);
      cairo_translate (temp_cr, x, y);
      cairo_set_source (temp_cr, pattern);
      cairo_clip (temp_cr);
      cairo_paint (temp_cr);
      cairo_destroy (temp_cr);

      clipped_pattern = cairo_pattern_create_for_surface (clipped_surface);
      cairo_surface_destroy (clipped_surface);

      shadow_pattern = _st_create_shadow_cairo_pattern (shadow_spec,
                                                        clipped_pattern);
      cairo_pattern_destroy (clipped_pattern);
    }
  else
    {
      shadow_pattern = _st_create_shadow_cairo_pattern (shadow_spec,
                                                        pattern);
    }

  paint_shadow_pattern_to_cairo_context (shadow_spec,
                                         shadow_pattern, FALSE,
                                         cr,
                                         interior_path,
                                         outline_path);
  cairo_pattern_destroy (shadow_pattern);
}

/* gets the extents of a cairo_path_t; slightly inefficient, but much simpler than
 * computing from the raw path data */
static void
path_extents (cairo_path_t *path,
              double       *x1,
              double       *y1,
              double       *x2,
              double       *y2)

{
  cairo_surface_t *dummy = cairo_image_surface_create (CAIRO_FORMAT_A8, 1, 1);
  cairo_t *cr = cairo_create (dummy);

  cairo_append_path (cr, path);
  cairo_path_extents (cr, x1, y1, x2, y2);

  cairo_destroy (cr);
  cairo_surface_destroy (dummy);
}

static void
paint_inset_box_shadow_to_cairo_context (StThemeNode     *node,
                                         StShadow        *shadow_spec,
                                         cairo_t         *cr,
                                         cairo_path_t    *shadow_outline)
{
  cairo_surface_t *shadow_surface;
  cairo_pattern_t *shadow_pattern;
  double extents_x1, extents_y1, extents_x2, extents_y2;
  double shrunk_extents_x1, shrunk_extents_y1, shrunk_extents_x2, shrunk_extents_y2;
  gboolean fill_exterior;

  g_assert (shadow_spec != NULL);
  g_assert (shadow_outline != NULL);

  /* Create the pattern used to create the inset shadow; as the shadow
   * should be drawn as if everything outside the outline was opaque,
   * we use a temporary surface to draw the background as a solid shape,
   * which is inverted when creating the shadow pattern.
   */

  /* First we need to find the size of the temporary surface
   */
  path_extents (shadow_outline,
                &extents_x1, &extents_y1, &extents_x2, &extents_y2);

  /* Shrink the extents by the spread, and offset */
  shrunk_extents_x1 = extents_x1 + shadow_spec->xoffset + shadow_spec->spread;
  shrunk_extents_y1 = extents_y1 + shadow_spec->yoffset + shadow_spec->spread;
  shrunk_extents_x2 = extents_x2 + shadow_spec->xoffset - shadow_spec->spread;
  shrunk_extents_y2 = extents_y2 + shadow_spec->yoffset - shadow_spec->spread;

  if (shrunk_extents_x1 >= shrunk_extents_x2 || shrunk_extents_y1 >= shrunk_extents_x2)
    {
      /* Shadow occupies entire area within border */
      shadow_pattern = cairo_pattern_create_rgb (0., 0., 0.);
      fill_exterior = FALSE;
    }
  else
    {
      /* Bounds of temporary surface */
      int surface_x = floor (shrunk_extents_x1);
      int surface_y = floor (shrunk_extents_y1);
      int surface_width = ceil (shrunk_extents_x2) - surface_x;
      int surface_height = ceil (shrunk_extents_y2) - surface_y;

      /* Center of the original path */
      double x_center = (extents_x1 + extents_x2) / 2;
      double y_center = (extents_y1 + extents_y2) / 2;

      cairo_pattern_t *pattern;
      cairo_t *temp_cr;
      cairo_matrix_t matrix;

      shadow_surface = cairo_image_surface_create (CAIRO_FORMAT_A8, surface_width, surface_height);
      temp_cr = cairo_create (shadow_surface);

      /* Match the coordinates in the temporary context to the parent context */
      cairo_translate (temp_cr, - surface_x, - surface_y);

      /* Shadow offset */
      cairo_translate (temp_cr, shadow_spec->xoffset, shadow_spec->yoffset);

      /* Scale the path around the center to match the shrunk bounds */
      cairo_translate (temp_cr, x_center, y_center);
      cairo_scale (temp_cr,
                   (shrunk_extents_x2 - shrunk_extents_x1) / (extents_x2 - extents_x1),
                   (shrunk_extents_y2 - shrunk_extents_y1) / (extents_y2 - extents_y1));
      cairo_translate (temp_cr, - x_center, - y_center);

      cairo_append_path (temp_cr, shadow_outline);
      cairo_fill (temp_cr);
      cairo_destroy (temp_cr);

      pattern = cairo_pattern_create_for_surface (shadow_surface);
      cairo_surface_destroy (shadow_surface);

      /* The pattern needs to be offset back to coordinates in the parent context */
      cairo_matrix_init_translate (&matrix, - surface_x, - surface_y);
      cairo_pattern_set_matrix (pattern, &matrix);

      shadow_pattern = _st_create_shadow_cairo_pattern (shadow_spec, pattern);
      fill_exterior = TRUE;

      cairo_pattern_destroy (pattern);
    }

  paint_shadow_pattern_to_cairo_context (shadow_spec,
                                         shadow_pattern, fill_exterior,
                                         cr,
                                         shadow_outline,
                                         NULL);

  cairo_pattern_destroy (shadow_pattern);
}

/* In order for borders to be smoothly blended with non-solid backgrounds,
 * we need to use cairo.  This function is a slow fallback path for those
 * cases (gradients, background images, etc).
 */
static CoglHandle
st_theme_node_prerender_background (StThemeNode *node)
{
  StBorderImage *border_image;
  CoglHandle texture;
  int radius[4], i;
  cairo_t *cr;
  cairo_surface_t *surface;
  StShadow *shadow_spec;
  StShadow *box_shadow_spec;
  cairo_pattern_t *pattern = NULL;
  cairo_path_t *outline_path = NULL;
  gboolean draw_solid_background = TRUE;
  gboolean background_is_translucent;
  gboolean interior_dirty;
  gboolean draw_background_image_shadow = FALSE;
  gboolean has_visible_outline;
  ClutterColor border_color;
  int border_width[4];
  guint rowstride;
  guchar *data;
  ClutterActorBox actor_box;
  ClutterActorBox paint_box;
  cairo_path_t *interior_path = NULL;

  border_image = st_theme_node_get_border_image (node);

  shadow_spec = st_theme_node_get_background_image_shadow (node);
  box_shadow_spec = st_theme_node_get_box_shadow (node);

  actor_box.x1 = 0;
  actor_box.x2 = node->alloc_width;
  actor_box.y1 = 0;
  actor_box.y2 = node->alloc_height;

  /* If there's a background image shadow, we
   * may need to create an image bigger than the nodes
   * allocation
   */
  st_theme_node_get_background_paint_box (node, &actor_box, &paint_box);

  /* translate the boxes so the paint box is at 0,0
  */
  actor_box.x1 += - paint_box.x1;
  actor_box.x2 += - paint_box.x1;
  actor_box.y1 += - paint_box.y1;
  actor_box.y2 += - paint_box.y1;

  paint_box.x2 += - paint_box.x1;
  paint_box.x1 += - paint_box.x1;
  paint_box.y2 += - paint_box.y1;
  paint_box.y1 += - paint_box.y1;

  rowstride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32,
                                             paint_box.x2 - paint_box.x1);
  data = g_new0 (guchar, (paint_box.y2 - paint_box.y1) * rowstride);

  /* We zero initialize the destination memory, so it's fully transparent
   * by default.
   */
  interior_dirty = FALSE;

  surface = cairo_image_surface_create_for_data (data,
                                                 CAIRO_FORMAT_ARGB32,
                                                 paint_box.x2 - paint_box.x1,
                                                 paint_box.y2 - paint_box.y1,
                                                 rowstride);
  cr = cairo_create (surface);

  /* TODO - support non-uniform border colors */
  get_arbitrary_border_color (node, &border_color);

  for (i = 0; i < 4; i++)
    {
      border_width[i] = st_theme_node_get_border_width (node, i);

      radius[i] = st_theme_node_get_border_radius (node, i);
    }

  /* Note we don't support translucent background images on top
   * of gradients. It's strictly either/or.
   */
  if (node->background_gradient_type != ST_GRADIENT_NONE)
    {
      pattern = create_cairo_pattern_of_background_gradient (node);
      draw_solid_background = FALSE;

      /* If the gradient has any translucent areas, we need to
       * erase the interior region before drawing, so that we show
       * what's actually under the gradient and not whatever is
       * left over from filling the border, etc.
       */
      if (node->background_color.alpha < 255 ||
          node->background_gradient_end.alpha < 255)
        background_is_translucent = TRUE;
      else
        background_is_translucent = FALSE;
    }
  else
    {
      const char *background_image;

      background_image = st_theme_node_get_background_image (node);

      if (background_image != NULL)
        {
          pattern = create_cairo_pattern_of_background_image (node,
                                                              &draw_solid_background);
          if (shadow_spec && pattern != NULL)
            draw_background_image_shadow = TRUE;
        }

      /* We never need to clear the interior region before drawing the
       * background image, because it either always fills the entire area
       * opaquely, or we draw the solid background behind it.
       */
      background_is_translucent = FALSE;
    }

  if (pattern == NULL)
    draw_solid_background = TRUE;

  /* drawing the solid background implicitly clears the interior
   * region, so if we're going to draw a solid background before drawing
   * the background pattern, then we don't need to bother also clearing the
   * background region.
   */
  if (draw_solid_background)
    background_is_translucent = FALSE;

  has_visible_outline = st_theme_node_has_visible_outline (node);

  /* Create a path for the background's outline first */
  if (radius[ST_CORNER_TOPLEFT] > 0)
    cairo_arc (cr,
               actor_box.x1 + radius[ST_CORNER_TOPLEFT],
               actor_box.y1 + radius[ST_CORNER_TOPLEFT],
               radius[ST_CORNER_TOPLEFT], M_PI, 3 * M_PI / 2);
  else
    cairo_move_to (cr, actor_box.x1, actor_box.y1);
  cairo_line_to (cr, actor_box.x2 - radius[ST_CORNER_TOPRIGHT], actor_box.x1);
  if (radius[ST_CORNER_TOPRIGHT] > 0)
    cairo_arc (cr,
               actor_box.x2 - radius[ST_CORNER_TOPRIGHT],
               actor_box.x1 + radius[ST_CORNER_TOPRIGHT],
               radius[ST_CORNER_TOPRIGHT], 3 * M_PI / 2, 2 * M_PI);
  cairo_line_to (cr, actor_box.x2, actor_box.y2 - radius[ST_CORNER_BOTTOMRIGHT]);
  if (radius[ST_CORNER_BOTTOMRIGHT] > 0)
    cairo_arc (cr,
               actor_box.x2 - radius[ST_CORNER_BOTTOMRIGHT],
               actor_box.y2 - radius[ST_CORNER_BOTTOMRIGHT],
               radius[ST_CORNER_BOTTOMRIGHT], 0, M_PI / 2);
  cairo_line_to (cr, actor_box.x1 + radius[ST_CORNER_BOTTOMLEFT], actor_box.y2);
  if (radius[ST_CORNER_BOTTOMLEFT] > 0)
    cairo_arc (cr,
               actor_box.x1 + radius[ST_CORNER_BOTTOMLEFT],
               actor_box.y2 - radius[ST_CORNER_BOTTOMLEFT],
               radius[ST_CORNER_BOTTOMLEFT], M_PI / 2, M_PI);
  cairo_close_path (cr);

  outline_path = cairo_copy_path (cr);

  /* If we have a solid border, we fill the outline shape with the border
   * color and create the inline shape for the background;
   * otherwise the outline shape is filled with the background
   * directly
   */
  if (border_image == NULL &&
      (border_width[ST_SIDE_TOP] > 0 ||
       border_width[ST_SIDE_RIGHT] > 0 ||
       border_width[ST_SIDE_BOTTOM] > 0 ||
       border_width[ST_SIDE_LEFT] > 0))
    {
      cairo_set_source_rgba (cr,
                             border_color.red / 255.,
                             border_color.green / 255.,
                             border_color.blue / 255.,
                             border_color.alpha / 255.);
      cairo_fill (cr);

      /* We were sloppy when filling in the border, and now the interior
       * is filled with the border color, too.
       */
      interior_dirty = TRUE;

      if (radius[ST_CORNER_TOPLEFT] > MAX(border_width[ST_SIDE_TOP],
                                          border_width[ST_SIDE_LEFT]))
        elliptical_arc (cr,
                        actor_box.x1 + radius[ST_CORNER_TOPLEFT],
                        actor_box.y1 + radius[ST_CORNER_TOPLEFT],
                        radius[ST_CORNER_TOPLEFT] - border_width[ST_SIDE_LEFT],
                        radius[ST_CORNER_TOPLEFT] - border_width[ST_SIDE_TOP],
                        M_PI, 3 * M_PI / 2);
      else
        cairo_move_to (cr,
                       actor_box.x1 + border_width[ST_SIDE_LEFT],
                       actor_box.y1 + border_width[ST_SIDE_TOP]);

      cairo_line_to (cr,
                     actor_box.x2 - MAX(radius[ST_CORNER_TOPRIGHT], border_width[ST_SIDE_RIGHT]),
                     actor_box.y1 + border_width[ST_SIDE_TOP]);

      if (radius[ST_CORNER_TOPRIGHT] > MAX(border_width[ST_SIDE_TOP],
                                           border_width[ST_SIDE_RIGHT]))
        elliptical_arc (cr,
                        actor_box.x2 - radius[ST_CORNER_TOPRIGHT],
                        actor_box.y1 + radius[ST_CORNER_TOPRIGHT],
                        radius[ST_CORNER_TOPRIGHT] - border_width[ST_SIDE_RIGHT],
                        radius[ST_CORNER_TOPRIGHT] - border_width[ST_SIDE_TOP],
                        3 * M_PI / 2, 2 * M_PI);
      else
        cairo_line_to (cr,
                       actor_box.x2 - border_width[ST_SIDE_RIGHT],
                       actor_box.y1 + border_width[ST_SIDE_TOP]);

      cairo_line_to (cr,
                     actor_box.x2 - border_width[ST_SIDE_RIGHT],
                     actor_box.y2 - MAX(radius[ST_CORNER_BOTTOMRIGHT], border_width[ST_SIDE_BOTTOM]));

      if (radius[ST_CORNER_BOTTOMRIGHT] > MAX(border_width[ST_SIDE_BOTTOM],
                                              border_width[ST_SIDE_RIGHT]))
        elliptical_arc (cr,
                        actor_box.x2 - radius[ST_CORNER_BOTTOMRIGHT],
                        actor_box.y2 - radius[ST_CORNER_BOTTOMRIGHT],
                        radius[ST_CORNER_BOTTOMRIGHT] - border_width[ST_SIDE_RIGHT],
                        radius[ST_CORNER_BOTTOMRIGHT] - border_width[ST_SIDE_BOTTOM],
                        0, M_PI / 2);
      else
        cairo_line_to (cr,
                       actor_box.x2 - border_width[ST_SIDE_RIGHT],
                       actor_box.y2 - border_width[ST_SIDE_BOTTOM]);

      cairo_line_to (cr,
                     MAX(radius[ST_CORNER_BOTTOMLEFT], border_width[ST_SIDE_LEFT]),
                     actor_box.y2 - border_width[ST_SIDE_BOTTOM]);

      if (radius[ST_CORNER_BOTTOMLEFT] > MAX(border_width[ST_SIDE_BOTTOM],
                                             border_width[ST_SIDE_LEFT]))
        elliptical_arc (cr,
                        actor_box.x1 + radius[ST_CORNER_BOTTOMLEFT],
                        actor_box.y2 - radius[ST_CORNER_BOTTOMLEFT],
                        radius[ST_CORNER_BOTTOMLEFT] - border_width[ST_SIDE_LEFT],
                        radius[ST_CORNER_BOTTOMLEFT] - border_width[ST_SIDE_BOTTOM],
                        M_PI / 2, M_PI);
      else
        cairo_line_to (cr,
                       actor_box.x1 + border_width[ST_SIDE_LEFT],
                       actor_box.y2 - border_width[ST_SIDE_BOTTOM]);

      cairo_close_path (cr);

      interior_path = cairo_copy_path (cr);

      /* clip drawing to the region inside of the borders
       */
      cairo_clip (cr);

      /* But fill the pattern as if it started at the edge of outline,
       * behind the borders.  This is similar to
       * background-clip: border-box; semantics.
       */
      cairo_append_path (cr, outline_path);
    }

  if (interior_dirty && background_is_translucent)
    {
      cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
      cairo_fill_preserve (cr);
      cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
    }

  if (draw_solid_background)
    {
      cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);

      cairo_set_source_rgba (cr,
                             node->background_color.red / 255.,
                             node->background_color.green / 255.,
                             node->background_color.blue / 255.,
                             node->background_color.alpha / 255.);
      cairo_fill_preserve (cr);
      cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
    }

  if (draw_background_image_shadow)
    {
      paint_background_image_shadow_to_cairo_context (node,
                                                      shadow_spec,
                                                      pattern,
                                                      cr,
                                                      interior_path,
                                                      has_visible_outline?  outline_path : NULL,
                                                      actor_box.x1,
                                                      actor_box.y1,
                                                      paint_box.x2 - paint_box.x1,
                                                      paint_box.y2 - paint_box.y1);
      cairo_append_path (cr, outline_path);
    }

  cairo_translate (cr, actor_box.x1, actor_box.y1);

  if (pattern != NULL)
    {
      cairo_set_source (cr, pattern);
      cairo_fill (cr);
      cairo_pattern_destroy (pattern);
    }

  if (box_shadow_spec && box_shadow_spec->inset)
    {
      paint_inset_box_shadow_to_cairo_context (node,
                                               box_shadow_spec,
                                               cr,
                                               interior_path ? interior_path
                                                             : outline_path);
    }

  if (outline_path != NULL)
    cairo_path_destroy (outline_path);

  if (interior_path != NULL)
    cairo_path_destroy (interior_path);

  texture = cogl_texture_new_from_data (paint_box.x2 - paint_box.x1,
                                        paint_box.y2 - paint_box.y1,
                                        COGL_TEXTURE_NONE,
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
                                        COGL_PIXEL_FORMAT_BGRA_8888_PRE,
#elif G_BYTE_ORDER == G_BIG_ENDIAN
                                        COGL_PIXEL_FORMAT_ARGB_8888_PRE,
#else
                                        COGL_PIXEL_FORMAT_ANY,
#error unknown endianness type
#endif
                                        COGL_PIXEL_FORMAT_ANY,
                                        rowstride,
                                        data);

  cairo_destroy (cr);
  cairo_surface_destroy (surface);
  g_free (data);

  return texture;
}

void
_st_theme_node_free_drawing_state (StThemeNode  *node)
{
  int corner_id;

  if (node->background_texture != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->background_texture);
  if (node->background_material != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->background_material);
  if (node->background_shadow_material != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->background_shadow_material);
  if (node->border_slices_texture != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->border_slices_texture);
  if (node->border_slices_material != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->border_slices_material);
  if (node->prerendered_texture != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->prerendered_texture);
  if (node->prerendered_material != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->prerendered_material);
  if (node->box_shadow_material != COGL_INVALID_HANDLE)
    cogl_handle_unref (node->box_shadow_material);

  for (corner_id = 0; corner_id < 4; corner_id++)
    if (node->corner_material[corner_id] != COGL_INVALID_HANDLE)
      cogl_handle_unref (node->corner_material[corner_id]);

  _st_theme_node_init_drawing_state (node);
}

void
_st_theme_node_init_drawing_state (StThemeNode *node)
{
  int corner_id;

  node->background_texture = COGL_INVALID_HANDLE;
  node->background_material = COGL_INVALID_HANDLE;
  node->background_shadow_material = COGL_INVALID_HANDLE;
  node->box_shadow_material = COGL_INVALID_HANDLE;
  node->border_slices_texture = COGL_INVALID_HANDLE;
  node->border_slices_material = COGL_INVALID_HANDLE;
  node->prerendered_texture = COGL_INVALID_HANDLE;
  node->prerendered_material = COGL_INVALID_HANDLE;

  for (corner_id = 0; corner_id < 4; corner_id++)
    node->corner_material[corner_id] = COGL_INVALID_HANDLE;
}

static void st_theme_node_paint_borders (StThemeNode           *node,
                                         const ClutterActorBox *box,
                                         guint8                 paint_opacity);

static void
st_theme_node_render_resources (StThemeNode   *node,
                                float          width,
                                float          height)
{
  StTextureCache *texture_cache;
  StBorderImage *border_image;
  gboolean has_border;
  gboolean has_border_radius;
  gboolean has_inset_box_shadow;
  StShadow *box_shadow_spec;
  StShadow *background_image_shadow_spec;
  const char *background_image;

  texture_cache = st_texture_cache_get_default ();

  /* FIXME - need to separate this into things that need to be recomputed on
   * geometry change versus things that can be cached regardless, such as
   * a background image.
   */
  _st_theme_node_free_drawing_state (node);

  node->alloc_width = width;
  node->alloc_height = height;

  _st_theme_node_ensure_background (node);
  _st_theme_node_ensure_geometry (node);

  box_shadow_spec = st_theme_node_get_box_shadow (node);
  has_inset_box_shadow = box_shadow_spec && box_shadow_spec->inset;

  if (node->border_width[ST_SIDE_TOP] > 0 ||
      node->border_width[ST_SIDE_LEFT] > 0 ||
      node->border_width[ST_SIDE_RIGHT] > 0 ||
      node->border_width[ST_SIDE_BOTTOM] > 0)
    has_border = TRUE;
  else
    has_border = FALSE;

  if (node->border_radius[ST_CORNER_TOPLEFT] > 0 ||
      node->border_radius[ST_CORNER_TOPRIGHT] > 0 ||
      node->border_radius[ST_CORNER_BOTTOMLEFT] > 0 ||
      node->border_radius[ST_CORNER_BOTTOMRIGHT] > 0)
    has_border_radius = TRUE;
  else
    has_border_radius = FALSE;

  /* Load referenced images from disk and draw anything we need with cairo now */
  background_image = st_theme_node_get_background_image (node);
  border_image = st_theme_node_get_border_image (node);

  if (border_image)
    {
      const char *filename;

      filename = st_border_image_get_filename (border_image);

      node->border_slices_texture = st_texture_cache_load_file_to_cogl_texture (texture_cache, filename);
    }

  if (node->border_slices_texture)
    node->border_slices_material = _st_create_texture_material (node->border_slices_texture);
  else
    node->border_slices_material = COGL_INVALID_HANDLE;

  /* Use cairo to prerender the node if there is a gradient, or
   * background image with borders and/or rounded corners,
   * since we can't do those things easily with cogl.
   *
   * FIXME: if we could figure out ahead of time that a
   * background image won't overlap with the node borders,
   * then we could use cogl for that case.
   */
  if ((node->background_gradient_type != ST_GRADIENT_NONE)
      || (has_inset_box_shadow && (has_border || node->background_color.alpha > 0))
      || (background_image && (has_border || has_border_radius)))
    node->prerendered_texture = st_theme_node_prerender_background (node);

  if (node->prerendered_texture)
    node->prerendered_material = _st_create_texture_material (node->prerendered_texture);
  else
    node->prerendered_material = COGL_INVALID_HANDLE;

  if (box_shadow_spec && !has_inset_box_shadow)
    {
      if (node->border_slices_texture != COGL_INVALID_HANDLE)
        node->box_shadow_material = _st_create_shadow_material (box_shadow_spec,
                                                                node->border_slices_texture);
      else if (node->prerendered_texture != COGL_INVALID_HANDLE)
        node->box_shadow_material = _st_create_shadow_material (box_shadow_spec,
                                                                node->prerendered_texture);
      else if (node->background_color.alpha > 0 || has_border)
        {
          CoglHandle buffer, offscreen;

          buffer = cogl_texture_new_with_size (width,
                                               height,
                                               COGL_TEXTURE_NO_SLICING,
                                               COGL_PIXEL_FORMAT_ANY);
          offscreen = cogl_offscreen_new_to_texture (buffer);

          if (offscreen != COGL_INVALID_HANDLE)
            {
              ClutterActorBox box = { 0, 0, width, height };

              cogl_push_framebuffer (offscreen);
              cogl_ortho (0, width, height, 0, 0, 1.0);
              st_theme_node_paint_borders (node, &box, 0xFF);
              cogl_pop_framebuffer ();
              cogl_handle_unref (offscreen);

              node->box_shadow_material = _st_create_shadow_material (box_shadow_spec,
                                                                      buffer);
            }
          cogl_handle_unref (buffer);
        }
    }

  background_image_shadow_spec = st_theme_node_get_background_image_shadow (node);
  if (background_image != NULL && !has_border && !has_border_radius)
    {
      CoglHandle texture;

      texture = st_texture_cache_load_file_to_cogl_texture (texture_cache, background_image);

      /* If no background position is specified, then we will automatically scale
       * the background to fit within the node allocation. But, if a background
       * position is specified, we won't scale the background, and it could
       * potentially leak out of bounds. To prevent that, we subtexture from the
       * in bounds area when necessary.
       */
      if (node->background_position_set &&
          (cogl_texture_get_width (texture) > width ||
           cogl_texture_get_height (texture) > height))
        {
          CoglHandle subtexture;

          subtexture = cogl_texture_new_from_sub_texture (texture,
                                                          0, 0,
                                                          width - node->background_position_x,
                                                          height - node->background_position_y);
          cogl_handle_unref (texture);

          node->background_texture = subtexture;
        }
      else
        {
          node->background_texture = texture;
        }

      node->background_material = _st_create_texture_material (node->background_texture);

      if (background_image_shadow_spec)
        {
          node->background_shadow_material = _st_create_shadow_material (background_image_shadow_spec,
                                                                         node->background_texture);
        }
    }

  node->corner_material[ST_CORNER_TOPLEFT] =
    st_theme_node_lookup_corner (node, ST_CORNER_TOPLEFT);
  node->corner_material[ST_CORNER_TOPRIGHT] =
    st_theme_node_lookup_corner (node, ST_CORNER_TOPRIGHT);
  node->corner_material[ST_CORNER_BOTTOMRIGHT] =
    st_theme_node_lookup_corner (node, ST_CORNER_BOTTOMRIGHT);
  node->corner_material[ST_CORNER_BOTTOMLEFT] =
    st_theme_node_lookup_corner (node, ST_CORNER_BOTTOMLEFT);
}

static void
paint_material_with_opacity (CoglHandle       material,
                             ClutterActorBox *box,
                             guint8           paint_opacity)
{
  cogl_material_set_color4ub (material,
                              paint_opacity, paint_opacity, paint_opacity, paint_opacity);

  cogl_set_source (material);
  cogl_rectangle (box->x1, box->y1, box->x2, box->y2);
}

static void
st_theme_node_paint_borders (StThemeNode           *node,
                             const ClutterActorBox *box,
                             guint8                 paint_opacity)

{
  float width, height;
  int border_width[4];
  int max_border_radius = 0;
  int max_width_radius[4];
  int corner_id, side_id;
  ClutterColor border_color;
  guint8 alpha;

  width = box->x2 - box->x1;
  height = box->y2 - box->y1;

  /* TODO - support non-uniform border colors */
  get_arbitrary_border_color (node, &border_color);

  for (side_id = 0; side_id < 4; side_id++)
    border_width[side_id] = st_theme_node_get_border_width(node, side_id);

  for (corner_id = 0; corner_id < 4; corner_id++)
    {
      guint border_width_1, border_width_2;

      st_theme_node_get_corner_border_widths (node, corner_id,
                                              &border_width_1, &border_width_2);

      if (node->border_radius[corner_id] > max_border_radius)
        max_border_radius = node->border_radius[corner_id];
      max_width_radius[corner_id] = MAX(MAX(border_width_1, border_width_2),
                                        node->border_radius[corner_id]);
    }

  /* borders */
  if (border_width[ST_SIDE_TOP] > 0 ||
      border_width[ST_SIDE_RIGHT] > 0 ||
      border_width[ST_SIDE_BOTTOM] > 0 ||
      border_width[ST_SIDE_LEFT] > 0)
    {
      ClutterColor effective_border;
      gboolean skip_corner_1, skip_corner_2;
      float x1, y1, x2, y2;

      over (&border_color, &node->background_color, &effective_border);
      alpha = paint_opacity * effective_border.alpha / 255;

      if (alpha > 0)
        {
          cogl_set_source_color4ub (effective_border.red,
                                    effective_border.green,
                                    effective_border.blue,
                                    alpha);

          /* NORTH */
          skip_corner_1 = node->border_radius[ST_CORNER_TOPLEFT] > 0;
          skip_corner_2 = node->border_radius[ST_CORNER_TOPRIGHT] > 0;

          x1 = skip_corner_1 ? max_width_radius[ST_CORNER_TOPLEFT] : 0;
          y1 = 0;
          x2 = skip_corner_2 ? width - max_width_radius[ST_CORNER_TOPRIGHT] : width;
          y2 = border_width[ST_SIDE_TOP];
          cogl_rectangle (x1, y1, x2, y2);

          /* EAST */
          skip_corner_1 = node->border_radius[ST_CORNER_TOPRIGHT] > 0;
          skip_corner_2 = node->border_radius[ST_CORNER_BOTTOMRIGHT] > 0;

          x1 = width - border_width[ST_SIDE_RIGHT];
          y1 = skip_corner_1 ? max_width_radius[ST_CORNER_TOPRIGHT]
                             : border_width[ST_SIDE_TOP];
          x2 = width;
          y2 = skip_corner_2 ? height - max_width_radius[ST_CORNER_BOTTOMRIGHT]
                             : height - border_width[ST_SIDE_BOTTOM];
          cogl_rectangle (x1, y1, x2, y2);

          /* SOUTH */
          skip_corner_1 = node->border_radius[ST_CORNER_BOTTOMLEFT] > 0;
          skip_corner_2 = node->border_radius[ST_CORNER_BOTTOMRIGHT] > 0;

          x1 = skip_corner_1 ? max_width_radius[ST_CORNER_BOTTOMLEFT] : 0;
          y1 = height - border_width[ST_SIDE_BOTTOM];
          x2 = skip_corner_2 ? width - max_width_radius[ST_CORNER_BOTTOMRIGHT]
                             : width;
          y2 = height;
          cogl_rectangle (x1, y1, x2, y2);

          /* WEST */
          skip_corner_1 = node->border_radius[ST_CORNER_TOPLEFT] > 0;
          skip_corner_2 = node->border_radius[ST_CORNER_BOTTOMLEFT] > 0;

          x1 = 0;
          y1 = skip_corner_1 ? max_width_radius[ST_CORNER_TOPLEFT]
                             : border_width[ST_SIDE_TOP];
          x2 = border_width[ST_SIDE_LEFT];
          y2 = skip_corner_2 ? height - max_width_radius[ST_CORNER_BOTTOMLEFT]
                             : height - border_width[ST_SIDE_BOTTOM];
          cogl_rectangle (x1, y1, x2, y2);
        }
    }

  /* corners */
  if (max_border_radius > 0 && paint_opacity > 0)
    {
      for (corner_id = 0; corner_id < 4; corner_id++)
        {
          if (node->corner_material[corner_id] == COGL_INVALID_HANDLE)
            continue;

          cogl_material_set_color4ub (node->corner_material[corner_id],
                                      paint_opacity, paint_opacity,
                                      paint_opacity, paint_opacity);
          cogl_set_source (node->corner_material[corner_id]);

          switch (corner_id)
            {
              case ST_CORNER_TOPLEFT:
                cogl_rectangle_with_texture_coords (0, 0,
                                                    max_width_radius[ST_CORNER_TOPLEFT], max_width_radius[ST_CORNER_TOPLEFT],
                                                    0, 0, 0.5, 0.5);
                break;
              case ST_CORNER_TOPRIGHT:
                cogl_rectangle_with_texture_coords (width - max_width_radius[ST_CORNER_TOPRIGHT], 0,
                                                    width, max_width_radius[ST_CORNER_TOPRIGHT],
                                                    0.5, 0, 1, 0.5);
                break;
              case ST_CORNER_BOTTOMRIGHT:
                cogl_rectangle_with_texture_coords (width - max_width_radius[ST_CORNER_BOTTOMRIGHT], height - max_width_radius[ST_CORNER_BOTTOMRIGHT],
                                                    width, height,
                                                    0.5, 0.5, 1, 1);
                break;
              case ST_CORNER_BOTTOMLEFT:
                cogl_rectangle_with_texture_coords (0, height - max_width_radius[ST_CORNER_BOTTOMLEFT],
                                                    max_width_radius[ST_CORNER_BOTTOMLEFT], height,
                                                    0, 0.5, 0.5, 1);
                break;
            }
        }
    }

  /* background color */
  alpha = paint_opacity * node->background_color.alpha / 255;
  if (alpha > 0)
    {
      cogl_set_source_color4ub (node->background_color.red,
                                node->background_color.green,
                                node->background_color.blue,
                                alpha);

      /* We add padding to each corner, so that all corners end up as if they
       * had a border-radius of max_border_radius, which allows us to treat
       * corners as uniform further on.
       */
      for (corner_id = 0; corner_id < 4; corner_id++)
        {
          float verts[8];
          int n_rects;

          /* corner texture does not need padding */
          if (max_border_radius == node->border_radius[corner_id])
            continue;

          n_rects = node->border_radius[corner_id] == 0 ? 1 : 2;

          switch (corner_id)
            {
              case ST_CORNER_TOPLEFT:
                verts[0] = border_width[ST_SIDE_LEFT];
                verts[1] = MAX(node->border_radius[corner_id],
                               border_width[ST_SIDE_TOP]);
                verts[2] = max_border_radius;
                verts[3] = max_border_radius;
                if (n_rects == 2)
                  {
                    verts[4] = MAX(node->border_radius[corner_id],
                                   border_width[ST_SIDE_LEFT]);
                    verts[5] = border_width[ST_SIDE_TOP];
                    verts[6] = max_border_radius;
                    verts[7] = MAX(node->border_radius[corner_id],
                                   border_width[ST_SIDE_TOP]);
                  }
                break;
              case ST_CORNER_TOPRIGHT:
                verts[0] = width - max_border_radius;
                verts[1] = MAX(node->border_radius[corner_id],
                               border_width[ST_SIDE_TOP]);
                verts[2] = width - border_width[ST_SIDE_RIGHT];
                verts[3] = max_border_radius;
                if (n_rects == 2)
                  {
                    verts[4] = width - max_border_radius;
                    verts[5] = border_width[ST_SIDE_TOP];
                    verts[6] = width - MAX(node->border_radius[corner_id],
                                           border_width[ST_SIDE_RIGHT]);
                    verts[7] = MAX(node->border_radius[corner_id],
                                   border_width[ST_SIDE_TOP]);
                  }
                break;
              case ST_CORNER_BOTTOMRIGHT:
                verts[0] = width - max_border_radius;
                verts[1] = height - max_border_radius;
                verts[2] = width - border_width[ST_SIDE_RIGHT];
                verts[3] = height - MAX(node->border_radius[corner_id],
                                        border_width[ST_SIDE_BOTTOM]);
                if (n_rects == 2)
                  {
                    verts[4] = width - max_border_radius;
                    verts[5] = height - MAX(node->border_radius[corner_id],
                                            border_width[ST_SIDE_BOTTOM]);
                    verts[6] = width - MAX(node->border_radius[corner_id],
                                           border_width[ST_SIDE_RIGHT]);
                    verts[7] = height - border_width[ST_SIDE_BOTTOM];
                  }
                break;
              case ST_CORNER_BOTTOMLEFT:
                verts[0] = border_width[ST_SIDE_LEFT];
                verts[1] = height - max_border_radius;
                verts[2] = max_border_radius;
                verts[3] = height - MAX(node->border_radius[corner_id],
                                        border_width[ST_SIDE_BOTTOM]);
                if (n_rects == 2)
                  {
                    verts[4] = MAX(node->border_radius[corner_id],
                                   border_width[ST_SIDE_LEFT]);
                    verts[5] = height - MAX(node->border_radius[corner_id],
                                            border_width[ST_SIDE_BOTTOM]);
                    verts[6] = max_border_radius;
                    verts[7] = height - border_width[ST_SIDE_BOTTOM];
                  }
                break;
            }
          cogl_rectangles (verts, n_rects);
        }

      /* Once we've drawn the borders and corners, if the corners are bigger
       * then the border width, the remaining area is shaped like
       *
       *  ########
       * ##########
       * ##########
       *  ########
       *
       * We draw it in at most 3 pieces - first the top and bottom if
       * necessary, then the main rectangle
       */
      if (max_border_radius > border_width[ST_SIDE_TOP])
        cogl_rectangle (MAX(max_border_radius, border_width[ST_SIDE_LEFT]),
                        border_width[ST_SIDE_TOP],
                        width - MAX(max_border_radius, border_width[ST_SIDE_RIGHT]),
                        max_border_radius);
      if (max_border_radius > border_width[ST_SIDE_BOTTOM])
        cogl_rectangle (MAX(max_border_radius, border_width[ST_SIDE_LEFT]),
                        height - max_border_radius,
                        width - MAX(max_border_radius, border_width[ST_SIDE_RIGHT]),
                        height - border_width[ST_SIDE_BOTTOM]);

      cogl_rectangle (border_width[ST_SIDE_LEFT],
                      MAX(border_width[ST_SIDE_TOP], max_border_radius),
                      width - border_width[ST_SIDE_RIGHT],
                      height - MAX(border_width[ST_SIDE_BOTTOM], max_border_radius));
    }
}

static void
st_theme_node_paint_sliced_border_image (StThemeNode           *node,
                                         const ClutterActorBox *box,
                                         guint8                 paint_opacity)
{
  gfloat ex, ey;
  gfloat tx1, ty1, tx2, ty2;
  gint border_left, border_right, border_top, border_bottom;
  float img_width, img_height;
  StBorderImage *border_image;
  CoglHandle material;

  border_image = st_theme_node_get_border_image (node);
  g_assert (border_image != NULL);

  st_border_image_get_borders (border_image,
                               &border_left, &border_right, &border_top, &border_bottom);

  img_width = cogl_texture_get_width (node->border_slices_texture);
  img_height = cogl_texture_get_height (node->border_slices_texture);

  tx1 = border_left / img_width;
  tx2 = (img_width - border_right) / img_width;
  ty1 = border_top / img_height;
  ty2 = (img_height - border_bottom) / img_height;

  ex = node->alloc_width - border_right;
  if (ex < 0)
    ex = border_right;           /* FIXME ? */

  ey = node->alloc_height - border_bottom;
  if (ey < 0)
    ey = border_bottom;          /* FIXME ? */

  material = node->border_slices_material;
  cogl_material_set_color4ub (material,
                              paint_opacity, paint_opacity, paint_opacity, paint_opacity);

  cogl_set_source (material);

  {
    GLfloat rectangles[] =
    {
      /* top left corner */
      0, 0, border_left, border_top,
      0.0, 0.0,
      tx1, ty1,

      /* top middle */
      border_left, 0, ex, border_top,
      tx1, 0.0,
      tx2, ty1,

      /* top right */
      ex, 0, node->alloc_width, border_top,
      tx2, 0.0,
      1.0, ty1,

      /* mid left */
      0, border_top, border_left, ey,
      0.0, ty1,
      tx1, ty2,

      /* center */
      border_left, border_top, ex, ey,
      tx1, ty1,
      tx2, ty2,

      /* mid right */
      ex, border_top, node->alloc_width, ey,
      tx2, ty1,
      1.0, ty2,

      /* bottom left */
      0, ey, border_left, node->alloc_height,
      0.0, ty2,
      tx1, 1.0,

      /* bottom center */
      border_left, ey, ex, node->alloc_height,
      tx1, ty2,
      tx2, 1.0,

      /* bottom right */
      ex, ey, node->alloc_width, node->alloc_height,
      tx2, ty2,
      1.0, 1.0
    };

    cogl_rectangles_with_texture_coords (rectangles, 9);
  }
}

static void
st_theme_node_paint_outline (StThemeNode           *node,
                             const ClutterActorBox *box,
                             guint8                 paint_opacity)

{
  float width, height;
  int outline_width;
  ClutterColor outline_color, effective_outline;

  width = box->x2 - box->x1;
  height = box->y2 - box->y1;

  outline_width = st_theme_node_get_outline_width (node);
  if (outline_width == 0)
    return;

  st_theme_node_get_outline_color (node, &outline_color);
  over (&outline_color, &node->background_color, &effective_outline);

  cogl_set_source_color4ub (effective_outline.red,
                            effective_outline.green,
                            effective_outline.blue,
                            paint_opacity * effective_outline.alpha / 255);

  /* The outline is drawn just outside the border, which means just
   * outside the allocation box. This means that in some situations
   * involving clip_to_allocation or the screen edges, you won't be
   * able to see the outline. In practice, it works well enough.
   */

  /* NORTH */
  cogl_rectangle (-outline_width, -outline_width,
                  width + outline_width, 0);

  /* EAST */
  cogl_rectangle (width, 0,
                  width + outline_width, height);

  /* SOUTH */
  cogl_rectangle (-outline_width, height,
                  width + outline_width, height + outline_width);

  /* WEST */
  cogl_rectangle (-outline_width, 0,
                  0, height);
}

void
st_theme_node_paint (StThemeNode           *node,
                     const ClutterActorBox *box,
                     guint8                 paint_opacity)
{
  float width, height;
  ClutterActorBox allocation;

  /* Some things take an ActorBox, some things just width/height */
  width = box->x2 - box->x1;
  height = box->y2 - box->y1;
  allocation.x1 = allocation.y1 = 0;
  allocation.x2 = width;
  allocation.y2 = height;

  if (node->alloc_width != width || node->alloc_height != height)
    st_theme_node_render_resources (node, width, height);

  /* Rough notes about the relationship of borders and backgrounds in CSS3;
   * see http://www.w3.org/TR/css3-background/ for more accurate details.
   *
   * - Things are drawn in 4 layers, from the bottom:
   *     Background color
   *     Background image
   *     Border color or border image
   *     Content
   * - The background color, gradient and image extend to and are clipped by
   *   the edge of the border area, so will be rounded if the border is
   *   rounded. (CSS3 background-clip property modifies this)
   * - The border image replaces what would normally be drawn by the border
   * - The border image is not clipped by a rounded border-radius
   * - The border radius rounds the background even if the border is
   *   zero width or a border image is being used.
   *
   * Deviations from the above as implemented here:
   *  - The combination of border image and a non-zero border radius is
   *    not supported; the background color will be drawn with square
   *    corners.
   *  - The background image is drawn above the border color, not below it.
   *  - We clip the background image to the inside edges of the border
   *    instead of the outside edges of the border (but position the image
   *    such that it's aligned to the outside edges)
   */

  if (node->box_shadow_material)
    _st_paint_shadow_with_opacity (node->box_shadow,
                                   node->box_shadow_material,
                                   &allocation,
                                   paint_opacity);

  if (node->prerendered_material != COGL_INVALID_HANDLE ||
      node->border_slices_material != COGL_INVALID_HANDLE)
    {
      if (node->prerendered_material != COGL_INVALID_HANDLE)
        {
          ClutterActorBox paint_box;

          st_theme_node_get_background_paint_box (node,
                                                  &allocation,
                                                  &paint_box);

          paint_material_with_opacity (node->prerendered_material,
                                       &paint_box,
                                       paint_opacity);
        }

      if (node->border_slices_material != COGL_INVALID_HANDLE)
        st_theme_node_paint_sliced_border_image (node, &allocation, paint_opacity);
    }
  else
    {
      st_theme_node_paint_borders (node, box, paint_opacity);
    }

  st_theme_node_paint_outline (node, box, paint_opacity);

  if (node->background_texture != COGL_INVALID_HANDLE)
    {
      ClutterActorBox background_box;
      gboolean has_visible_outline;

      /* If the background doesn't have a border or opaque background,
       * then we let its background image shadows leak out, but other
       * wise we clip it.
       */
      has_visible_outline = st_theme_node_has_visible_outline (node);

      get_background_position (node, &allocation, &background_box);

      if (has_visible_outline)
        cogl_clip_push_rectangle (allocation.x1, allocation.y1, allocation.x2, allocation.y2);

      /* CSS based drop shadows
       *
       * Drop shadows in ST are modelled after the CSS3 box-shadow property;
       * see http://www.css3.info/preview/box-shadow/ for a detailed description.
       *
       * While the syntax of the property is mostly identical - we do not support
       * multiple shadows and allow for a more liberal placement of the color
       * parameter - its interpretation defers significantly in that the shadow's
       * shape is not determined by the bounding box, but by the CSS background
       * image. The drop shadows are allowed to escape the nodes allocation if
       * there is nothing (like a border, or the edge of the background color)
       * to logically confine it.
       */
      if (node->background_shadow_material != COGL_INVALID_HANDLE)
        _st_paint_shadow_with_opacity (node->background_image_shadow,
                                       node->background_shadow_material,
                                       &background_box,
                                       paint_opacity);

      paint_material_with_opacity (node->background_material, &background_box, paint_opacity);

      if (has_visible_outline)
        cogl_clip_pop ();
    }
}

/**
 * st_theme_node_copy_cached_paint_state:
 * @node: a #StThemeNode
 * @other: a different #StThemeNode
 *
 * Copy cached painting state from @other to @node. This function can be used to
 * optimize redrawing cached background images when the style on an element changess
 * in a way that doesn't affect background drawing. This function must only be called
 * if st_theme_node_paint_equal (node, other) returns %TRUE.
 */
void
st_theme_node_copy_cached_paint_state (StThemeNode *node,
                                       StThemeNode *other)
{
  int corner_id;

  g_return_if_fail (ST_IS_THEME_NODE (node));
  g_return_if_fail (ST_IS_THEME_NODE (other));

  /* Check omitted for speed: */
  /* g_return_if_fail (st_theme_node_paint_equal (node, other)); */

  _st_theme_node_free_drawing_state (node);

  node->alloc_width = other->alloc_width;
  node->alloc_height = other->alloc_height;

  if (other->background_shadow_material)
    node->background_shadow_material = cogl_handle_ref (other->background_shadow_material);
  if (other->box_shadow_material)
    node->box_shadow_material = cogl_handle_ref (other->box_shadow_material);
  if (other->background_texture)
    node->background_texture = cogl_handle_ref (other->background_texture);
  if (other->background_material)
    node->background_material = cogl_handle_ref (other->background_material);
  if (other->border_slices_texture)
    node->border_slices_texture = cogl_handle_ref (other->border_slices_texture);
  if (other->border_slices_material)
    node->border_slices_material = cogl_handle_ref (other->border_slices_material);
  if (other->prerendered_texture)
    node->prerendered_texture = cogl_handle_ref (other->prerendered_texture);
  if (other->prerendered_material)
    node->prerendered_material = cogl_handle_ref (other->prerendered_material);
  for (corner_id = 0; corner_id < 4; corner_id++)
    if (other->corner_material[corner_id])
      node->corner_material[corner_id] = cogl_handle_ref (other->corner_material[corner_id]);
}