ui/theme.c

Bug Summary

File:	ui/theme.c
Warning:	line 1325, column 10 Cast a region whose size is not a multiple of the destination type size
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name theme.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/src -resource-dir /usr/lib/llvm-16/lib/clang/16 -D HAVE_CONFIG_H -I . -I .. -I ./include -D CROMA_LIBEXECDIR="/usr/libexec" -D HOST_ALIAS="" -D CROMA_LOCALEDIR="/usr/share/locale" -D CROMA_PKGDATADIR="/usr/share/croma" -D CROMA_DATADIR="/usr/share" -D G_LOG_DOMAIN="croma" -D SN_API_NOT_YET_FROZEN=1 -I /usr/include/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -D _REENTRANT -D _REENTRANT -I /usr/include/startup-notification-1.0 -I /usr/include/libgtop-2.0 -D PIC -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir=/rootdir/src -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-02-14-231308-31150-1 -x c ui/theme.c
1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */

3/* Croma Theme Rendering */

5/*
* Copyright (C) 2001 Havoc Pennington
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/

24/**
* \file theme.c    Making Croma look pretty
*
* The window decorations drawn by Croma are described by files on disk
* known internally as "themes" (externally as "window border themes" on
* http://art.gnome.org/themes/croma/ or "Croma themes"). This file
* contains most of the code necessary to support themes; it does not
* contain the XML parser, which is in theme-parser.c.
*
* \bug This is a big file with lots of different subsystems, which might
* be better split out into separate files.
*/

37/**
* \defgroup tokenizer   The theme expression tokenizer
*
* Themes can use a simple expression language to represent the values of
* things. This is the tokeniser used for that language.
*
* \bug We could remove almost all this code by using GScanner instead,
* but we would also have to find every expression in every existing theme
* we could and make sure the parse trees were the same.
*/

48/**
* \defgroup parser  The theme expression parser
*
* Themes can use a simple expression language to represent the values of
* things. This is the parser used for that language.
*/

55#include <config.h>
56#include "prefs.h"
57#include "theme.h"
58#include "theme-parser.h"
59#include "util.h"
60#include "gradient.h"
61#include <ctk/ctk.h>
62#include <string.h>
63#include <stdlib.h>
64#define __USE_XOPEN
65#include <math.h>

67#define CDK_COLOR_RGBA(color)((guint32) (0xff | ((int)((color).red * 255) << 24) | (
(int)((color).green * 255) << 16) | ((int)((color).blue
 * 255) << 8)))                                           \
                       ((guint32) (0xff                         |     \
                                   ((int)((color).red * 255) << 24)   |    \
                                   ((int)((color).green * 255) << 16) |    \
                                   ((int)((color).blue * 255) << 8)))

73#define CDK_COLOR_RGB(color)((guint32) (((int)((color).red * 255) << 16) | ((int)((
color).green * 255) << 8) | ((int)((color).blue * 255))
))                                            \
                       ((guint32) (((int)((color).red * 255) << 16)   |    \
                                   ((int)((color).green * 255) << 8)  |    \
                                   ((int)((color).blue * 255))))

78#define ALPHA_TO_UCHAR(d)((unsigned char) ((d) * 255)) ((unsigned char) ((d) * 255))

80#define DEBUG_FILL_STRUCT(s)memset ((s), 0xef, sizeof (*(s))) memset ((s), 0xef, sizeof (*(s)))
81#define CLAMP_UCHAR(v)((guchar) ((((((int)v)) > ((int)255)) ? ((int)255) : (((((
int)v)) < ((int)0)) ? ((int)0) : (((int)v)))))) ((guchar) (CLAMP (((int)v), (int)0, (int)255)(((((int)v)) > ((int)255)) ? ((int)255) : (((((int)v)) <
 ((int)0)) ? ((int)0) : (((int)v))))))
82#define INTENSITY(r, g, b)((r) * 0.30 + (g) * 0.59 + (b) * 0.11) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)

84static void ctk_style_shade		(CdkRGBA	 *a,
			 CdkRGBA	 *b,
			 gdouble	  k);
87static void rgb_to_hls			(gdouble	 *r,
			 gdouble	 *g,
			 gdouble	 *b);
90static void hls_to_rgb			(gdouble	 *h,
			 gdouble	 *l,
			 gdouble	 *s);

94/**
* The current theme. (Themes are singleton.)
*/
97static MetaTheme *meta_current_theme = NULL((void*)0);

99static cairo_surface_t *
100scale_surface (cairo_surface_t *surface,
             gdouble          old_width,
             gdouble          old_height,
             gdouble          new_width,
             gdouble          new_height,
             gboolean         vertical_stripes,
             gboolean         horizontal_stripes)
107{
gdouble scale_x;
gdouble scale_y;
cairo_content_t content;
gint width;
gint height;
cairo_surface_t *scaled;
cairo_t *cr;

scale_x = new_width / old_width;
scale_y = new_height / old_height;

if (horizontal_stripes && !vertical_stripes)
  {
    new_width = old_width;
    scale_x = 1.0;
  }
else if (vertical_stripes && !horizontal_stripes)
  {
    new_height = old_height;
    scale_y = 1.0;
  }

content = CAIRO_CONTENT_COLOR_ALPHA;
width = ceil (new_width);
height = ceil (new_height);

scaled = cairo_surface_create_similar (surface, content, width, height);
cr = cairo_create (scaled);

cairo_scale (cr, scale_x, scale_y);
cairo_set_source_surface (cr, surface, 0, 0);

cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_PAD);

cairo_paint (cr);
cairo_destroy (cr);

return scaled;
146}

148static cairo_surface_t *
149get_surface_from_pixbuf (GdkPixbuf         *pixbuf,
                       MetaImageFillType  fill_type,
                       gdouble            width,
                       gdouble            height,
                       gboolean           vertical_stripes,
                       gboolean           horizontal_stripes)
155{
gdouble pixbuf_width;
gdouble pixbuf_height;
cairo_surface_t *surface;
cairo_content_t content;
cairo_surface_t *copy;
cairo_t *cr;

pixbuf_width = gdk_pixbuf_get_width (pixbuf);
pixbuf_height = gdk_pixbuf_get_height (pixbuf);
surface = cdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL((void*)0));

if (pixbuf_width == width && pixbuf_height == height)
  {
    return surface;
  }

if (fill_type != META_IMAGE_FILL_TILE)
  {
    cairo_surface_t *scaled;

    scaled = scale_surface (surface, pixbuf_width, pixbuf_height,
                            width, height, vertical_stripes,
                            horizontal_stripes);

    cairo_surface_destroy (surface);
    surface = scaled;
  }

content = CAIRO_CONTENT_COLOR_ALPHA;
width = ceil (width);
height = ceil (height);

copy = cairo_surface_create_similar (surface, content, width, height);
cr = cairo_create (copy);

cairo_set_source_surface (cr, surface, 0, 0);

if (fill_type == META_IMAGE_FILL_TILE ||
    vertical_stripes || horizontal_stripes)
  {
    cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
  }

cairo_paint (cr);
cairo_destroy (cr);

cairo_surface_destroy (surface);

return copy;
205}

207static GdkPixbuf *
208colorize_pixbuf (GdkPixbuf *orig,
               CdkRGBA   *new_color)
210{
GdkPixbuf *pixbuf;
double intensity;
int x, y;
const guchar *src;
int orig_rowstride;
int dest_rowstride;
int width, height;
gboolean has_alpha;
const guchar *src_pixels;
guchar *dest_pixels;

pixbuf = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (orig), gdk_pixbuf_get_has_alpha (orig),
	   gdk_pixbuf_get_bits_per_sample (orig),
	   gdk_pixbuf_get_width (orig), gdk_pixbuf_get_height (orig));

if (pixbuf == NULL((void*)0))
  return NULL((void*)0);

orig_rowstride = gdk_pixbuf_get_rowstride (orig);
dest_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
has_alpha = gdk_pixbuf_get_has_alpha (orig);
src_pixels = gdk_pixbuf_get_pixels (orig);
dest_pixels = gdk_pixbuf_get_pixels (pixbuf);

for (y = 0; y < height; y++)
  {
    guchar *dest;

    src = src_pixels + y * orig_rowstride;
    dest = dest_pixels + y * dest_rowstride;

    for (x = 0; x < width; x++)
      {
        double dr, dg, db;

        intensity = INTENSITY (src[0], src[1], src[2])((src[0]) * 0.30 + (src[1]) * 0.59 + (src[2]) * 0.11) / 255.0;

        if (intensity <= 0.5)
          {
            /* Go from black at intensity = 0.0 to new_color at intensity = 0.5 */
            dr = new_color->red * intensity * 2.0;
            dg = new_color->green * intensity * 2.0;
            db = new_color->blue * intensity * 2.0;
          }
        else
          {
            /* Go from new_color at intensity = 0.5 to white at intensity = 1.0 */
            dr = new_color->red + (1.0 - new_color->red) * (intensity - 0.5) * 2.0;
            dg = new_color->green + (1.0 - new_color->green) * (intensity - 0.5) * 2.0;
            db = new_color->blue + (1.0 - new_color->blue) * (intensity - 0.5) * 2.0;
          }

        dest[0] = CLAMP_UCHAR (255 * dr)((guchar) ((((((int)255 * dr)) > ((int)255)) ? ((int)255) :
 (((((int)255 * dr)) < ((int)0)) ? ((int)0) : (((int)255 *
 dr))))));
        dest[1] = CLAMP_UCHAR (255 * dg)((guchar) ((((((int)255 * dg)) > ((int)255)) ? ((int)255) :
 (((((int)255 * dg)) < ((int)0)) ? ((int)0) : (((int)255 *
 dg))))));
        dest[2] = CLAMP_UCHAR (255 * db)((guchar) ((((((int)255 * db)) > ((int)255)) ? ((int)255) :
 (((((int)255 * db)) < ((int)0)) ? ((int)0) : (((int)255 *
 db))))));

        if (has_alpha)
          {
            dest[3] = src[3];
            src += 4;
            dest += 4;
          }
        else
          {
            src += 3;
            dest += 3;
          }
      }
  }

return pixbuf;
284}

286static void
287color_composite (const CdkRGBA *bg,
               const CdkRGBA *fg,
               double         alpha,
               CdkRGBA       *color)
291{
*color = *bg;
color->red = color->red + (fg->red - color->red) * alpha;
color->green = color->green + (fg->green - color->green) * alpha;
color->blue = color->blue + (fg->blue - color->blue) * alpha;
296}

298/**
* Sets all the fields of a border to dummy values.
*
* \param border The border whose fields should be reset.
*/
303static void
304init_border (CtkBorder *border)
305{
border->top = -1;
border->bottom = -1;
border->left = -1;
border->right = -1;
310}

312/**
* Creates a new, empty MetaFrameLayout. The fields will be set to dummy
* values.
*
* \return The newly created MetaFrameLayout.
*/
318MetaFrameLayout*
319meta_frame_layout_new  (void)
320{
MetaFrameLayout *layout;

layout = g_new0 (MetaFrameLayout, 1)((MetaFrameLayout *) g_malloc0_n ((1), sizeof (MetaFrameLayout
)));

layout->refcount = 1;

/* Fill with -1 values to detect invalid themes */
layout->left_width = -1;
layout->right_width = -1;
layout->bottom_height = -1;

layout->invisible_border.left = 10;
layout->invisible_border.right = 10;
layout->invisible_border.bottom = 10;
layout->invisible_border.top = 10;

init_border (&layout->title_border);

layout->title_vertical_pad = -1;

layout->right_titlebar_edge = -1;
layout->left_titlebar_edge = -1;

layout->button_sizing = META_BUTTON_SIZING_LAST;
layout->button_aspect = 1.0;
layout->button_width = -1;
layout->button_height = -1;

layout->has_title = TRUE(!(0));
layout->title_scale = 1.0;

init_border (&layout->button_border);

return layout;
355}

357/**
*
*/
360static gboolean
361validate_border (const CtkBorder *border,
               const char     **bad)
363{
*bad = NULL((void*)0);

if (border->top < 0)
  *bad = _("top")dgettext ("croma", "top");
else if (border->bottom < 0)
  *bad = _("bottom")dgettext ("croma", "bottom");
else if (border->left < 0)
  *bad = _("left")dgettext ("croma", "left");
else if (border->right < 0)
  *bad = _("right")dgettext ("croma", "right");

return *bad == NULL((void*)0);
376}

378/**
* Ensures that the theme supplied a particular dimension. When a
* MetaFrameLayout is created, all its integer fields are set to -1
* by meta_frame_layout_new(). After an instance of this type
* should have been initialised, this function checks that
* a given field is not still at -1. It is never called directly, but
* rather via the CHECK_GEOMETRY_VALUE and CHECK_GEOMETRY_BORDER
* macros.
*
* \param      val    The value to check
* \param      name   The name to use in the error message
* \param[out] error  Set to an error if val was not initialised
*/
391static gboolean
392validate_geometry_value (int         val,
                       const char *name,
                       GError    **error)
395{
if (val < 0)
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_FRAME_GEOMETRY,
                 _("frame geometry does not specify \"%s\" dimension")dgettext ("croma", "frame geometry does not specify \"%s\" dimension"
),
                 name);
    return FALSE(0);
  }
else
  return TRUE(!(0));
406}

408static gboolean
409validate_geometry_border (const CtkBorder *border,
                        const char      *name,
                        GError         **error)
412{
const char *bad;

if (!validate_border (border, &bad))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_FRAME_GEOMETRY,
                 _("frame geometry does not specify dimension \"%s\" for border \"%s\"")dgettext ("croma", "frame geometry does not specify dimension \"%s\" for border \"%s\""
),
                 bad, name);
    return FALSE(0);
  }
else
  return TRUE(!(0));
425}

427gboolean
428meta_frame_layout_validate (const MetaFrameLayout *layout,
                          GError               **error)
430{
g_return_val_if_fail (layout != NULL, FALSE)do { if ((layout != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "layout != NULL"); return
 ((0)); } } while (0);

433#define CHECK_GEOMETRY_VALUE(vname)if (!validate_geometry_value (layout->vname, "vname", error
)) return (0) if (!validate_geometry_value (layout->vname, #vname, error)) return FALSE(0)

435#define CHECK_GEOMETRY_BORDER(bname)if (!validate_geometry_border (&layout->bname, "bname"
, error)) return (0) if (!validate_geometry_border (&layout->bname, #bname, error)) return FALSE(0)

CHECK_GEOMETRY_VALUE (left_width)if (!validate_geometry_value (layout->left_width, "left_width"
, error)) return (0);
CHECK_GEOMETRY_VALUE (right_width)if (!validate_geometry_value (layout->right_width, "right_width"
, error)) return (0);
CHECK_GEOMETRY_VALUE (bottom_height)if (!validate_geometry_value (layout->bottom_height, "bottom_height"
, error)) return (0);

CHECK_GEOMETRY_BORDER (title_border)if (!validate_geometry_border (&layout->title_border, "title_border"
, error)) return (0);

CHECK_GEOMETRY_VALUE (title_vertical_pad)if (!validate_geometry_value (layout->title_vertical_pad, "title_vertical_pad"
, error)) return (0);

CHECK_GEOMETRY_VALUE (right_titlebar_edge)if (!validate_geometry_value (layout->right_titlebar_edge,
 "right_titlebar_edge", error)) return (0);
CHECK_GEOMETRY_VALUE (left_titlebar_edge)if (!validate_geometry_value (layout->left_titlebar_edge, "left_titlebar_edge"
, error)) return (0);

switch (layout->button_sizing)
  {
  case META_BUTTON_SIZING_ASPECT:
    if (layout->button_aspect < (0.1) ||
        layout->button_aspect > (15.0))
      {
        g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FRAME_GEOMETRY,
                     _("Button aspect ratio %g is not reasonable")dgettext ("croma", "Button aspect ratio %g is not reasonable"
),
                     layout->button_aspect);
        return FALSE(0);
      }
    break;
  case META_BUTTON_SIZING_FIXED:
    CHECK_GEOMETRY_VALUE (button_width)if (!validate_geometry_value (layout->button_width, "button_width"
, error)) return (0);
    CHECK_GEOMETRY_VALUE (button_height)if (!validate_geometry_value (layout->button_height, "button_height"
, error)) return (0);
    break;
  case META_BUTTON_SIZING_LAST:
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_FRAME_GEOMETRY,
                 _("Frame geometry does not specify size of buttons")dgettext ("croma", "Frame geometry does not specify size of buttons"
));
    return FALSE(0);
  }

CHECK_GEOMETRY_BORDER (button_border)if (!validate_geometry_border (&layout->button_border,
 "button_border", error)) return (0);

return TRUE(!(0));
475}

477MetaFrameLayout*
478meta_frame_layout_copy (const MetaFrameLayout *src)
479{
MetaFrameLayout *layout;

layout = g_new0 (MetaFrameLayout, 1)((MetaFrameLayout *) g_malloc0_n ((1), sizeof (MetaFrameLayout
)));

*layout = *src;

layout->refcount = 1;

return layout;
489}

491void
492meta_frame_layout_ref (MetaFrameLayout *layout)
493{
g_return_if_fail (layout != NULL)do { if ((layout != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "layout != NULL"); return
; } } while (0);

layout->refcount += 1;
497}

499void
500meta_frame_layout_unref (MetaFrameLayout *layout)
501{
g_return_if_fail (layout != NULL)do { if ((layout != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "layout != NULL"); return
; } } while (0);
g_return_if_fail (layout->refcount > 0)do { if ((layout->refcount > 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "layout->refcount > 0"
); return; } } while (0);

layout->refcount -= 1;

if (layout->refcount == 0)
  {
    DEBUG_FILL_STRUCT (layout)memset ((layout), 0xef, sizeof (*(layout)));
    g_free (layout);
  }
512}

514void
515meta_frame_layout_get_borders (const MetaFrameLayout *layout,
                             int                    text_height,
                             MetaFrameFlags         flags,
                             MetaFrameBorders      *borders)
519{
int buttons_height, title_height;

meta_frame_borders_clear (borders);

/* For a full-screen window, we don't have any borders, visible or not. */
if (flags & META_FRAME_FULLSCREEN)
  return;

g_return_if_fail (layout != NULL)do { if ((layout != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "layout != NULL"); return
; } } while (0);

if (!layout->has_title)
  text_height = 0;

buttons_height = layout->button_height +
  layout->button_border.top + layout->button_border.bottom;
title_height = text_height +
  layout->title_vertical_pad +
  layout->title_border.top + layout->title_border.bottom;

borders->visible.top = MAX (buttons_height, title_height)(((buttons_height) > (title_height)) ? (buttons_height) : (
title_height));
borders->visible.left = layout->left_width;
borders->visible.right = layout->right_width;
borders->visible.bottom = layout->bottom_height;

if (flags & META_FRAME_ALLOWS_HORIZONTAL_RESIZE)
  {
    borders->invisible.left = layout->invisible_border.left;
    borders->invisible.right = layout->invisible_border.right;
  }

if (flags & META_FRAME_ALLOWS_VERTICAL_RESIZE)
  {
    borders->invisible.bottom = layout->invisible_border.bottom;
    borders->invisible.top = layout->invisible_border.top;
  }

if (flags & META_FRAME_SHADED)
  borders->visible.bottom = borders->invisible.bottom = 0;

borders->total.left = borders->invisible.left + borders->visible.left;
borders->total.right = borders->invisible.right + borders->visible.right;
borders->total.bottom = borders->invisible.bottom + borders->visible.bottom;
borders->total.top = borders->invisible.top + borders->visible.top;
563}

565static MetaButtonType
566map_button_function_to_type (MetaButtonFunction  function)
567{
switch (function)
  {
  case META_BUTTON_FUNCTION_SHADE:
    return META_BUTTON_TYPE_SHADE;
  case META_BUTTON_FUNCTION_ABOVE:
    return META_BUTTON_TYPE_ABOVE;
  case META_BUTTON_FUNCTION_STICK:
    return META_BUTTON_TYPE_STICK;
  case META_BUTTON_FUNCTION_UNSHADE:
    return META_BUTTON_TYPE_UNSHADE;
  case META_BUTTON_FUNCTION_UNABOVE:
    return META_BUTTON_TYPE_UNABOVE;
  case META_BUTTON_FUNCTION_UNSTICK:
    return META_BUTTON_TYPE_UNSTICK;
  case META_BUTTON_FUNCTION_MENU:
    return META_BUTTON_TYPE_MENU;
  case META_BUTTON_FUNCTION_APPMENU:
    return META_BUTTON_TYPE_APPMENU;
  case META_BUTTON_FUNCTION_MINIMIZE:
    return META_BUTTON_TYPE_MINIMIZE;
  case META_BUTTON_FUNCTION_MAXIMIZE:
    return META_BUTTON_TYPE_MAXIMIZE;
  case META_BUTTON_FUNCTION_CLOSE:
    return META_BUTTON_TYPE_CLOSE;
  case META_BUTTON_FUNCTION_LAST:
    return META_BUTTON_TYPE_LAST;
  }

return META_BUTTON_TYPE_LAST;
597}

599static MetaButtonSpace*
600rect_for_function (MetaFrameGeometry *fgeom,
                 MetaFrameFlags     flags,
                 MetaButtonFunction function,
                 MetaTheme         *theme)
604{

/* Firstly, check version-specific things. */

if (META_THEME_ALLOWS(theme, META_THEME_SHADE_STICK_ABOVE_BUTTONS)(theme->format_version >= 2))
  {
    switch (function)
      {
      case META_BUTTON_FUNCTION_SHADE:
        if ((flags & META_FRAME_ALLOWS_SHADE) && !(flags & META_FRAME_SHADED))
          return &fgeom->shade_rect;
        else
          return NULL((void*)0);
      case META_BUTTON_FUNCTION_ABOVE:
        if (!(flags & META_FRAME_ABOVE))
          return &fgeom->above_rect;
        else
          return NULL((void*)0);
      case META_BUTTON_FUNCTION_STICK:
        if (!(flags & META_FRAME_STUCK))
          return &fgeom->stick_rect;
        else
          return NULL((void*)0);
      case META_BUTTON_FUNCTION_UNSHADE:
        if ((flags & META_FRAME_ALLOWS_SHADE) && (flags & META_FRAME_SHADED))
          return &fgeom->unshade_rect;
        else
          return NULL((void*)0);
      case META_BUTTON_FUNCTION_UNABOVE:
        if (flags & META_FRAME_ABOVE)
          return &fgeom->unabove_rect;
        else
          return NULL((void*)0);
      case META_BUTTON_FUNCTION_UNSTICK:
        if (flags & META_FRAME_STUCK)
          return &fgeom->unstick_rect;
      default:
        /* just go on to the next switch block */;
      }
  }

/* now consider the buttons which exist in all versions */

switch (function)
  {
  case META_BUTTON_FUNCTION_MENU:
    if (flags & META_FRAME_ALLOWS_MENU)
      return &fgeom->menu_rect;
    else
      return NULL((void*)0);
  case META_BUTTON_FUNCTION_APPMENU:
    if (flags & META_FRAME_ALLOWS_APPMENU)
      return &fgeom->appmenu_rect;
    else
      return NULL((void*)0);
  case META_BUTTON_FUNCTION_MINIMIZE:
    if (flags & META_FRAME_ALLOWS_MINIMIZE)
      return &fgeom->min_rect;
    else
      return NULL((void*)0);
  case META_BUTTON_FUNCTION_MAXIMIZE:
    if (flags & META_FRAME_ALLOWS_MAXIMIZE)
      return &fgeom->max_rect;
    else
      return NULL((void*)0);
  case META_BUTTON_FUNCTION_CLOSE:
    if (flags & META_FRAME_ALLOWS_DELETE)
      return &fgeom->close_rect;
    else
      return NULL((void*)0);
  case META_BUTTON_FUNCTION_STICK:
  case META_BUTTON_FUNCTION_SHADE:
  case META_BUTTON_FUNCTION_ABOVE:
  case META_BUTTON_FUNCTION_UNSTICK:
  case META_BUTTON_FUNCTION_UNSHADE:
  case META_BUTTON_FUNCTION_UNABOVE:
    /* we are being asked for a >v1 button which hasn't been handled yet,
     * so obviously we're not in a theme which supports that version.
     * therefore, we don't show the button. return NULL and all will
     * be well.
     */
    return NULL((void*)0);

  case META_BUTTON_FUNCTION_LAST:
    return NULL((void*)0);
  }

return NULL((void*)0);
692}

694static gboolean
695strip_button (MetaButtonSpace *func_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST],
            CdkRectangle    *bg_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST],
            int             *n_rects,
            MetaButtonSpace *to_strip)
699{
int i;

i = 0;
while (i < *n_rects)
  {
    if (func_rects[i] == to_strip)
      {
        *n_rects -= 1;

        /* shift the other rects back in the array */
        while (i < *n_rects)
          {
            func_rects[i] = func_rects[i+1];
            bg_rects[i] = bg_rects[i+1];

            ++i;
          }

        func_rects[i] = NULL((void*)0);
        bg_rects[i] = NULL((void*)0);

        return TRUE(!(0));
      }

    ++i;
  }

return FALSE(0); /* did not strip anything */
728}

730void
731meta_frame_layout_calc_geometry (const MetaFrameLayout  *layout,
                               int                     text_height,
                               MetaFrameFlags          flags,
                               int                     client_width,
                               int                     client_height,
                               const MetaButtonLayout *button_layout,
                               MetaFrameGeometry      *fgeom,
                               MetaTheme              *theme)
739{
int i, n_left, n_right, n_left_spacers, n_right_spacers;
int x;
int button_y;
int title_right_edge;
int width, height;
int button_width, button_height;
int min_size_for_rounding;

/* the left/right rects in order; the max # of rects
 * is the number of button functions
 */
MetaButtonSpace *left_func_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
MetaButtonSpace *right_func_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
CdkRectangle *left_bg_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
gboolean left_buttons_has_spacer[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
CdkRectangle *right_bg_rects[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];
gboolean right_buttons_has_spacer[MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST];

MetaFrameBorders borders;

meta_frame_layout_get_borders (layout, text_height,
                               flags,
                               &borders);

fgeom->borders = borders;

width = client_width + borders.total.left + borders.total.right;

height = ((flags & META_FRAME_SHADED) ? 0: client_height) +
  borders.total.top + borders.total.bottom;

fgeom->width = width;
fgeom->height = height;

fgeom->top_titlebar_edge = layout->title_border.top;
fgeom->bottom_titlebar_edge = layout->title_border.bottom;
fgeom->left_titlebar_edge = layout->left_titlebar_edge;
fgeom->right_titlebar_edge = layout->right_titlebar_edge;

switch (layout->button_sizing)
  {
  case META_BUTTON_SIZING_ASPECT:
    button_height = borders.visible.top - layout->button_border.top - layout->button_border.bottom;
    button_width = button_height / layout->button_aspect;
    break;
  case META_BUTTON_SIZING_FIXED:
    button_width = layout->button_width;
    button_height = layout->button_height;
    break;
  case META_BUTTON_SIZING_LAST:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 790, ((
const char*) (__func__)), ((void*)0)); } while (0);
  default:
    button_width = -1;
    button_height = -1;
  }

/* FIXME all this code sort of pretends that duplicate buttons
 * with the same function are allowed, but that breaks the
 * code in frames.c, so isn't really allowed right now.
 * Would need left_close_rect, right_close_rect, etc.
 */

/* Init all button rects to 0, lame hack */
memset (ADDRESS_OF_BUTTON_RECTS (fgeom)(((char*)(fgeom)) + ((glong) __builtin_offsetof(MetaFrameGeometry
, close_rect))), '\0',
        LENGTH_OF_BUTTON_RECTS(((glong) __builtin_offsetof(MetaFrameGeometry, right_single_background
)) + sizeof (CdkRectangle) - ((glong) __builtin_offsetof(MetaFrameGeometry
, close_rect))));

n_left = 0;
n_right = 0;
n_left_spacers = 0;
n_right_spacers = 0;

if (!layout->hide_buttons)
  {
    /* Try to fill in rects */
    for (i = 0; i < MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST && button_layout->left_buttons[i] != META_BUTTON_FUNCTION_LAST; i++)
      {
        left_func_rects[n_left] = rect_for_function (fgeom, flags,
                                                     button_layout->left_buttons[i],
                                                     theme);
        if (left_func_rects[n_left] != NULL((void*)0))
          {
            left_buttons_has_spacer[n_left] = button_layout->left_buttons_has_spacer[i];
            if (button_layout->left_buttons_has_spacer[i])
              ++n_left_spacers;

            ++n_left;
          }
      }

    for (i = 0; i < MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST && button_layout->right_buttons[i] != META_BUTTON_FUNCTION_LAST; i++)
      {
        right_func_rects[n_right] = rect_for_function (fgeom, flags,
                                                       button_layout->right_buttons[i],
                                                       theme);
        if (right_func_rects[n_right] != NULL((void*)0))
          {
            right_buttons_has_spacer[n_right] = button_layout->right_buttons_has_spacer[i];
            if (button_layout->right_buttons_has_spacer[i])
              ++n_right_spacers;

            ++n_right;
          }
      }
  }

for (i = 0; i < MAX_BUTTONS_PER_CORNERMETA_BUTTON_FUNCTION_LAST; i++)
  {
    left_bg_rects[i] = NULL((void*)0);
    right_bg_rects[i] = NULL((void*)0);
  }

for (i = 0; i < n_left; i++)
  {
    if (n_left == 1)
      left_bg_rects[i] = &fgeom->left_single_background;
    else if (i == 0)
      left_bg_rects[i] = &fgeom->left_left_background;
    else if (i == (n_left - 1))
      left_bg_rects[i] = &fgeom->left_right_background;
    else
      left_bg_rects[i] = &fgeom->left_middle_backgrounds[i - 1];
  }

for (i = 0; i < n_right; i++)
  {
    if (n_right == 1)
      right_bg_rects[i] = &fgeom->right_single_background;
    else if (i == (n_right - 1))
      right_bg_rects[i] = &fgeom->right_right_background;
    else if (i == 0)
      right_bg_rects[i] = &fgeom->right_left_background;
    else
      right_bg_rects[i] = &fgeom->right_middle_backgrounds[i - 1];
  }

/* Be sure buttons fit */
while (n_left > 0 || n_right > 0)
  {
    int space_used_by_buttons;
    int space_available;

    space_available = fgeom->width - layout->left_titlebar_edge - layout->right_titlebar_edge;

    space_used_by_buttons = 0;

    space_used_by_buttons += button_width * n_left;
    space_used_by_buttons += (button_width * 0.75) * n_left_spacers;
    space_used_by_buttons += layout->button_border.left * n_left;
    space_used_by_buttons += layout->button_border.right * n_left;

    space_used_by_buttons += button_width * n_right;
    space_used_by_buttons += (button_width * 0.75) * n_right_spacers;
    space_used_by_buttons += layout->button_border.left * n_right;
    space_used_by_buttons += layout->button_border.right * n_right;

    if (space_used_by_buttons <= space_available)
      break; /* Everything fits, bail out */

    /* First try to remove separators */
    if (n_left_spacers > 0)
      {
        left_buttons_has_spacer[--n_left_spacers] = FALSE(0);
        continue;
      }
    else if (n_right_spacers > 0)
      {
        right_buttons_has_spacer[--n_right_spacers] = FALSE(0);
        continue;
      }

    /* Otherwise we need to shave out a button. Shave
     * above, stick, shade, min, max, close, then menu (menu is most useful);
     * prefer the default button locations.
     */
    if (strip_button (left_func_rects, left_bg_rects,
                      &n_left, &fgeom->above_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->above_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                      &n_left, &fgeom->stick_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->stick_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                      &n_left, &fgeom->shade_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->shade_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                      &n_left, &fgeom->min_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->min_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                           &n_left, &fgeom->max_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->max_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                           &n_left, &fgeom->close_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->close_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->menu_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                           &n_left, &fgeom->menu_rect))
      continue;
    else if (strip_button (right_func_rects, right_bg_rects,
                           &n_right, &fgeom->appmenu_rect))
      continue;
    else if (strip_button (left_func_rects, left_bg_rects,
                           &n_left, &fgeom->appmenu_rect))
      continue;
    else
      {
        meta_bug ("Could not find a button to strip. n_left = %d n_right = %d\n",
                  n_left, n_right);
      }
  }

/* Save the button layout */
fgeom->button_layout = *button_layout;
fgeom->n_left_buttons = n_left;
fgeom->n_right_buttons = n_right;

/* center buttons vertically */
button_y = (borders.visible.top -
            (button_height + layout->button_border.top + layout->button_border.bottom)) / 2 + layout->button_border.top + borders.invisible.top;

/* right edge of farthest-right button */
x = width - layout->right_titlebar_edge - borders.invisible.right;

i = n_right - 1;
while (i >= 0)
  {
    MetaButtonSpace *rect;

    if (x < 0) /* if we go negative, leave the buttons we don't get to as 0-width */
      break;

    rect = right_func_rects[i];
    rect->visible.x = x - layout->button_border.right - button_width;
    if (right_buttons_has_spacer[i])
      rect->visible.x -= (button_width * 0.75);

    rect->visible.y = button_y;
    rect->visible.width = button_width;
    rect->visible.height = button_height;

    if (flags & META_FRAME_MAXIMIZED ||
        flags & META_FRAME_TILED_LEFT ||
        flags & META_FRAME_TILED_RIGHT)
      {
        rect->clickable.x = rect->visible.x;
        rect->clickable.y = rect->visible.y;
        rect->clickable.width = button_width;
        rect->clickable.height = button_height;

        if (i == n_right - 1)
          rect->clickable.width += layout->right_titlebar_edge + layout->right_width + layout->button_border.right;

      }
    else
      memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable));

    *(right_bg_rects[i]) = rect->visible;

    x = rect->visible.x - layout->button_border.left;

    --i;
  }

/* save right edge of titlebar for later use */
title_right_edge = x - layout->title_border.right;

/* Now x changes to be position from the left and we go through
 * the left-side buttons
 */
x = layout->left_titlebar_edge + borders.invisible.left;
for (i = 0; i < n_left; i++)
  {
    MetaButtonSpace *rect;

    rect = left_func_rects[i];

    rect->visible.x = x + layout->button_border.left;
    rect->visible.y = button_y;
    rect->visible.width = button_width;
    rect->visible.height = button_height;

    if (flags & META_FRAME_MAXIMIZED)
      {
        rect->clickable.x = rect->visible.x;
        rect->clickable.y = rect->visible.y;
        rect->clickable.width = button_width;
        rect->clickable.height = button_height;
      }
    else
      memmove (&(rect->clickable), &(rect->visible), sizeof(rect->clickable));

    x = rect->visible.x + rect->visible.width + layout->button_border.right;
    if (left_buttons_has_spacer[i])
      x += (button_width * 0.75);

    *(left_bg_rects[i]) = rect->visible;
  }

/* We always fill as much vertical space as possible with title rect,
 * rather than centering it like the buttons
 */
fgeom->title_rect.x = x + layout->title_border.left;
fgeom->title_rect.y = layout->title_border.top + borders.invisible.top;
fgeom->title_rect.width = title_right_edge - fgeom->title_rect.x;
fgeom->title_rect.height = borders.visible.top - layout->title_border.top - layout->title_border.bottom;

/* Nuke title if it won't fit */
if (fgeom->title_rect.width < 0 ||
    fgeom->title_rect.height < 0)
  {
    fgeom->title_rect.width = 0;
    fgeom->title_rect.height = 0;
  }

if (flags & META_FRAME_SHADED)
  min_size_for_rounding = 0;
else
  min_size_for_rounding = 5;

fgeom->top_left_corner_rounded_radius = 0;
fgeom->top_right_corner_rounded_radius = 0;
fgeom->bottom_left_corner_rounded_radius = 0;
fgeom->bottom_right_corner_rounded_radius = 0;

if (borders.visible.top + borders.visible.left >= min_size_for_rounding)
  fgeom->top_left_corner_rounded_radius = layout->top_left_corner_rounded_radius;
if (borders.visible.top + borders.visible.right >= min_size_for_rounding)
  fgeom->top_right_corner_rounded_radius = layout->top_right_corner_rounded_radius;

if (borders.visible.bottom + borders.visible.left >= min_size_for_rounding)
  fgeom->bottom_left_corner_rounded_radius = layout->bottom_left_corner_rounded_radius;
if (borders.visible.bottom + borders.visible.right >= min_size_for_rounding)
  fgeom->bottom_right_corner_rounded_radius = layout->bottom_right_corner_rounded_radius;
1091}

1093MetaGradientSpec*
1094meta_gradient_spec_new (MetaGradientType type)
1095{
MetaGradientSpec *spec;

spec = g_new (MetaGradientSpec, 1)((MetaGradientSpec *) g_malloc_n ((1), sizeof (MetaGradientSpec
)));

spec->type = type;
spec->color_specs = NULL((void*)0);

return spec;
1104}

1106static cairo_pattern_t *
1107create_cairo_pattern_from_gradient_spec (const MetaGradientSpec      *spec,
                                       const MetaAlphaGradientSpec *alpha_spec,
                                       CtkStyleContext             *context)
1110{
gint n_colors;
cairo_pattern_t *pattern;
GSList *tmp;
gint i;

n_colors = g_slist_length (spec->color_specs);
if (n_colors == 0)
  return NULL((void*)0);

if (alpha_spec != NULL((void*)0) && alpha_spec->n_alphas != 1)
  g_assert (n_colors == alpha_spec->n_alphas)do { if (n_colors == alpha_spec->n_alphas) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 1121, ((const char*) (__func__)), "n_colors == alpha_spec->n_alphas"
); } while (0);

if (spec->type == META_GRADIENT_HORIZONTAL)
  pattern = cairo_pattern_create_linear (0, 0, 1, 0);
else if (spec->type == META_GRADIENT_VERTICAL)
  pattern = cairo_pattern_create_linear (0, 0, 0, 1);
else if (spec->type == META_GRADIENT_DIAGONAL)
  pattern = cairo_pattern_create_linear (0, 0, 1, 1);
else
  g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 1130, (
(const char*) (__func__)), ((void*)0)); } while (0);

i = 0;
tmp = spec->color_specs;
while (tmp != NULL((void*)0))
  {
    CdkRGBA color;

    meta_color_spec_render (tmp->data, context, &color);

    if (alpha_spec != NULL((void*)0))
      {
        gdouble alpha;

        if (alpha_spec->n_alphas == 1)
          alpha = alpha_spec->alphas[0] / 255.0;
        else
          alpha = alpha_spec->alphas[i] / 255.0;

        cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_colors - 1),
                                           color.red, color.green, color.blue,
                                           alpha);
      }
    else
      cairo_pattern_add_color_stop_rgb (pattern, i / (gfloat) (n_colors - 1),
                                        color.red, color.green, color.blue);

    tmp = tmp->next;
    ++i;
  }

if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
  {
    cairo_pattern_destroy (pattern);
    return NULL((void*)0);
  }

return pattern;
1168}

1170static void
1171free_color_spec (gpointer spec, gpointer user_data)
1172{
meta_color_spec_free (spec);
1174}

1176void
1177meta_gradient_spec_free (MetaGradientSpec *spec)
1178{
g_return_if_fail (spec != NULL)do { if ((spec != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "spec != NULL"); return
; } } while (0);

g_slist_foreach (spec->color_specs, free_color_spec, NULL((void*)0));
g_slist_free (spec->color_specs);

DEBUG_FILL_STRUCT (spec)memset ((spec), 0xef, sizeof (*(spec)));
g_free (spec);
1186}

1188void
1189meta_gradient_spec_render (const MetaGradientSpec      *spec,
                         const MetaAlphaGradientSpec *alpha_spec,
                         cairo_t                     *cr,
                         CtkStyleContext             *context,
                         gint                         x,
                         gint                         y,
                         gint                         width,
                         gint                         height)
1197{
cairo_pattern_t *pattern;

pattern = create_cairo_pattern_from_gradient_spec (spec, alpha_spec, context);
if (pattern == NULL((void*)0))
  return;

cairo_save (cr);

cairo_rectangle (cr, x, y, width, height);

cairo_translate (cr, x, y);
cairo_scale (cr, width, height);

cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);

cairo_restore (cr);
1216}

1218gboolean
1219meta_gradient_spec_validate (MetaGradientSpec *spec,
                           GError          **error)
1221{
g_return_val_if_fail (spec != NULL, FALSE)do { if ((spec != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "spec != NULL"); return
 ((0)); } } while (0);

if (g_slist_length (spec->color_specs) < 2)
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_FAILED,
                 _("Gradients should have at least two colors")dgettext ("croma", "Gradients should have at least two colors"
));
    return FALSE(0);
  }

return TRUE(!(0));
1233}

1235MetaAlphaGradientSpec*
1236meta_alpha_gradient_spec_new (MetaGradientType       type,
                            int                    n_alphas)
1238{
MetaAlphaGradientSpec *spec;

g_return_val_if_fail (n_alphas > 0, NULL)do { if ((n_alphas > 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "n_alphas > 0"); return
 (((void*)0)); } } while (0);

spec = g_new0 (MetaAlphaGradientSpec, 1)((MetaAlphaGradientSpec *) g_malloc0_n ((1), sizeof (MetaAlphaGradientSpec
)));

spec->type = type;
spec->alphas = g_new0 (unsigned char, n_alphas)((unsigned char *) g_malloc0_n ((n_alphas), sizeof (unsigned char
)));
spec->n_alphas = n_alphas;

return spec;
1250}

1252void
1253meta_alpha_gradient_spec_free (MetaAlphaGradientSpec *spec)
1254{
g_return_if_fail (spec != NULL)do { if ((spec != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "spec != NULL"); return
; } } while (0);

g_free (spec->alphas);
g_free (spec);
1259}

1261cairo_pattern_t *
1262meta_alpha_gradient_spec_get_mask (const MetaAlphaGradientSpec *spec)
1263{
gint n_alphas;
cairo_pattern_t *pattern;
gint i;

/* Hardcoded in theme-parser.c */
g_assert (spec->type == META_GRADIENT_HORIZONTAL)do { if (spec->type == META_GRADIENT_HORIZONTAL) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 1269, ((const char*) (__func__)), "spec->type == META_GRADIENT_HORIZONTAL"
); } while (0);

n_alphas = spec->n_alphas;
if (n_alphas == 0)
  return NULL((void*)0);

if (n_alphas == 1)
  return cairo_pattern_create_rgba (0, 0, 0, spec->alphas[0] / 255.0);

pattern = cairo_pattern_create_linear (0, 0, 1, 0);

for (i = 0; i < n_alphas; i++)
  cairo_pattern_add_color_stop_rgba (pattern, i / (gfloat) (n_alphas - 1),
                                     0, 0, 0, spec->alphas[i] / 255.0);

if (cairo_pattern_status (pattern) != CAIRO_STATUS_SUCCESS)
  {
    cairo_pattern_destroy (pattern);
    return NULL((void*)0);
  }

return pattern;
1291}

1293MetaColorSpec*
1294meta_color_spec_new (MetaColorSpecType type)
1295{
MetaColorSpec *spec;
MetaColorSpec dummy;
int size;

size = G_STRUCT_OFFSET (MetaColorSpec, data)((glong) __builtin_offsetof(MetaColorSpec, data));

switch (type)
2
←
Control jumps to 'case META_COLOR_SPEC_CTK:'  at line 1308→
  {
  case META_COLOR_SPEC_BASIC:
    size += sizeof (dummy.data.basic);
    break;

  case META_COLOR_SPEC_CTK:
    size += sizeof (dummy.data.ctk);
    break;

  case META_COLOR_SPEC_CTK_CUSTOM:
    size += sizeof (dummy.data.ctkcustom);
    break;

  case META_COLOR_SPEC_BLEND:
    size += sizeof (dummy.data.blend);
    break;

  case META_COLOR_SPEC_SHADE:
    size += sizeof (dummy.data.shade);
    break;
  }

spec = g_malloc0 (size);
3
←
 Execution continues on line 1325→
4
←
Cast a region whose size is not a multiple of the destination type size

spec->type = type;

return spec;
1330}

1332void
1333meta_color_spec_free (MetaColorSpec *spec)
1334{
g_return_if_fail (spec != NULL)do { if ((spec != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "spec != NULL"); return
; } } while (0);

switch (spec->type)
  {
  case META_COLOR_SPEC_BASIC:
    DEBUG_FILL_STRUCT (&spec->data.basic)memset ((&spec->data.basic), 0xef, sizeof (*(&spec
->data.basic)));
    break;

  case META_COLOR_SPEC_CTK:
    DEBUG_FILL_STRUCT (&spec->data.ctk)memset ((&spec->data.ctk), 0xef, sizeof (*(&spec->
data.ctk)));
    break;

  case META_COLOR_SPEC_CTK_CUSTOM:
    if (spec->data.ctkcustom.color_name)
      g_free (spec->data.ctkcustom.color_name);
    if (spec->data.ctkcustom.fallback)
      meta_color_spec_free (spec->data.ctkcustom.fallback);
    DEBUG_FILL_STRUCT (&spec->data.ctkcustom)memset ((&spec->data.ctkcustom), 0xef, sizeof (*(&
spec->data.ctkcustom)));
    break;

  case META_COLOR_SPEC_BLEND:
    if (spec->data.blend.foreground)
      meta_color_spec_free (spec->data.blend.foreground);
    if (spec->data.blend.background)
      meta_color_spec_free (spec->data.blend.background);
    DEBUG_FILL_STRUCT (&spec->data.blend)memset ((&spec->data.blend), 0xef, sizeof (*(&spec
->data.blend)));
    break;

  case META_COLOR_SPEC_SHADE:
    if (spec->data.shade.base)
      meta_color_spec_free (spec->data.shade.base);
    DEBUG_FILL_STRUCT (&spec->data.shade)memset ((&spec->data.shade), 0xef, sizeof (*(&spec
->data.shade)));
    break;
  }

g_free (spec);
1371}

1373MetaColorSpec*
1374meta_color_spec_new_from_string (const char *str,
                               GError    **err)
1376{
MetaColorSpec *spec;

spec = NULL((void*)0);

if (strncmp (str, "ctk:custom", 10) == 0)
  {
    const char *color_name_start, *fallback_str_start, *end;
    char *color_name;
    MetaColorSpec *fallback = NULL((void*)0);
    static gboolean debug, debug_set = FALSE(0);

    if (!debug_set)
      {
        debug = g_getenv ("CROMA_DISABLE_FALLBACK_COLOR") != NULL((void*)0);
        debug_set = TRUE(!(0));
      }

    if (str[10] != '(')
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("CTK custom color specification must have color name and fallback in parentheses, e.g. ctk:custom(foo,bar); could not parse \"%s\"")dgettext ("croma", "CTK custom color specification must have color name and fallback in parentheses, e.g. ctk:custom(foo,bar); could not parse \"%s\""
),
                     str);
        return NULL((void*)0);
      }

    color_name_start = str + 11;

    fallback_str_start = color_name_start;
    while (*fallback_str_start && *fallback_str_start != ',')
      {
        if (!(g_ascii_isalnum (*fallback_str_start)((g_ascii_table[(guchar) (*fallback_str_start)] & G_ASCII_ALNUM
) != 0)
              || *fallback_str_start == '-'
              || *fallback_str_start == '_'))
          {
            g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                         META_THEME_ERROR_FAILED,
                         _("Invalid character '%c' in color_name parameter of ctk:custom, only A-Za-z0-9-_ are valid")dgettext ("croma", "Invalid character '%c' in color_name parameter of ctk:custom, only A-Za-z0-9-_ are valid"
),
                         *fallback_str_start);
            return NULL((void*)0);
          }
        fallback_str_start++;
      }
    fallback_str_start++;

    end = strrchr (str, ')');

    if (color_name_start == NULL((void*)0) || fallback_str_start == NULL((void*)0) || end == NULL((void*)0))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Ctk:custom format is \"ctk:custom(color_name,fallback)\", \"%s\" does not fit the format")dgettext ("croma", "Ctk:custom format is \"ctk:custom(color_name,fallback)\", \"%s\" does not fit the format"
),
                     str);
        return NULL((void*)0);
      }

    if (!debug)
      {
        char *fallback_str;
        fallback_str = g_strndup (fallback_str_start,
                                  end - fallback_str_start);
        fallback = meta_color_spec_new_from_string (fallback_str, err);
        g_free (fallback_str);
      }
    else
      {
        fallback = meta_color_spec_new_from_string ("pink", err);
      }

    if (fallback == NULL((void*)0))
      return NULL((void*)0);

    color_name = g_strndup (color_name_start, fallback_str_start - color_name_start - 1);

    spec = meta_color_spec_new (META_COLOR_SPEC_CTK_CUSTOM);
    spec->data.ctkcustom.color_name = color_name;
    spec->data.ctkcustom.fallback = fallback;
  }
else if (strncmp (str, "ctk:", 4) == 0)
  {
    /* CTK color */
    const char *bracket;
    const char *end_bracket;
    char *tmp;
    CtkStateFlags state;
    MetaCtkColorComponent component;

    bracket = str;
    while (*bracket && *bracket != '[')
      ++bracket;

    if (*bracket == '\0')
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("CTK color specification must have the state in brackets, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\"")dgettext ("croma", "CTK color specification must have the state in brackets, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\""
),
                     str);
        return NULL((void*)0);
      }

    end_bracket = bracket;
    ++end_bracket;
    while (*end_bracket && *end_bracket != ']')
      ++end_bracket;

    if (*end_bracket == '\0')
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("CTK color specification must have a close bracket after the state, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\"")dgettext ("croma", "CTK color specification must have a close bracket after the state, e.g. ctk:fg[NORMAL] where NORMAL is the state; could not parse \"%s\""
),
                     str);
        return NULL((void*)0);
      }

    tmp = g_strndup (bracket + 1, end_bracket - bracket - 1);
    state = meta_ctk_state_from_string (tmp);
    if (((int) state) == -1)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Did not understand state \"%s\" in color specification")dgettext ("croma", "Did not understand state \"%s\" in color specification"
),
                     tmp);
        g_free (tmp);
        return NULL((void*)0);
      }
    g_free (tmp);

    tmp = g_strndup (str + 4, bracket - str - 4);
    component = meta_color_component_from_string (tmp);
    if (component == META_CTK_COLOR_LAST)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Did not understand color component \"%s\" in color specification")dgettext ("croma", "Did not understand color component \"%s\" in color specification"
),
                     tmp);
        g_free (tmp);
        return NULL((void*)0);
      }
    g_free (tmp);

    spec = meta_color_spec_new (META_COLOR_SPEC_CTK);
    spec->data.ctk.state = state;
    spec->data.ctk.component = component;
    g_assert (spec->data.ctk.component < META_CTK_COLOR_LAST)do { if (spec->data.ctk.component < META_CTK_COLOR_LAST
) ; else g_assertion_message_expr ("croma", "ui/theme.c", 1520
, ((const char*) (__func__)), "spec->data.ctk.component < META_CTK_COLOR_LAST"
); } while (0);
  }
else if (strncmp (str, "blend/", 6) == 0)
  {
    /* blend */
    char **split;
    double alpha;
    char *end;
    MetaColorSpec *fg;
    MetaColorSpec *bg;

    split = g_strsplit (str, "/", 4);

    if (split[0] == NULL((void*)0) || split[1] == NULL((void*)0) ||
        split[2] == NULL((void*)0) || split[3] == NULL((void*)0))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the format")dgettext ("croma", "Blend format is \"blend/bg_color/fg_color/alpha\", \"%s\" does not fit the format"
),
                     str);
        g_strfreev (split);
        return NULL((void*)0);
      }

    alpha = g_ascii_strtod (split[3], &end);
    if (end == split[3])
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Could not parse alpha value \"%s\" in blended color")dgettext ("croma", "Could not parse alpha value \"%s\" in blended color"
),
                     split[3]);
        g_strfreev (split);
        return NULL((void*)0);
      }

    if (alpha < (0.0 - 1e6) || alpha > (1.0 + 1e6))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Alpha value \"%s\" in blended color is not between 0.0 and 1.0")dgettext ("croma", "Alpha value \"%s\" in blended color is not between 0.0 and 1.0"
),
                     split[3]);
        g_strfreev (split);
        return NULL((void*)0);
      }

    fg = NULL((void*)0);
    bg = NULL((void*)0);

    bg = meta_color_spec_new_from_string (split[1], err);
    if (bg == NULL((void*)0))
      {
        g_strfreev (split);
        return NULL((void*)0);
      }

    fg = meta_color_spec_new_from_string (split[2], err);
    if (fg == NULL((void*)0))
      {
        meta_color_spec_free (bg);
        g_strfreev (split);
        return NULL((void*)0);
      }

    g_strfreev (split);

    spec = meta_color_spec_new (META_COLOR_SPEC_BLEND);
    spec->data.blend.alpha = alpha;
    spec->data.blend.background = bg;
    spec->data.blend.foreground = fg;
  }
else if (strncmp (str, "shade/", 6) == 0)
  {
    /* shade */
    char **split;
    double factor;
    char *end;
    MetaColorSpec *base;

    split = g_strsplit (str, "/", 3);

    if (split[0] == NULL((void*)0) || split[1] == NULL((void*)0) ||
        split[2] == NULL((void*)0))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format")dgettext ("croma", "Shade format is \"shade/base_color/factor\", \"%s\" does not fit the format"
),
                     str);
        g_strfreev (split);
        return NULL((void*)0);
      }

    factor = g_ascii_strtod (split[2], &end);
    if (end == split[2])
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Could not parse shade factor \"%s\" in shaded color")dgettext ("croma", "Could not parse shade factor \"%s\" in shaded color"
),
                     split[2]);
        g_strfreev (split);
        return NULL((void*)0);
      }

    if (factor < (0.0 - 1e6))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Shade factor \"%s\" in shaded color is negative")dgettext ("croma", "Shade factor \"%s\" in shaded color is negative"
),
                     split[2]);
        g_strfreev (split);
        return NULL((void*)0);
      }

    base = NULL((void*)0);

    base = meta_color_spec_new_from_string (split[1], err);
    if (base == NULL((void*)0))
      {
        g_strfreev (split);
        return NULL((void*)0);
      }

    g_strfreev (split);

    spec = meta_color_spec_new (META_COLOR_SPEC_SHADE);
    spec->data.shade.factor = factor;
    spec->data.shade.base = base;
  }
else
  {
    spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);

    if (!cdk_rgba_parse (&spec->data.basic.color, str))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Could not parse color \"%s\"")dgettext ("croma", "Could not parse color \"%s\""),
                     str);
        meta_color_spec_free (spec);
        return NULL((void*)0);
      }
  }

g_assert (spec)do { if (spec) ; else g_assertion_message_expr ("croma", "ui/theme.c"
, 1662, ((const char*) (__func__)), "spec"); } while (0);

return spec;
1665}

1667MetaColorSpec*
1668meta_color_spec_new_ctk (MetaCtkColorComponent component,
                       CtkStateFlags         state)
1670{
MetaColorSpec *spec;

spec = meta_color_spec_new (META_COLOR_SPEC_CTK);
1
Calling 'meta_color_spec_new'→

spec->data.ctk.component = component;
spec->data.ctk.state = state;

return spec;
1679}

1681static void
1682get_background_color_real (CtkStyleContext *context,
                         CtkStateFlags    state,
                         CdkRGBA         *color)
1685{
CdkRGBA *c;

g_return_if_fail (color != NULL)do { if ((color != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "color != NULL"); return
; } } while (0);
g_return_if_fail (CTK_IS_STYLE_CONTEXT (context))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((context)); GType __t = ((ctk_style_context_get_type ()))
; gboolean __r; if (!__inst) __r = (0); else if (__inst->g_class
 && __inst->g_class->g_type == __t) __r = (!(0)
); else __r = g_type_check_instance_is_a (__inst, __t); __r; }
)))))) { } else { g_return_if_fail_warning ("croma", ((const char
*) (__func__)), "CTK_IS_STYLE_CONTEXT (context)"); return; } }
 while (0);

ctk_style_context_get (context,
                       state,
                       "background-color", &c,
                       NULL((void*)0));

*color = *c;
cdk_rgba_free (c);
1698}

1700static void
1701get_background_color (CtkStyleContext *context,
                    CtkStateFlags    state,
                    CdkRGBA         *color)
1704{
CdkRGBA empty = { 0.0, 0.0, 0.0, 0.0 };
CdkRGBA rgba;

get_background_color_real (context, state, &rgba);

if (cdk_rgba_equal (&rgba, &empty))
  {
    CtkWidget *toplevel;
    CtkStyleContext *tmp;

    toplevel = ctk_window_new (CTK_WINDOW_TOPLEVEL);
    tmp = ctk_widget_get_style_context (toplevel);

    get_background_color_real (tmp, state, &rgba);

    ctk_widget_destroy (toplevel);
  }

*color = rgba;
1724}

1726/* Based on set_color() in ctkstyle.c */
1727#define LIGHTNESS_MULT1.3 1.3
1728#define DARKNESS_MULT0.7  0.7
1729void
1730meta_ctk_style_get_light_color (CtkStyleContext *style,
                              CtkStateFlags    state,
                              CdkRGBA         *color)
1733{
get_background_color (style, state, color);
ctk_style_shade (color, color, LIGHTNESS_MULT1.3);
1736}

1738void
1739meta_ctk_style_get_dark_color (CtkStyleContext *style,
                             CtkStateFlags    state,
                             CdkRGBA         *color)
1742{
get_background_color (style, state, color);
ctk_style_shade (color, color, DARKNESS_MULT0.7);
1745}

1747static void
1748meta_set_color_from_style (CdkRGBA               *color,
                         CtkStyleContext       *context,
                         CtkStateFlags          state,
                         MetaCtkColorComponent  component)
1752{
CdkRGBA other;

/* Add background class to context to get the correct colors from the CTK+
   theme instead of white text over black background. */
ctk_style_context_add_class (context, CTK_STYLE_CLASS_BACKGROUND"background");

switch (component)
  {
  case META_CTK_COLOR_BG:
  case META_CTK_COLOR_BASE:
    get_background_color (context, state, color);
    break;
  case META_CTK_COLOR_FG:
  case META_CTK_COLOR_TEXT:
    ctk_style_context_get_color (context, state, color);
    break;
  case META_CTK_COLOR_TEXT_AA:
    ctk_style_context_get_color (context, state, color);
    meta_set_color_from_style (&other, context, state, META_CTK_COLOR_BASE);

    color->red = (color->red + other.red) / 2;
    color->green = (color->green + other.green) / 2;
    color->blue = (color->blue + other.blue) / 2;
    break;
  case META_CTK_COLOR_MID:
    meta_ctk_style_get_light_color (context, state, color);
    meta_ctk_style_get_dark_color (context, state, &other);

    color->red = (color->red + other.red) / 2;
    color->green = (color->green + other.green) / 2;
    color->blue = (color->blue + other.blue) / 2;
    break;
  case META_CTK_COLOR_LIGHT:
    meta_ctk_style_get_light_color (context, state, color);
    break;
  case META_CTK_COLOR_DARK:
    meta_ctk_style_get_dark_color (context, state, color);
    break;
  case META_CTK_COLOR_LAST:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 1792, (
(const char*) (__func__)), ((void*)0)); } while (0);
    break;
  }
1795}

1797static void
1798meta_set_custom_color_from_style (CdkRGBA         *color,
                                CtkStyleContext *context,
                                char            *color_name,
                                MetaColorSpec   *fallback)
1802{
if (!ctk_style_context_lookup_color (context, color_name, color))
  meta_color_spec_render (fallback, context, color);
1805}

1807void
1808meta_color_spec_render (MetaColorSpec *spec,
                      CtkStyleContext *style,
                      CdkRGBA         *color)
1811{
g_return_if_fail (spec != NULL)do { if ((spec != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "spec != NULL"); return
; } } while (0);

g_return_if_fail (CTK_IS_STYLE_CONTEXT (style))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((style)); GType __t = ((ctk_style_context_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("croma", ((const char*) (__func__
)), "CTK_IS_STYLE_CONTEXT (style)"); return; } } while (0);

switch (spec->type)
  {
  case META_COLOR_SPEC_BASIC:
    *color = spec->data.basic.color;
    break;

  case META_COLOR_SPEC_CTK:
    meta_set_color_from_style (color,
                               style,
                               spec->data.ctk.state,
                               spec->data.ctk.component);
    break;

  case META_COLOR_SPEC_CTK_CUSTOM:
    meta_set_custom_color_from_style (color,
                                      style,
                                      spec->data.ctkcustom.color_name,
                                      spec->data.ctkcustom.fallback);
    break;

  case META_COLOR_SPEC_BLEND:
    {
      CdkRGBA bg, fg;

      meta_color_spec_render (spec->data.blend.background, style, &bg);
      meta_color_spec_render (spec->data.blend.foreground, style, &fg);

      color_composite (&bg, &fg, spec->data.blend.alpha,
                       &spec->data.blend.color);

      *color = spec->data.blend.color;
    }
    break;

  case META_COLOR_SPEC_SHADE:
    {
      meta_color_spec_render (spec->data.shade.base, style,
                              &spec->data.shade.color);

      ctk_style_shade (&spec->data.shade.color,
                       &spec->data.shade.color, spec->data.shade.factor);

      *color = spec->data.shade.color;
    }
    break;
  }
1862}

1864/**
* Represents an operation as a string.
*
* \param type  an operation, such as addition
* \return  a string, such as "+"
*/
1870static const char*
1871op_name (PosOperatorType type)
1872{
switch (type)
  {
  case POS_OP_ADD:
    return "+";
  case POS_OP_SUBTRACT:
    return "-";
  case POS_OP_MULTIPLY:
    return "*";
  case POS_OP_DIVIDE:
    return "/";
  case POS_OP_MOD:
    return "%";
  case POS_OP_MAX:
    return "`max`";
  case POS_OP_MIN:
    return "`min`";
  case POS_OP_NONE:
    break;
  }

return "<unknown>";
1894}

1896/**
* Parses a string and returns an operation.
*
* \param p  a pointer into a string representing an operation; part of an
*           expression somewhere, so not null-terminated
* \param len  set to the length of the string found. Set to 0 if none is.
* \return  the operation found. If none was, returns POS_OP_NONE.
*/
1904static PosOperatorType
1905op_from_string (const char *p,
              int        *len)
1907{
*len = 0;

switch (*p)
  {
  case '+':
    *len = 1;
    return POS_OP_ADD;
  case '-':
    *len = 1;
    return POS_OP_SUBTRACT;
  case '*':
    *len = 1;
    return POS_OP_MULTIPLY;
  case '/':
    *len = 1;
    return POS_OP_DIVIDE;
  case '%':
    *len = 1;
    return POS_OP_MOD;

  case '`':
    if (strncmp (p, "`max`", 5) == 0)
      {
        *len = 5;
        return POS_OP_MAX;
      }
    else if (strncmp (p, "`min`", 5) == 0)
      {
        *len = 5;
        return POS_OP_MIN;
      }
  }

return POS_OP_NONE;
1942}

1944/**
* Frees an array of tokens. All the tokens and their associated memory
* will be freed.
*
* \param tokens  an array of tokens to be freed
* \param n_tokens  how many tokens are in the array.
*/
1951static void
1952free_tokens (PosToken *tokens,
           int       n_tokens)
1954{
int i;

/* n_tokens can be 0 since tokens may have been allocated more than
 * it was initialized
 */

for (i = 0; i < n_tokens; i++)
  if (tokens[i].type == POS_TOKEN_VARIABLE)
    g_free (tokens[i].d.v.name);

g_free (tokens);
1966}

1968/**
* Tokenises a number in an expression.
*
* \param p  a pointer into a string representing an operation; part of an
*           expression somewhere, so not null-terminated
* \param end_return  set to a pointer to the end of the number found; but
*                    not updated if no number was found at all
* \param next  set to either an integer or a float token
* \param[out] err  set to the problem if there was a problem
* \return TRUE if a valid number was found, FALSE otherwise (and "err" will
*         have been set)
*
* \bug The "while (*start)..." part: what's wrong with strchr-ish things?
* \bug The name is wrong: it doesn't parse anything.
* \ingroup tokenizer
*/
1984static gboolean
1985parse_number (const char  *p,
            const char **end_return,
            PosToken    *next,
            GError     **err)
1989{
const char *start = p;
char *end;
gboolean is_float;
char *num_str;

while (*p && (*p == '.' || g_ascii_isdigit (*p)((g_ascii_table[(guchar) (*p)] & G_ASCII_DIGIT) != 0)))
  ++p;

if (p == start)
  {
    char buf[7] = { '\0' };
    buf[g_unichar_to_utf8 (g_utf8_get_char (p), buf)] = '\0';
    g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_BAD_CHARACTER,
                 _("Coordinate expression contains character '%s' which is not allowed")dgettext ("croma", "Coordinate expression contains character '%s' which is not allowed"
),
                 buf);
    return FALSE(0);
  }

*end_return = p;

/* we need this to exclude floats like "1e6" */
num_str = g_strndup (start, p - start);
start = num_str;
is_float = FALSE(0);
while (*start)
  {
    if (*start == '.')
      is_float = TRUE(!(0));
    ++start;
  }

if (is_float)
  {
    next->type = POS_TOKEN_DOUBLE;
    next->d.d.val = g_ascii_strtod (num_str, &end);

    if (end == num_str)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression contains floating point number '%s' which could not be parsed")dgettext ("croma", "Coordinate expression contains floating point number '%s' which could not be parsed"
),
                     num_str);
        g_free (num_str);
        return FALSE(0);
      }
  }
else
  {
    next->type = POS_TOKEN_INT;
    next->d.i.val = strtol (num_str, &end, 10);
    if (end == num_str)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression contains integer '%s' which could not be parsed")dgettext ("croma", "Coordinate expression contains integer '%s' which could not be parsed"
),
                     num_str);
        g_free (num_str);
        return FALSE(0);
      }
  }

g_free (num_str);

g_assert (next->type == POS_TOKEN_INT || next->type == POS_TOKEN_DOUBLE)do { if (next->type == POS_TOKEN_INT || next->type == POS_TOKEN_DOUBLE
) ; else g_assertion_message_expr ("croma", "ui/theme.c", 2054
, ((const char*) (__func__)), "next->type == POS_TOKEN_INT || next->type == POS_TOKEN_DOUBLE"
); } while (0);

return TRUE(!(0));
2057}

2059/**
* Whether a variable can validly appear as part of the name of a variable.
*/
2062#define IS_VARIABLE_CHAR(c)(((g_ascii_table[(guchar) ((c))] & G_ASCII_ALPHA) != 0) ||
 (c) == '_') (g_ascii_isalpha ((c))((g_ascii_table[(guchar) ((c))] & G_ASCII_ALPHA) != 0) || (c) == '_')

2064#if 0
2065static void
2066debug_print_tokens (PosToken *tokens,
                  int       n_tokens)
2068{
int i;

for (i = 0; i < n_tokens; i++)
  {
    PosToken *t = &tokens[i];

    g_print (" ");

    switch (t->type)
      {
      case POS_TOKEN_INT:
        g_print ("\"%d\"", t->d.i.val);
        break;
      case POS_TOKEN_DOUBLE:
        g_print ("\"%g\"", t->d.d.val);
        break;
      case POS_TOKEN_OPEN_PAREN:
        g_print ("\"(\"");
        break;
      case POS_TOKEN_CLOSE_PAREN:
        g_print ("\")\"");
        break;
      case POS_TOKEN_VARIABLE:
        g_print ("\"%s\"", t->d.v.name);
        break;
      case POS_TOKEN_OPERATOR:
        g_print ("\"%s\"", op_name (t->d.o.op));
        break;
      }
  }

g_print ("\n");
2101}
2102#endif

2104/**
* Tokenises an expression.
*
* \param      expr        The expression
* \param[out] tokens_p    The resulting tokens
* \param[out] n_tokens_p  The number of resulting tokens
* \param[out] err  set to the problem if there was a problem
*
* \return  True if the expression was successfully tokenised; false otherwise.
*
* \ingroup tokenizer
*/
2116static gboolean
2117pos_tokenize (const char  *expr,
            PosToken   **tokens_p,
            int         *n_tokens_p,
            GError     **err)
2121{
PosToken *tokens;
int n_tokens;
int allocated;
const char *p;

*tokens_p = NULL((void*)0);
*n_tokens_p = 0;

allocated = 3;
n_tokens = 0;
tokens = g_new (PosToken, allocated)((PosToken *) g_malloc_n ((allocated), sizeof (PosToken)));

p = expr;
while (*p)
  {
    PosToken *next;
    int len;

    if (n_tokens == allocated)
      {
        allocated *= 2;
        tokens = g_renew (PosToken, tokens, allocated)((PosToken *) g_realloc_n (tokens, (allocated), sizeof (PosToken
)));
      }

    next = &tokens[n_tokens];

    switch (*p)
      {
      case '*':
      case '/':
      case '+':
      case '-': /* negative numbers aren't allowed so this is easy */
      case '%':
      case '`':
        next->type = POS_TOKEN_OPERATOR;
        next->d.o.op = op_from_string (p, &len);
        if (next->d.o.op != POS_OP_NONE)
          {
            ++n_tokens;
            p = p + (len - 1); /* -1 since we ++p later */
          }
        else
          {
            g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                         META_THEME_ERROR_FAILED,
                         _("Coordinate expression contained unknown operator at the start of this text: \"%s\"")dgettext ("croma", "Coordinate expression contained unknown operator at the start of this text: \"%s\""
),
                         p);

            goto error;
          }
        break;

      case '(':
        next->type = POS_TOKEN_OPEN_PAREN;
        ++n_tokens;
        break;

      case ')':
        next->type = POS_TOKEN_CLOSE_PAREN;
        ++n_tokens;
        break;

      case ' ':
      case '\t':
      case '\n':
        break;

      default:
        if (IS_VARIABLE_CHAR (*p)(((g_ascii_table[(guchar) ((*p))] & G_ASCII_ALPHA) != 0) ||
 (*p) == '_'))
          {
            /* Assume variable */
            const char *start = p;
            while (*p && IS_VARIABLE_CHAR (*p)(((g_ascii_table[(guchar) ((*p))] & G_ASCII_ALPHA) != 0) ||
 (*p) == '_'))
              ++p;
            g_assert (p != start)do { if (p != start) ; else g_assertion_message_expr ("croma"
, "ui/theme.c", 2196, ((const char*) (__func__)), "p != start"
); } while (0);
            next->type = POS_TOKEN_VARIABLE;
            next->d.v.name = g_strndup (start, p - start);
            ++n_tokens;
            --p; /* since we ++p again at the end of while loop */
          }
        else
          {
            /* Assume number */
            const char *end;

            if (!parse_number (p, &end, next, err))
              goto error;

            ++n_tokens;
            p = end - 1; /* -1 since we ++p again at the end of while loop */
          }

        break;
      }

    ++p;
  }

if (n_tokens == 0)
  {
    g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_FAILED,
                 _("Coordinate expression was empty or not understood")dgettext ("croma", "Coordinate expression was empty or not understood"
));

    goto error;
  }

*tokens_p = tokens;
*n_tokens_p = n_tokens;

return TRUE(!(0));

error:
g_assert (err == NULL || *err != NULL)do { if (err == ((void*)0) || *err != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 2235, ((const char*) (__func__)), "err == NULL || *err != NULL"
); } while (0);

free_tokens (tokens, n_tokens);
return FALSE(0);
2239}

2241/**
* The type of a PosExpr: either integer, double, or an operation.
* \ingroup parser
*/
2245typedef enum
2246{
POS_EXPR_INT,
POS_EXPR_DOUBLE,
POS_EXPR_OPERATOR
2250} PosExprType;

2252/**
* Type and value of an expression in a parsed sequence. We don't
* keep expressions in a tree; if this is of type POS_EXPR_OPERATOR,
* the arguments of the operator will be in the array positions
* immediately preceding and following this operator; they cannot
* themselves be operators.
*
* \bug operator is char; it should really be of PosOperatorType.
* \ingroup parser
*/
2262typedef struct
2263{
PosExprType type;
union
{
  double double_val;
  int int_val;
  char operator;
} d;
2271} PosExpr;

2273#if 0
2274static void
2275debug_print_exprs (PosExpr *exprs,
                 int      n_exprs)
2277{
int i;

for (i = 0; i < n_exprs; i++)
  {
    switch (exprs[i].type)
      {
      case POS_EXPR_INT:
        g_print (" %d", exprs[i].d.int_val);
        break;
      case POS_EXPR_DOUBLE:
        g_print (" %g", exprs[i].d.double_val);
        break;
      case POS_EXPR_OPERATOR:
        g_print (" %s", op_name (exprs[i].d.operator));
        break;
      }
  }
g_print ("\n");
2296}
2297#endif

2299static gboolean
2300do_operation (PosExpr *a,
            PosExpr *b,
            PosOperatorType op,
            GError **err)
2304{
/* Promote types to double if required */
if (a->type == POS_EXPR_DOUBLE ||
    b->type == POS_EXPR_DOUBLE)
  {
    if (a->type != POS_EXPR_DOUBLE)
      {
        a->type = POS_EXPR_DOUBLE;
        a->d.double_val = a->d.int_val;
      }
    if (b->type != POS_EXPR_DOUBLE)
      {
        b->type = POS_EXPR_DOUBLE;
        b->d.double_val = b->d.int_val;
      }
  }

g_assert (a->type == b->type)do { if (a->type == b->type) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 2321, ((const char*) (__func__)), "a->type == b->type"
); } while (0);

if (a->type == POS_EXPR_INT)
  {
    switch (op)
      {
      case POS_OP_MULTIPLY:
        a->d.int_val = a->d.int_val * b->d.int_val;
        break;
      case POS_OP_DIVIDE:
        if (b->d.int_val == 0)
          {
            g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                         META_THEME_ERROR_DIVIDE_BY_ZERO,
                         _("Coordinate expression results in division by zero")dgettext ("croma", "Coordinate expression results in division by zero"
));
            return FALSE(0);
          }
        a->d.int_val = a->d.int_val / b->d.int_val;
        break;
      case POS_OP_MOD:
        if (b->d.int_val == 0)
          {
            g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                         META_THEME_ERROR_DIVIDE_BY_ZERO,
                         _("Coordinate expression results in division by zero")dgettext ("croma", "Coordinate expression results in division by zero"
));
            return FALSE(0);
          }
        a->d.int_val = a->d.int_val % b->d.int_val;
        break;
      case POS_OP_ADD:
        a->d.int_val = a->d.int_val + b->d.int_val;
        break;
      case POS_OP_SUBTRACT:
        a->d.int_val = a->d.int_val - b->d.int_val;
        break;
      case POS_OP_MAX:
        a->d.int_val = MAX (a->d.int_val, b->d.int_val)(((a->d.int_val) > (b->d.int_val)) ? (a->d.int_val
) : (b->d.int_val));
        break;
      case POS_OP_MIN:
        a->d.int_val = MIN (a->d.int_val, b->d.int_val)(((a->d.int_val) < (b->d.int_val)) ? (a->d.int_val
) : (b->d.int_val));
        break;
      case POS_OP_NONE:
        g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2363, (
(const char*) (__func__)), ((void*)0)); } while (0);
        break;
      }
  }
else if (a->type == POS_EXPR_DOUBLE)
  {
    switch (op)
      {
      case POS_OP_MULTIPLY:
        a->d.double_val = a->d.double_val * b->d.double_val;
        break;
      case POS_OP_DIVIDE:
        if (b->d.double_val == 0.0)
          {
            g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                         META_THEME_ERROR_DIVIDE_BY_ZERO,
                         _("Coordinate expression results in division by zero")dgettext ("croma", "Coordinate expression results in division by zero"
));
            return FALSE(0);
          }
        a->d.double_val = a->d.double_val / b->d.double_val;
        break;
      case POS_OP_MOD:
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_MOD_ON_FLOAT,
                     _("Coordinate expression tries to use mod operator on a floating-point number")dgettext ("croma", "Coordinate expression tries to use mod operator on a floating-point number"
));
        return FALSE(0);
      case POS_OP_ADD:
        a->d.double_val = a->d.double_val + b->d.double_val;
        break;
      case POS_OP_SUBTRACT:
        a->d.double_val = a->d.double_val - b->d.double_val;
        break;
      case POS_OP_MAX:
        a->d.double_val = MAX (a->d.double_val, b->d.double_val)(((a->d.double_val) > (b->d.double_val)) ? (a->d.
double_val) : (b->d.double_val));
        break;
      case POS_OP_MIN:
        a->d.double_val = MIN (a->d.double_val, b->d.double_val)(((a->d.double_val) < (b->d.double_val)) ? (a->d.
double_val) : (b->d.double_val));
        break;
      case POS_OP_NONE:
        g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2402, (
(const char*) (__func__)), ((void*)0)); } while (0);
        break;
      }
  }
else
  g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2407, (
(const char*) (__func__)), ((void*)0)); } while (0);

return TRUE(!(0));
2410}

2412static gboolean
2413do_operations (PosExpr *exprs,
             int     *n_exprs,
             int      precedence,
             GError **err)
2417{
int i;

2420#if 0
g_print ("Doing prec %d ops on %d exprs\n", precedence, *n_exprs);
debug_print_exprs (exprs, *n_exprs);
2423#endif

i = 1;
while (i < *n_exprs)
  {
    gboolean compress;

    /* exprs[i-1] first operand
     * exprs[i]   operator
     * exprs[i+1] second operand
     *
     * we replace first operand with result of mul/div/mod,
     * or skip over operator and second operand if we have
     * an add/subtract
     */

    if (exprs[i-1].type == POS_EXPR_OPERATOR)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression has an operator \"%s\" where an operand was expected")dgettext ("croma", "Coordinate expression has an operator \"%s\" where an operand was expected"
),
                     op_name (exprs[i-1].d.operator));
        return FALSE(0);
      }

    if (exprs[i].type != POS_EXPR_OPERATOR)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression had an operand where an operator was expected")dgettext ("croma", "Coordinate expression had an operand where an operator was expected"
));
        return FALSE(0);
      }

    if (i == (*n_exprs - 1))
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression ended with an operator instead of an operand")dgettext ("croma", "Coordinate expression ended with an operator instead of an operand"
));
        return FALSE(0);
      }

    g_assert ((i+1) < *n_exprs)do { if ((i+1) < *n_exprs) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 2464, ((const char*) (__func__)), "(i+1) < *n_exprs"
); } while (0);

    if (exprs[i+1].type == POS_EXPR_OPERATOR)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression has operator \"%c\" following operator \"%c\" with no operand in between")dgettext ("croma", "Coordinate expression has operator \"%c\" following operator \"%c\" with no operand in between"
),
                     exprs[i+1].d.operator,
                     exprs[i].d.operator);
        return FALSE(0);
      }

    compress = FALSE(0);

    switch (precedence)
      {
      case 2:
        switch (exprs[i].d.operator)
          {
          case POS_OP_DIVIDE:
          case POS_OP_MOD:
          case POS_OP_MULTIPLY:
            compress = TRUE(!(0));
            if (!do_operation (&exprs[i-1], &exprs[i+1],
                               exprs[i].d.operator,
                               err))
              return FALSE(0);
            break;
          }
        break;
      case 1:
        switch (exprs[i].d.operator)
          {
          case POS_OP_ADD:
          case POS_OP_SUBTRACT:
            compress = TRUE(!(0));
            if (!do_operation (&exprs[i-1], &exprs[i+1],
                               exprs[i].d.operator,
                               err))
              return FALSE(0);
            break;
          }
        break;
        /* I have no rationale at all for making these low-precedence */
      case 0:
        switch (exprs[i].d.operator)
          {
          case POS_OP_MAX:
          case POS_OP_MIN:
            compress = TRUE(!(0));
            if (!do_operation (&exprs[i-1], &exprs[i+1],
                               exprs[i].d.operator,
                               err))
              return FALSE(0);
            break;
          }
        break;
      }

    if (compress)
      {
        /* exprs[i-1] first operand (now result)
         * exprs[i]   operator
         * exprs[i+1] second operand
         * exprs[i+2] new operator
         *
         * we move new operator just after first operand
         */
        if ((i+2) < *n_exprs)
          {
            memmove (&exprs[i], &exprs[i+2],
                       sizeof (PosExpr) * (*n_exprs - i - 2));
          }

        *n_exprs -= 2;
      }
    else
      {
        /* Skip operator and next operand */
        i += 2;
      }
  }

return TRUE(!(0));
2548}

2550/**
* There is a predefined set of variables which can appear in an expression.
* Here we take a token representing a variable, and return the current value
* of that variable in a particular environment.
* (The value is always an integer.)
*
* There are supposedly some circumstances in which this function can be
* called from outside Croma, in which case env->theme will be NULL, and
* therefore we can't use it to find out quark values, so we do the comparison
* using strcmp, which is slower.
*
* \param t  The token representing a variable
* \param[out] result  The value of that variable; not set if the token did
*                     not represent a known variable
* \param env  The environment within which t should be evaluated
* \param[out] err  set to the problem if there was a problem
*
* \return true if we found the variable asked for, false if we didn't
*
* \bug shouldn't t be const?
* \bug we should perhaps consider some sort of lookup arrangement into an
*      array; also, the duplication of code is unlovely; perhaps using glib
*      string hashes instead of quarks would fix both problems?
* \ingroup parser
*/
2575static gboolean
2576pos_eval_get_variable (PosToken                  *t,
                     int                       *result,
                     const MetaPositionExprEnv *env,
                     GError                   **err)
2580{
if (env->theme)
  {
    if (t->d.v.name_quark == env->theme->quark_width)
      *result = env->rect.width;
    else if (t->d.v.name_quark == env->theme->quark_height)
      *result = env->rect.height;
    else if (env->object_width >= 0 &&
             t->d.v.name_quark == env->theme->quark_object_width)
      *result = env->object_width;
    else if (env->object_height >= 0 &&
             t->d.v.name_quark == env->theme->quark_object_height)
      *result = env->object_height;
    else if (t->d.v.name_quark == env->theme->quark_left_width)
      *result = env->left_width;
    else if (t->d.v.name_quark == env->theme->quark_right_width)
      *result = env->right_width;
    else if (t->d.v.name_quark == env->theme->quark_top_height)
      *result = env->top_height;
    else if (t->d.v.name_quark == env->theme->quark_bottom_height)
      *result = env->bottom_height;
    else if (t->d.v.name_quark == env->theme->quark_mini_icon_width)
      *result = env->mini_icon_width;
    else if (t->d.v.name_quark == env->theme->quark_mini_icon_height)
      *result = env->mini_icon_height;
    else if (t->d.v.name_quark == env->theme->quark_icon_width)
      *result = env->icon_width;
    else if (t->d.v.name_quark == env->theme->quark_icon_height)
      *result = env->icon_height;
    else if (t->d.v.name_quark == env->theme->quark_title_width)
      *result = env->title_width;
    else if (t->d.v.name_quark == env->theme->quark_title_height)
      *result = env->title_height;
    else if (t->d.v.name_quark == env->theme->quark_frame_x_center)
      *result = env->frame_x_center;
    else if (t->d.v.name_quark == env->theme->quark_frame_y_center)
      *result = env->frame_y_center;
    else
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_UNKNOWN_VARIABLE,
                     _("Coordinate expression had unknown variable or constant \"%s\"")dgettext ("croma", "Coordinate expression had unknown variable or constant \"%s\""
),
                     t->d.v.name);
        return FALSE(0);
      }
  }
else
  {
    if (strcmp (t->d.v.name, "width") == 0)
      *result = env->rect.width;
    else if (strcmp (t->d.v.name, "height") == 0)
      *result = env->rect.height;
    else if (env->object_width >= 0 &&
             strcmp (t->d.v.name, "object_width") == 0)
      *result = env->object_width;
    else if (env->object_height >= 0 &&
             strcmp (t->d.v.name, "object_height") == 0)
      *result = env->object_height;
    else if (strcmp (t->d.v.name, "left_width") == 0)
      *result = env->left_width;
    else if (strcmp (t->d.v.name, "right_width") == 0)
      *result = env->right_width;
    else if (strcmp (t->d.v.name, "top_height") == 0)
      *result = env->top_height;
    else if (strcmp (t->d.v.name, "bottom_height") == 0)
      *result = env->bottom_height;
    else if (strcmp (t->d.v.name, "mini_icon_width") == 0)
      *result = env->mini_icon_width;
    else if (strcmp (t->d.v.name, "mini_icon_height") == 0)
      *result = env->mini_icon_height;
    else if (strcmp (t->d.v.name, "icon_width") == 0)
      *result = env->icon_width;
    else if (strcmp (t->d.v.name, "icon_height") == 0)
      *result = env->icon_height;
    else if (strcmp (t->d.v.name, "title_width") == 0)
      *result = env->title_width;
    else if (strcmp (t->d.v.name, "title_height") == 0)
      *result = env->title_height;
    else if (strcmp (t->d.v.name, "frame_x_center") == 0)
      *result = env->frame_x_center;
    else if (strcmp (t->d.v.name, "frame_y_center") == 0)
      *result = env->frame_y_center;
    else
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_UNKNOWN_VARIABLE,
                     _("Coordinate expression had unknown variable or constant \"%s\"")dgettext ("croma", "Coordinate expression had unknown variable or constant \"%s\""
),
                     t->d.v.name);
        return FALSE(0);
      }
  }

return TRUE(!(0));
2673}

2675/**
* Evaluates a sequence of tokens within a particular environment context,
* and returns the current value. May recur if parantheses are found.
*
* \param tokens  A list of tokens to evaluate.
* \param n_tokens  How many tokens are in the list.
* \param env  The environment context in which to evaluate the expression.
* \param[out] result  The current value of the expression
*
* \bug Yes, we really do reparse the expression every time it's evaluated.
*      We should keep the parse tree around all the time and just
*      run the new values through it.
* \ingroup parser
*/
2689static gboolean
2690pos_eval_helper (PosToken                   *tokens,
               int                         n_tokens,
               const MetaPositionExprEnv  *env,
               PosExpr                    *result,
               GError                    **err)
2695{
/* Lazy-ass hardcoded limit on number of terms in expression */
2697#define MAX_EXPRS32 32
int paren_level;
int first_paren;
int i;
PosExpr exprs[MAX_EXPRS32];
int n_exprs;
int precedence;

/* Our first goal is to get a list of PosExpr, essentially
 * substituting variables and handling parentheses.
 */

first_paren = 0;
paren_level = 0;
n_exprs = 0;
for (i = 0; i < n_tokens; i++)
  {
    PosToken *t = &tokens[i];

    if (n_exprs >= MAX_EXPRS32)
      {
        g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Coordinate expression parser overflowed its buffer.")dgettext ("croma", "Coordinate expression parser overflowed its buffer."
));
        return FALSE(0);
      }

    if (paren_level == 0)
      {
        switch (t->type)
          {
          case POS_TOKEN_INT:
            exprs[n_exprs].type = POS_EXPR_INT;
            exprs[n_exprs].d.int_val = t->d.i.val;
            ++n_exprs;
            break;

          case POS_TOKEN_DOUBLE:
            exprs[n_exprs].type = POS_EXPR_DOUBLE;
            exprs[n_exprs].d.double_val = t->d.d.val;
            ++n_exprs;
            break;

          case POS_TOKEN_OPEN_PAREN:
            ++paren_level;
            if (paren_level == 1)
              first_paren = i;
            break;

          case POS_TOKEN_CLOSE_PAREN:
            g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                         META_THEME_ERROR_BAD_PARENS,
                         _("Coordinate expression had a close parenthesis with no open parenthesis")dgettext ("croma", "Coordinate expression had a close parenthesis with no open parenthesis"
));
            return FALSE(0);

          case POS_TOKEN_VARIABLE:
            exprs[n_exprs].type = POS_EXPR_INT;

            /* FIXME we should just dump all this crap
             * in a hash, maybe keep width/height out
             * for optimization purposes
             */
            if (!pos_eval_get_variable (t, &exprs[n_exprs].d.int_val, env, err))
              return FALSE(0);

            ++n_exprs;
            break;

          case POS_TOKEN_OPERATOR:
            exprs[n_exprs].type = POS_EXPR_OPERATOR;
            exprs[n_exprs].d.operator = t->d.o.op;
            ++n_exprs;
            break;
          }
      }
    else
      {
        g_assert (paren_level > 0)do { if (paren_level > 0) ; else g_assertion_message_expr (
"croma", "ui/theme.c", 2774, ((const char*) (__func__)), "paren_level > 0"
); } while (0);

        switch (t->type)
          {
          case POS_TOKEN_INT:
          case POS_TOKEN_DOUBLE:
          case POS_TOKEN_VARIABLE:
          case POS_TOKEN_OPERATOR:
            break;

          case POS_TOKEN_OPEN_PAREN:
            ++paren_level;
            break;

          case POS_TOKEN_CLOSE_PAREN:
            if (paren_level == 1)
              {
                /* We closed a toplevel paren group, so recurse */
                if (!pos_eval_helper (&tokens[first_paren+1],
                                      i - first_paren - 1,
                                      env,
                                      &exprs[n_exprs],
                                      err))
                  return FALSE(0);

                ++n_exprs;
              }

            --paren_level;
            break;

          }
      }
  }

if (paren_level > 0)
  {
    g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_BAD_PARENS,
                 _("Coordinate expression had an open parenthesis with no close parenthesis")dgettext ("croma", "Coordinate expression had an open parenthesis with no close parenthesis"
));
    return FALSE(0);
  }

/* Now we have no parens and no vars; so we just do all the multiplies
 * and divides, then all the add and subtract.
 */
if (n_exprs == 0)
  {
    g_set_error (err, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                 META_THEME_ERROR_FAILED,
                 _("Coordinate expression doesn't seem to have any operators or operands")dgettext ("croma", "Coordinate expression doesn't seem to have any operators or operands"
));
    return FALSE(0);
  }

/* precedence 1 ops */
precedence = 2;
while (precedence >= 0)
  {
    if (!do_operations (exprs, &n_exprs, precedence, err))
      return FALSE(0);
    --precedence;
  }

g_assert (n_exprs == 1)do { if (n_exprs == 1) ; else g_assertion_message_expr ("croma"
, "ui/theme.c", 2837, ((const char*) (__func__)), "n_exprs == 1"
); } while (0);

*result = *exprs;

return TRUE(!(0));
2842}

2844/*
*   expr = int | double | expr * expr | expr / expr |
*          expr + expr | expr - expr | (expr)
*
*   so very not worth fooling with bison, yet so very painful by hand.
*/
2850/**
* Evaluates an expression.
*
* \param spec  The expression to evaluate.
* \param env   The environment context to evaluate the expression in.
* \param[out] val_p  The integer value of the expression; if the expression
*                    is of type float, this will be rounded. If we return
*                    FALSE because the expression is invalid, this will be
*                    zero.
* \param[out] err    The error, if anything went wrong.
*
* \return  True if we evaluated the expression successfully; false otherwise.
*
* \bug Shouldn't spec be const?
* \ingroup parser
*/
2866static gboolean
2867pos_eval (MetaDrawSpec              *spec,
        const MetaPositionExprEnv *env,
        int                       *val_p,
        GError                   **err)
2871{
PosExpr expr;

*val_p = 0;

if (pos_eval_helper (spec->tokens, spec->n_tokens, env, &expr, err))
  {
    switch (expr.type)
      {
      case POS_EXPR_INT:
        *val_p = expr.d.int_val;
        break;
      case POS_EXPR_DOUBLE:
        *val_p = expr.d.double_val;
        break;
      case POS_EXPR_OPERATOR:
        g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 2887, (
(const char*) (__func__)), ((void*)0)); } while (0);
        break;
      }
    return TRUE(!(0));
  }
else
  {
    return FALSE(0);
  }
2896}

2898/* We always return both X and Y, but only one will be meaningful in
* most contexts.
*/

2902gboolean
2903meta_parse_position_expression (MetaDrawSpec              *spec,
                              const MetaPositionExprEnv *env,
                              int                       *x_return,
                              int                       *y_return,
                              GError                   **err)
2908{
/* All positions are in a coordinate system with x, y at the origin.
 * The expression can have -, +, *, / as operators, floating point
 * or integer constants, and the variables "width" and "height" and
 * optionally "object_width" and object_height". Negative numbers
 * aren't allowed.
 */
int val;

if (spec->constant)
  val = spec->value;
else
  {
    if (pos_eval (spec, env, &spec->value, err) == FALSE(0))
      {
        g_assert (err == NULL || *err != NULL)do { if (err == ((void*)0) || *err != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 2923, ((const char*) (__func__)), "err == NULL || *err != NULL"
); } while (0);
        return FALSE(0);
      }

    val = spec->value;
  }

if (x_return)
  *x_return = env->rect.x + val;
if (y_return)
  *y_return = env->rect.y + val;

return TRUE(!(0));
2936}


2939gboolean
2940meta_parse_size_expression (MetaDrawSpec              *spec,
                          const MetaPositionExprEnv *env,
                          int                       *val_return,
                          GError                   **err)
2944{
int val;

if (spec->constant)
  val = spec->value;
else
  {
    if (pos_eval (spec, env, &spec->value, err) == FALSE(0))
      {
        g_assert (err == NULL || *err != NULL)do { if (err == ((void*)0) || *err != ((void*)0)) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 2953, ((const char*) (__func__)), "err == NULL || *err != NULL"
); } while (0);
        return FALSE(0);
      }

    val = spec->value;
  }

if (val_return)
  *val_return = MAX (val, 1)(((val) > (1)) ? (val) : (1)); /* require that sizes be at least 1x1 */

return TRUE(!(0));
2964}

2966/* To do this we tokenize, replace variable tokens
* that are constants, then reassemble. The purpose
* here is to optimize expressions so we don't do hash
* lookups to eval them. Obviously it's a tradeoff that
* slows down theme load times.
*/
2972gboolean
2973meta_theme_replace_constants (MetaTheme   *theme,
                            PosToken    *tokens,
                            int          n_tokens,
                            GError     **err)
2977{
int i;
double dval;
int ival;
gboolean is_constant = TRUE(!(0));

/* Loop through tokenized string looking for variables to replace */
for (i = 0; i < n_tokens; i++)
  {
    PosToken *t = &tokens[i];

    if (t->type == POS_TOKEN_VARIABLE)
      {
        if (meta_theme_lookup_int_constant (theme, t->d.v.name, &ival))
          {
            g_free (t->d.v.name);
            t->type = POS_TOKEN_INT;
            t->d.i.val = ival;
          }
        else if (meta_theme_lookup_float_constant (theme, t->d.v.name, &dval))
          {
            g_free (t->d.v.name);
            t->type = POS_TOKEN_DOUBLE;
            t->d.d.val = dval;
          }
        else
          {
            /* If we've found a variable that cannot be replaced then the
               expression is not a constant expression and we want to
               replace it with a GQuark */

            t->d.v.name_quark = g_quark_from_string (t->d.v.name);
            is_constant = FALSE(0);
          }
      }
  }

return is_constant;
3015}

3017static int
3018parse_x_position_unchecked (MetaDrawSpec              *spec,
                          const MetaPositionExprEnv *env)
3020{
int retval;
GError *error;

retval = 0;
error = NULL((void*)0);
if (!meta_parse_position_expression (spec, env, &retval, NULL((void*)0), &error))
  {
    meta_warning (_("Theme contained an expression that resulted in an error: %s\n")dgettext ("croma", "Theme contained an expression that resulted in an error: %s\n"
),
                  error->message);

    g_error_free (error);
  }

return retval;
3035}

3037static int
3038parse_y_position_unchecked (MetaDrawSpec              *spec,
                          const MetaPositionExprEnv *env)
3040{
int retval;
GError *error;

retval = 0;
error = NULL((void*)0);
if (!meta_parse_position_expression (spec, env, NULL((void*)0), &retval, &error))
  {
    meta_warning (_("Theme contained an expression that resulted in an error: %s\n")dgettext ("croma", "Theme contained an expression that resulted in an error: %s\n"
),
                  error->message);

    g_error_free (error);
  }

return retval;
3055}

3057static int
3058parse_size_unchecked (MetaDrawSpec        *spec,
                    MetaPositionExprEnv *env)
3060{
int retval;
GError *error;

retval = 0;
error = NULL((void*)0);
if (!meta_parse_size_expression (spec, env, &retval, &error))
  {
    meta_warning (_("Theme contained an expression that resulted in an error: %s\n")dgettext ("croma", "Theme contained an expression that resulted in an error: %s\n"
),
                  error->message);

    g_error_free (error);
  }

return retval;
3075}

3077void
3078meta_draw_spec_free (MetaDrawSpec *spec)
3079{
if (!spec) return;
free_tokens (spec->tokens, spec->n_tokens);
g_slice_free (MetaDrawSpec, spec)do { if (1) g_slice_free1 (sizeof (MetaDrawSpec), (spec)); else
 (void) ((MetaDrawSpec*) 0 == (spec)); } while (0);
3083}

3085MetaDrawSpec *
3086meta_draw_spec_new (MetaTheme  *theme,
                  const char *expr,
                  GError    **error)
3089{
MetaDrawSpec *spec;

spec = g_slice_new0 (MetaDrawSpec)((MetaDrawSpec*) g_slice_alloc0 (sizeof (MetaDrawSpec)));

pos_tokenize (expr, &spec->tokens, &spec->n_tokens, NULL((void*)0));

spec->constant = meta_theme_replace_constants (theme, spec->tokens,
                                               spec->n_tokens, NULL((void*)0));
if (spec->constant)
  {
    gboolean result;

    result = pos_eval (spec, NULL((void*)0), &spec->value, error);
    if (result == FALSE(0))
      {
        meta_draw_spec_free (spec);
        return NULL((void*)0);
      }
  }

return spec;
3111}

3113MetaDrawOp*
3114meta_draw_op_new (MetaDrawType type)
3115{
MetaDrawOp *op;
MetaDrawOp dummy;
int size;

size = G_STRUCT_OFFSET (MetaDrawOp, data)((glong) __builtin_offsetof(MetaDrawOp, data));

switch (type)
  {
  case META_DRAW_LINE:
    size += sizeof (dummy.data.line);
    break;

  case META_DRAW_RECTANGLE:
    size += sizeof (dummy.data.rectangle);
    break;

  case META_DRAW_ARC:
    size += sizeof (dummy.data.arc);
    break;

  case META_DRAW_CLIP:
    size += sizeof (dummy.data.clip);
    break;

  case META_DRAW_TINT:
    size += sizeof (dummy.data.tint);
    break;

  case META_DRAW_GRADIENT:
    size += sizeof (dummy.data.gradient);
    break;

  case META_DRAW_IMAGE:
    size += sizeof (dummy.data.image);
    break;

  case META_DRAW_CTK_ARROW:
    size += sizeof (dummy.data.ctk_arrow);
    break;

  case META_DRAW_CTK_BOX:
    size += sizeof (dummy.data.ctk_box);
    break;

  case META_DRAW_CTK_VLINE:
    size += sizeof (dummy.data.ctk_vline);
    break;

  case META_DRAW_ICON:
    size += sizeof (dummy.data.icon);
    break;

  case META_DRAW_TITLE:
    size += sizeof (dummy.data.title);
    break;
  case META_DRAW_OP_LIST:
    size += sizeof (dummy.data.op_list);
    break;
  case META_DRAW_TILE:
    size += sizeof (dummy.data.tile);
    break;
  }

op = g_malloc0 (size);

op->type = type;

return op;
3184}

3186void
3187meta_draw_op_free (MetaDrawOp *op)
3188{
g_return_if_fail (op != NULL)do { if ((op != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "op != NULL"); return;
 } } while (0);

switch (op->type)
  {
  case META_DRAW_LINE:
    if (op->data.line.color_spec)
      meta_color_spec_free (op->data.line.color_spec);

    meta_draw_spec_free (op->data.line.x1);
    meta_draw_spec_free (op->data.line.y1);
    meta_draw_spec_free (op->data.line.x2);
    meta_draw_spec_free (op->data.line.y2);
    break;

  case META_DRAW_RECTANGLE:
    if (op->data.rectangle.color_spec)
      g_free (op->data.rectangle.color_spec);

    meta_draw_spec_free (op->data.rectangle.x);
    meta_draw_spec_free (op->data.rectangle.y);
    meta_draw_spec_free (op->data.rectangle.width);
    meta_draw_spec_free (op->data.rectangle.height);
    break;

  case META_DRAW_ARC:
    if (op->data.arc.color_spec)
      g_free (op->data.arc.color_spec);

    meta_draw_spec_free (op->data.arc.x);
    meta_draw_spec_free (op->data.arc.y);
    meta_draw_spec_free (op->data.arc.width);
    meta_draw_spec_free (op->data.arc.height);
    break;

  case META_DRAW_CLIP:
    meta_draw_spec_free (op->data.clip.x);
    meta_draw_spec_free (op->data.clip.y);
    meta_draw_spec_free (op->data.clip.width);
    meta_draw_spec_free (op->data.clip.height);
    break;

  case META_DRAW_TINT:
    if (op->data.tint.color_spec)
      meta_color_spec_free (op->data.tint.color_spec);

    if (op->data.tint.alpha_spec)
      meta_alpha_gradient_spec_free (op->data.tint.alpha_spec);

    meta_draw_spec_free (op->data.tint.x);
    meta_draw_spec_free (op->data.tint.y);
    meta_draw_spec_free (op->data.tint.width);
    meta_draw_spec_free (op->data.tint.height);
    break;

  case META_DRAW_GRADIENT:
    if (op->data.gradient.gradient_spec)
      meta_gradient_spec_free (op->data.gradient.gradient_spec);

    if (op->data.gradient.alpha_spec)
      meta_alpha_gradient_spec_free (op->data.gradient.alpha_spec);

    meta_draw_spec_free (op->data.gradient.x);
    meta_draw_spec_free (op->data.gradient.y);
    meta_draw_spec_free (op->data.gradient.width);
    meta_draw_spec_free (op->data.gradient.height);
    break;

  case META_DRAW_IMAGE:
    if (op->data.image.alpha_spec)
      meta_alpha_gradient_spec_free (op->data.image.alpha_spec);

    if (op->data.image.pixbuf)
      g_object_unref (G_OBJECT (op->data.image.pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((op->data.image.pixbuf)), (((GType) ((20) << (2)
))))))));

    if (op->data.image.colorize_spec)
meta_color_spec_free (op->data.image.colorize_spec);

    if (op->data.image.colorize_cache_pixbuf)
      g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((op->data.image.colorize_cache_pixbuf)), (((GType) ((20
) << (2)))))))));

    meta_draw_spec_free (op->data.image.x);
    meta_draw_spec_free (op->data.image.y);
    meta_draw_spec_free (op->data.image.width);
    meta_draw_spec_free (op->data.image.height);
    break;

  case META_DRAW_CTK_ARROW:
    meta_draw_spec_free (op->data.ctk_arrow.x);
    meta_draw_spec_free (op->data.ctk_arrow.y);
    meta_draw_spec_free (op->data.ctk_arrow.width);
    meta_draw_spec_free (op->data.ctk_arrow.height);
    break;

  case META_DRAW_CTK_BOX:
    meta_draw_spec_free (op->data.ctk_box.x);
    meta_draw_spec_free (op->data.ctk_box.y);
    meta_draw_spec_free (op->data.ctk_box.width);
    meta_draw_spec_free (op->data.ctk_box.height);
    break;

  case META_DRAW_CTK_VLINE:
    meta_draw_spec_free (op->data.ctk_vline.x);
    meta_draw_spec_free (op->data.ctk_vline.y1);
    meta_draw_spec_free (op->data.ctk_vline.y2);
    break;

  case META_DRAW_ICON:
    if (op->data.icon.alpha_spec)
      meta_alpha_gradient_spec_free (op->data.icon.alpha_spec);

    meta_draw_spec_free (op->data.icon.x);
    meta_draw_spec_free (op->data.icon.y);
    meta_draw_spec_free (op->data.icon.width);
    meta_draw_spec_free (op->data.icon.height);
    break;

  case META_DRAW_TITLE:
    if (op->data.title.color_spec)
      meta_color_spec_free (op->data.title.color_spec);

    meta_draw_spec_free (op->data.title.x);
    meta_draw_spec_free (op->data.title.y);
    if (op->data.title.ellipsize_width)
      meta_draw_spec_free (op->data.title.ellipsize_width);
    break;

  case META_DRAW_OP_LIST:
    if (op->data.op_list.op_list)
      meta_draw_op_list_unref (op->data.op_list.op_list);

    meta_draw_spec_free (op->data.op_list.x);
    meta_draw_spec_free (op->data.op_list.y);
    meta_draw_spec_free (op->data.op_list.width);
    meta_draw_spec_free (op->data.op_list.height);
    break;

  case META_DRAW_TILE:
    if (op->data.tile.op_list)
      meta_draw_op_list_unref (op->data.tile.op_list);

    meta_draw_spec_free (op->data.tile.x);
    meta_draw_spec_free (op->data.tile.y);
    meta_draw_spec_free (op->data.tile.width);
    meta_draw_spec_free (op->data.tile.height);
    meta_draw_spec_free (op->data.tile.tile_xoffset);
    meta_draw_spec_free (op->data.tile.tile_yoffset);
    meta_draw_spec_free (op->data.tile.tile_width);
    meta_draw_spec_free (op->data.tile.tile_height);
    break;
  }

g_free (op);
3341}

3343static GdkPixbuf*
3344apply_alpha (GdkPixbuf             *pixbuf,
           MetaAlphaGradientSpec *spec,
           gboolean               force_copy)
3347{
GdkPixbuf *new_pixbuf;
gboolean needs_alpha;

g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((pixbuf)); GType __t = ((gdk_pixbuf_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("croma", ((const char*) (__func__
)), "GDK_IS_PIXBUF (pixbuf)"); return (((void*)0)); } } while
 (0);

needs_alpha = spec && (spec->n_alphas > 1 ||
                       spec->alphas[0] != 0xff);

if (!needs_alpha)
  return pixbuf;

if (!gdk_pixbuf_get_has_alpha (pixbuf))
  {
    new_pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE(0), 0, 0, 0);
    g_object_unref (G_OBJECT (pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((pixbuf)), (((GType) ((20) << (2)))))))));
    pixbuf = new_pixbuf;
  }
else if (force_copy)
  {
    new_pixbuf = gdk_pixbuf_copy (pixbuf);
    g_object_unref (G_OBJECT (pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((pixbuf)), (((GType) ((20) << (2)))))))));
    pixbuf = new_pixbuf;
  }

g_assert (gdk_pixbuf_get_has_alpha (pixbuf))do { if (gdk_pixbuf_get_has_alpha (pixbuf)) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 3372, ((const char*) (__func__)), "gdk_pixbuf_get_has_alpha (pixbuf)"
); } while (0);

meta_gradient_add_alpha (pixbuf, spec->alphas, spec->n_alphas, spec->type);

return pixbuf;
3377}

3379static GdkPixbuf*
3380pixbuf_tile (GdkPixbuf *tile,
           int        width,
           int        height)
3383{
GdkPixbuf *pixbuf;
int tile_width;
int tile_height;
int i;

tile_width = gdk_pixbuf_get_width (tile);
tile_height = gdk_pixbuf_get_height (tile);

pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                         gdk_pixbuf_get_has_alpha (tile),
                         8, width, height);

i = 0;
while (i < width)
  {
    int j;

    j = 0;
    while (j < height)
      {
        int w, h;

        w = MIN (tile_width, width - i)(((tile_width) < (width - i)) ? (tile_width) : (width - i)
);
        h = MIN (tile_height, height - j)(((tile_height) < (height - j)) ? (tile_height) : (height -
 j));

        gdk_pixbuf_copy_area (tile,
                              0, 0,
                              w, h,
                              pixbuf,
                              i, j);

        j += tile_height;
      }

    i += tile_width;
  }

return pixbuf;
3422}

3424static GdkPixbuf *
3425replicate_rows (GdkPixbuf  *src,
              int         src_x,
              int         src_y,
              int         width,
              int         height)
3430{
unsigned int n_channels = gdk_pixbuf_get_n_channels (src);
unsigned int src_rowstride = gdk_pixbuf_get_rowstride (src);
unsigned char *pixels = (gdk_pixbuf_get_pixels (src) + src_y * src_rowstride + src_x
                         * n_channels);
unsigned char *dest_pixels;
GdkPixbuf *result;
unsigned int dest_rowstride;
int i;

result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,
                         width, height);
dest_rowstride = gdk_pixbuf_get_rowstride (result);
dest_pixels = gdk_pixbuf_get_pixels (result);

for (i = 0; i < height; i++)
  memcpy (dest_pixels + dest_rowstride * i, pixels, n_channels * width);

return result;
3449}

3451static GdkPixbuf *
3452replicate_cols (GdkPixbuf  *src,
              int         src_x,
              int         src_y,
              int         width,
              int         height)
3457{
unsigned int n_channels = gdk_pixbuf_get_n_channels (src);
unsigned int src_rowstride = gdk_pixbuf_get_rowstride (src);
unsigned char *pixels = (gdk_pixbuf_get_pixels (src) + src_y * src_rowstride + src_x
                         * n_channels);
unsigned char *dest_pixels;
GdkPixbuf *result;
unsigned int dest_rowstride;
int i, j;

result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,
                         width, height);
dest_rowstride = gdk_pixbuf_get_rowstride (result);
dest_pixels = gdk_pixbuf_get_pixels (result);

for (i = 0; i < height; i++)
  {
    unsigned char *p = dest_pixels + dest_rowstride * i;
    unsigned char *q = pixels + src_rowstride * i;

    unsigned char r = *(q++);
    unsigned char g = *(q++);
    unsigned char b = *(q++);

    if (n_channels == 4)
      {
        unsigned char a;

        a = *(q++);

        for (j = 0; j < width; j++)
          {
            *(p++) = r;
            *(p++) = g;
            *(p++) = b;
            *(p++) = a;
          }
      }
    else
      {
        for (j = 0; j < width; j++)
          {
            *(p++) = r;
            *(p++) = g;
            *(p++) = b;
          }
      }
  }

return result;
3507}

3509static GdkPixbuf*
3510scale_and_alpha_pixbuf (GdkPixbuf             *src,
                      MetaAlphaGradientSpec *alpha_spec,
                      MetaImageFillType      fill_type,
                      int                    width,
                      int                    height,
                      gboolean               vertical_stripes,
                      gboolean               horizontal_stripes)
3517{
GdkPixbuf *pixbuf;
GdkPixbuf *temp_pixbuf;

pixbuf = NULL((void*)0);

pixbuf = src;

if (gdk_pixbuf_get_width (pixbuf) == width &&
    gdk_pixbuf_get_height (pixbuf) == height)
  {
    g_object_ref (G_OBJECT (pixbuf))((__typeof__ (((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((pixbuf)), (((GType) ((20) << (2)))
))))))) (g_object_ref) (((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((pixbuf)), (((GType) ((20) << (2)))
)))))));
  }
else
  {
    if (fill_type == META_IMAGE_FILL_TILE)
      {
        pixbuf = pixbuf_tile (pixbuf, width, height);
      }
    else
      {
  	  int src_h, src_w, dest_h, dest_w;
        src_h = gdk_pixbuf_get_height (src);
        src_w = gdk_pixbuf_get_width (src);

        /* prefer to replicate_cols if possible, as that
         * is faster (no memory reads)
         */
        if (horizontal_stripes)
          {
            dest_w = gdk_pixbuf_get_width (src);
            dest_h = height;
          }
        else if (vertical_stripes)
          {
            dest_w = width;
            dest_h = gdk_pixbuf_get_height (src);
          }

        else
          {
            dest_w = width;
            dest_h = height;
          }

        if (dest_w == src_w && dest_h == src_h)
          {
            temp_pixbuf = src;
            g_object_ref (G_OBJECT (temp_pixbuf))((__typeof__ (((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((temp_pixbuf)), (((GType) ((20) << (
2)))))))))) (g_object_ref) (((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((temp_pixbuf)), (((GType) ((20) << (
2))))))))));
          }
        else
          {
            temp_pixbuf = gdk_pixbuf_scale_simple (src,
                                                   dest_w, dest_h,
                                                   GDK_INTERP_BILINEAR);
          }

        /* prefer to replicate_cols if possible, as that
         * is faster (no memory reads)
         */
        if (horizontal_stripes)
          {
            pixbuf = replicate_cols (temp_pixbuf, 0, 0, width, height);
            g_object_unref (G_OBJECT (temp_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((temp_pixbuf)), (((GType) ((20) << (2)))))))));
          }
        else if (vertical_stripes)
          {
            pixbuf = replicate_rows (temp_pixbuf, 0, 0, width, height);
            g_object_unref (G_OBJECT (temp_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((temp_pixbuf)), (((GType) ((20) << (2)))))))));
          }
        else
          {
            pixbuf = temp_pixbuf;
          }
      }
  }

if (pixbuf)
  pixbuf = apply_alpha (pixbuf, alpha_spec, pixbuf == src);

return pixbuf;
3598}

3600static GdkPixbuf*
3601draw_op_as_pixbuf (const MetaDrawOp    *op,
                 CtkStyleContext     *style,
                 const MetaDrawInfo  *info,
                 int                  width,
                 int                  height)
3606{
/* Try to get the op as a pixbuf, assuming w/h in the op
 * matches the width/height passed in. return NULL
 * if the op can't be converted to an equivalent pixbuf.
 */
GdkPixbuf *pixbuf;

pixbuf = NULL((void*)0);

switch (op->type)
  {
  case META_DRAW_LINE:
    break;

  case META_DRAW_RECTANGLE:
    if (op->data.rectangle.filled)
      {
        CdkRGBA color;

        meta_color_spec_render (op->data.rectangle.color_spec,
                                style,
                                &color);

        pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                                 FALSE(0),
                                 8, width, height);

        gdk_pixbuf_fill (pixbuf, CDK_COLOR_RGBA (color)((guint32) (0xff | ((int)((color).red * 255) << 24) | (
(int)((color).green * 255) << 16) | ((int)((color).blue
 * 255) << 8))));
      }
    break;

  case META_DRAW_ARC:
    break;

  case META_DRAW_CLIP:
    break;

  case META_DRAW_TINT:
    {
      CdkRGBA color;
      guint32 rgba;
      gboolean has_alpha;

      meta_color_spec_render (op->data.rectangle.color_spec,
                              style,
                              &color);

      has_alpha =
        op->data.tint.alpha_spec &&
        (op->data.tint.alpha_spec->n_alphas > 1 ||
         op->data.tint.alpha_spec->alphas[0] != 0xff);

      pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                               has_alpha,
                               8, width, height);

      if (!has_alpha)
        {
          rgba = CDK_COLOR_RGBA (color)((guint32) (0xff | ((int)((color).red * 255) << 24) | (
(int)((color).green * 255) << 16) | ((int)((color).blue
 * 255) << 8)));

          gdk_pixbuf_fill (pixbuf, rgba);
        }
      else if (op->data.tint.alpha_spec->n_alphas == 1)
        {
          rgba = CDK_COLOR_RGBA (color)((guint32) (0xff | ((int)((color).red * 255) << 24) | (
(int)((color).green * 255) << 16) | ((int)((color).blue
 * 255) << 8)));
          rgba &= ~0xff;
          rgba |= op->data.tint.alpha_spec->alphas[0];

          gdk_pixbuf_fill (pixbuf, rgba);
        }
      else
        {
          rgba = CDK_COLOR_RGBA (color)((guint32) (0xff | ((int)((color).red * 255) << 24) | (
(int)((color).green * 255) << 16) | ((int)((color).blue
 * 255) << 8)));

          gdk_pixbuf_fill (pixbuf, rgba);

          meta_gradient_add_alpha (pixbuf,
                                   op->data.tint.alpha_spec->alphas,
                                   op->data.tint.alpha_spec->n_alphas,
                                   op->data.tint.alpha_spec->type);
        }
    }
    break;

  case META_DRAW_IMAGE:
    {
if (op->data.image.colorize_spec)
 {
   CdkRGBA color;

          meta_color_spec_render (op->data.image.colorize_spec,
                                  style, &color);

          if (op->data.image.colorize_cache_pixbuf == NULL((void*)0) ||
              op->data.image.colorize_cache_pixel != CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) | ((int)((
color).green * 255) << 8) | ((int)((color).blue * 255))
)))
            {
              if (op->data.image.colorize_cache_pixbuf)
                g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((op->data.image.colorize_cache_pixbuf)), (((GType) ((20
) << (2)))))))));

              /* const cast here */
              ((MetaDrawOp*)op)->data.image.colorize_cache_pixbuf =
                colorize_pixbuf (op->data.image.pixbuf,
                                 &color);
              ((MetaDrawOp*)op)->data.image.colorize_cache_pixel =
                CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) | ((int)((
color).green * 255) << 8) | ((int)((color).blue * 255))
));
            }

          if (op->data.image.colorize_cache_pixbuf)
            {
              pixbuf = scale_and_alpha_pixbuf (op->data.image.colorize_cache_pixbuf,
                                               op->data.image.alpha_spec,
                                               op->data.image.fill_type,
                                               width, height,
                                               op->data.image.vertical_stripes,
                                               op->data.image.horizontal_stripes);
            }
 }
else
 {
   pixbuf = scale_and_alpha_pixbuf (op->data.image.pixbuf,
                                           op->data.image.alpha_spec,
                                           op->data.image.fill_type,
                                           width, height,
                                           op->data.image.vertical_stripes,
                                           op->data.image.horizontal_stripes);
 }
      break;
    }

  case META_DRAW_GRADIENT:
  case META_DRAW_CTK_ARROW:
  case META_DRAW_CTK_BOX:
  case META_DRAW_CTK_VLINE:
    break;

  case META_DRAW_ICON:
    if (info->mini_icon &&
        width <= gdk_pixbuf_get_width (info->mini_icon) &&
        height <= gdk_pixbuf_get_height (info->mini_icon))
      pixbuf = scale_and_alpha_pixbuf (info->mini_icon,
                                       op->data.icon.alpha_spec,
                                       op->data.icon.fill_type,
                                       width, height,
                                       FALSE(0), FALSE(0));
    else if (info->icon)
      pixbuf = scale_and_alpha_pixbuf (info->icon,
                                       op->data.icon.alpha_spec,
                                       op->data.icon.fill_type,
                                       width, height,
                                       FALSE(0), FALSE(0));
    break;

  case META_DRAW_TITLE:
    break;

  case META_DRAW_OP_LIST:
    break;

  case META_DRAW_TILE:
    break;
  }

return pixbuf;
3769}

3771static cairo_surface_t *
3772draw_op_as_surface (const MetaDrawOp   *op,
                  CtkStyleContext    *style,
                  const MetaDrawInfo *info,
                  gdouble             width,
                  gdouble             height)
3777{
cairo_surface_t *surface;

surface = NULL((void*)0);

switch (op->type)
  {
  case META_DRAW_IMAGE:
    {
      if (op->data.image.colorize_spec)
        {
          CdkRGBA color;

          meta_color_spec_render (op->data.image.colorize_spec,
                                  style, &color);

          if (op->data.image.colorize_cache_pixbuf == NULL((void*)0) ||
              op->data.image.colorize_cache_pixel != CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) | ((int)((
color).green * 255) << 8) | ((int)((color).blue * 255))
)))
            {
              if (op->data.image.colorize_cache_pixbuf)
                g_object_unref (G_OBJECT (op->data.image.colorize_cache_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((op->data.image.colorize_cache_pixbuf)), (((GType) ((20
) << (2)))))))));

              /* const cast here */
              ((MetaDrawOp*)op)->data.image.colorize_cache_pixbuf =
                colorize_pixbuf (op->data.image.pixbuf,
                                 &color);
              ((MetaDrawOp*)op)->data.image.colorize_cache_pixel =
                CDK_COLOR_RGB (color)((guint32) (((int)((color).red * 255) << 16) | ((int)((
color).green * 255) << 8) | ((int)((color).blue * 255))
));
            }

          if (op->data.image.colorize_cache_pixbuf)
            {
              surface = get_surface_from_pixbuf (op->data.image.colorize_cache_pixbuf,
                                                 op->data.image.fill_type,
                                                 width, height,
                                                 op->data.image.vertical_stripes,
                                                 op->data.image.horizontal_stripes);
            }
        }
      else
        {
          surface = get_surface_from_pixbuf (op->data.image.pixbuf,
                                             op->data.image.fill_type,
                                             width, height,
                                             op->data.image.vertical_stripes,
                                             op->data.image.horizontal_stripes);
        }
      break;
    }

  case META_DRAW_ICON:
    if (info->mini_icon &&
        width <= gdk_pixbuf_get_width (info->mini_icon) &&
        height <= gdk_pixbuf_get_height (info->mini_icon))
      surface = get_surface_from_pixbuf (info->mini_icon, op->data.icon.fill_type,
                                         width, height, FALSE(0), FALSE(0));
    else if (info->icon)
      surface = get_surface_from_pixbuf (info->icon, op->data.icon.fill_type,
                                         width, height, FALSE(0), FALSE(0));
    break;

  case META_DRAW_TINT:
  case META_DRAW_LINE:
  case META_DRAW_RECTANGLE:
  case META_DRAW_ARC:
  case META_DRAW_CLIP:
  case META_DRAW_GRADIENT:
  case META_DRAW_CTK_ARROW:
  case META_DRAW_CTK_BOX:
  case META_DRAW_CTK_VLINE:
  case META_DRAW_TITLE:
  case META_DRAW_OP_LIST:
  case META_DRAW_TILE:
    break;

  default:
    break;
  }

return surface;
3857}

3859static void
3860fill_env (MetaPositionExprEnv *env,
        const MetaDrawInfo  *info,
        MetaRectangle        logical_region)
3863{
/* FIXME this stuff could be raised into draw_op_list_draw() probably
 */
env->rect = logical_region;
env->object_width = -1;
env->object_height = -1;
if (info->fgeom)
  {
    env->left_width = info->fgeom->borders.visible.left;
    env->right_width = info->fgeom->borders.visible.right;
    env->top_height = info->fgeom->borders.visible.top;
    env->bottom_height = info->fgeom->borders.visible.bottom;
    env->frame_x_center = info->fgeom->width / 2 - logical_region.x;
    env->frame_y_center = info->fgeom->height / 2 - logical_region.y;
  }
else
  {
    env->left_width = 0;
    env->right_width = 0;
    env->top_height = 0;
    env->bottom_height = 0;
    env->frame_x_center = 0;
    env->frame_y_center = 0;
  }

env->mini_icon_width = info->mini_icon ? gdk_pixbuf_get_width (info->mini_icon) : 0;
env->mini_icon_height = info->mini_icon ? gdk_pixbuf_get_height (info->mini_icon) : 0;
env->icon_width = info->icon ? gdk_pixbuf_get_width (info->icon) : 0;
env->icon_height = info->icon ? gdk_pixbuf_get_height (info->icon) : 0;

env->title_width = info->title_layout_width;
env->title_height = info->title_layout_height;
env->theme = meta_current_theme;
3896}

3898/* This code was originally rendering anti-aliased using X primitives, and
* now has been switched to draw anti-aliased using cairo. In general, the
* closest correspondence between X rendering and cairo rendering is given
* by offsetting the geometry by 0.5 pixels in both directions before rendering
* with cairo. This is because X samples at the upper left corner of the
* pixel while cairo averages over the entire pixel. However, in the cases
* where the X rendering was an exact rectangle with no "jaggies"
* we need to be a bit careful about applying the offset. We want to produce
* the exact same pixel-aligned rectangle, rather than a rectangle with
* fuzz around the edges.
*/
3909static void
3910meta_draw_op_draw_with_env (const MetaDrawOp    *op,
                          CtkStyleContext     *style_ctk,
                          cairo_t             *cr,
                          const MetaDrawInfo  *info,
                          MetaRectangle        rect,
                          MetaPositionExprEnv *env)
3916{
CdkRGBA color;

cairo_save (cr);
ctk_style_context_save (style_ctk);

cairo_set_line_width (cr, 1.0);

switch (op->type)
  {
  case META_DRAW_LINE:
    {
      int x1, y1;

      meta_color_spec_render (op->data.line.color_spec, style_ctk, &color);
      cdk_cairo_set_source_rgba (cr, &color);

      if (op->data.line.width > 0)
        cairo_set_line_width (cr, op->data.line.width);

      if (op->data.line.dash_on_length > 0 &&
          op->data.line.dash_off_length > 0)
        {
          double dash_list[2];
          dash_list[0] = op->data.line.dash_on_length;
          dash_list[1] = op->data.line.dash_off_length;
          cairo_set_dash (cr, dash_list, 2, 0);
        }

      x1 = parse_x_position_unchecked (op->data.line.x1, env);
      y1 = parse_y_position_unchecked (op->data.line.y1, env);

      if (!op->data.line.x2 &&
          !op->data.line.y2 &&
          op->data.line.width==0)
        {
          cairo_rectangle (cr, x1, y1, 1, 1);
          cairo_fill (cr);
        }
      else
        {
          int x2, y2;

          if (op->data.line.x2)
            x2 = parse_x_position_unchecked (op->data.line.x2, env);
          else
            x2 = x1;

          if (op->data.line.y2)
            y2 = parse_y_position_unchecked (op->data.line.y2, env);
          else
            y2 = y1;

          /* This is one of the cases where we are matching the exact
           * pixel aligned rectangle produced by X; for zero-width lines
           * the generic algorithm produces the right result so we don't
           * need to handle them here.
           */
          if ((y1 == y2 || x1 == x2) && op->data.line.width != 0)
            {
              double offset = op->data.line.width % 2 ? .5 : 0;

              if (y1 == y2)
                {
                  cairo_move_to (cr, x1, y1 + offset);
                  cairo_line_to (cr, x2, y2 + offset);
                }
              else
                {
                  cairo_move_to (cr, x1 + offset, y1);
                  cairo_line_to (cr, x2 + offset, y2);
                }
            }
          else
            {
              /* zero-width lines include both end-points in X, unlike wide lines */
              if (op->data.line.width == 0)
                cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);

              cairo_move_to (cr, x1 + .5, y1 + .5);
              cairo_line_to (cr, x2 + .5, y2 + .5);
            }
          cairo_stroke (cr);
        }
    }
    break;

  case META_DRAW_RECTANGLE:
    {
      int rx, ry, rwidth, rheight;

      meta_color_spec_render (op->data.rectangle.color_spec, style_ctk, &color);
      cdk_cairo_set_source_rgba (cr, &color);

      rx = parse_x_position_unchecked (op->data.rectangle.x, env);
      ry = parse_y_position_unchecked (op->data.rectangle.y, env);
      rwidth = parse_size_unchecked (op->data.rectangle.width, env);
      rheight = parse_size_unchecked (op->data.rectangle.height, env);

      /* Filled and stroked rectangles are the other cases
       * we pixel-align to X rasterization
       */
      if (op->data.rectangle.filled)
        {
          cairo_rectangle (cr, rx, ry, rwidth, rheight);
          cairo_fill (cr);
        }
      else
        {
          cairo_rectangle (cr, rx + .5, ry + .5, rwidth, rheight);
          cairo_stroke (cr);
        }
    }
    break;

  case META_DRAW_ARC:
    {
      int rx, ry, rwidth, rheight;
      double start_angle, end_angle;
      double center_x, center_y;

      meta_color_spec_render (op->data.arc.color_spec, style_ctk, &color);
      cdk_cairo_set_source_rgba (cr, &color);

      rx = parse_x_position_unchecked (op->data.arc.x, env);
      ry = parse_y_position_unchecked (op->data.arc.y, env);
      rwidth = parse_size_unchecked (op->data.arc.width, env);
      rheight = parse_size_unchecked (op->data.arc.height, env);

      start_angle = op->data.arc.start_angle * (M_PI3.14159265358979323846 / 180.)
                    - (.5 * M_PI3.14159265358979323846); /* start at 12 instead of 3 oclock */
      end_angle = start_angle + op->data.arc.extent_angle * (M_PI3.14159265358979323846 / 180.);
      center_x = rx + (double)rwidth / 2. + .5;
      center_y = ry + (double)rheight / 2. + .5;

      cairo_save (cr);

      cairo_translate (cr, center_x, center_y);
      cairo_scale (cr, (double)rwidth / 2., (double)rheight / 2.);

      if (op->data.arc.extent_angle >= 0)
        cairo_arc (cr, 0, 0, 1, start_angle, end_angle);
      else
        cairo_arc_negative (cr, 0, 0, 1, start_angle, end_angle);

      cairo_restore (cr);

      if (op->data.arc.filled)
        {
          cairo_line_to (cr, center_x, center_y);
          cairo_fill (cr);
        }
      else
        cairo_stroke (cr);
    }
    break;

  case META_DRAW_CLIP:
    break;

  case META_DRAW_TINT:
    {
      int rx, ry, rwidth, rheight;
      gboolean needs_alpha;

      needs_alpha = op->data.tint.alpha_spec &&
        (op->data.tint.alpha_spec->n_alphas > 1 ||
         op->data.tint.alpha_spec->alphas[0] != 0xff);

      rx = parse_x_position_unchecked (op->data.tint.x, env);
      ry = parse_y_position_unchecked (op->data.tint.y, env);
      rwidth = parse_size_unchecked (op->data.tint.width, env);
      rheight = parse_size_unchecked (op->data.tint.height, env);

      if (!needs_alpha)
        {
          meta_color_spec_render (op->data.tint.color_spec, style_ctk, &color);
          cdk_cairo_set_source_rgba (cr, &color);

          cairo_rectangle (cr, rx, ry, rwidth, rheight);
          cairo_fill (cr);
        }
      else
        {
          GdkPixbuf *pixbuf;

          pixbuf = draw_op_as_pixbuf (op, style_ctk, info,
                                      rwidth, rheight);

          if (pixbuf)
            {
              cdk_cairo_set_source_pixbuf (cr, pixbuf, rx, ry);
              cairo_paint (cr);

              g_object_unref (G_OBJECT (pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((pixbuf)), (((GType) ((20) << (2)))))))));
            }
        }
    }
    break;

  case META_DRAW_GRADIENT:
    {
      int rx, ry, rwidth, rheight;

      rx = parse_x_position_unchecked (op->data.gradient.x, env);
      ry = parse_y_position_unchecked (op->data.gradient.y, env);
      rwidth = parse_size_unchecked (op->data.gradient.width, env);
      rheight = parse_size_unchecked (op->data.gradient.height, env);

      meta_gradient_spec_render (op->data.gradient.gradient_spec,
                                 op->data.gradient.alpha_spec,
                                 cr, style_ctk, rx, ry, rwidth, rheight);
    }
    break;

  case META_DRAW_IMAGE:
    {
      gint scale;
      gdouble rx, ry, rwidth, rheight;
      cairo_surface_t *surface;

      scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());
      cairo_scale (cr, 1.0 / scale, 1.0 / scale);

      if (op->data.image.pixbuf)
        {
          env->object_width = gdk_pixbuf_get_width (op->data.image.pixbuf) / scale;
          env->object_height = gdk_pixbuf_get_height (op->data.image.pixbuf) / scale;
        }

      rwidth = parse_size_unchecked (op->data.image.width, env) * scale;
      rheight = parse_size_unchecked (op->data.image.height, env) * scale;

      surface = draw_op_as_surface (op, style_ctk, info, rwidth, rheight);

      if (surface)
        {
          rx = parse_x_position_unchecked (op->data.image.x, env) * scale;
          ry = parse_y_position_unchecked (op->data.image.y, env) * scale;

          cairo_set_source_surface (cr, surface, rx, ry);

          if (op->data.image.alpha_spec)
            {
              cairo_pattern_t *pattern;

              cairo_translate (cr, rx, ry);
              cairo_scale (cr, rwidth, rheight);

              pattern = meta_alpha_gradient_spec_get_mask (op->data.image.alpha_spec);
              cairo_mask (cr, pattern);

              cairo_pattern_destroy (pattern);
            }
          else
            {
              cairo_paint (cr);
            }

          cairo_surface_destroy (surface);
        }
    }
    break;

  case META_DRAW_CTK_ARROW:
    {
      int rx, ry, rwidth, rheight;

      rx = parse_x_position_unchecked (op->data.ctk_arrow.x, env);
      ry = parse_y_position_unchecked (op->data.ctk_arrow.y, env);
      rwidth = parse_size_unchecked (op->data.ctk_arrow.width, env);
      rheight = parse_size_unchecked (op->data.ctk_arrow.height, env);

      double size = MAX(rwidth, rheight)(((rwidth) > (rheight)) ? (rwidth) : (rheight)), angle = 0;

      switch (op->data.ctk_arrow.arrow)
        {
        case CTK_ARROW_UP:
          angle = 0;
          break;
        case CTK_ARROW_RIGHT:
          angle = M_PI3.14159265358979323846 / 2;
          break;
        case CTK_ARROW_DOWN:
          angle = M_PI3.14159265358979323846;
          break;
        case CTK_ARROW_LEFT:
          angle = 3 * M_PI3.14159265358979323846 / 2;
          break;
        case CTK_ARROW_NONE:
          return;
        }

      ctk_style_context_set_state (style_ctk, op->data.ctk_arrow.state);
      ctk_render_arrow (style_ctk, cr, angle, rx, ry, size);
    }
    break;

  case META_DRAW_CTK_BOX:
    {
      int rx, ry, rwidth, rheight;

      rx = parse_x_position_unchecked (op->data.ctk_box.x, env);
      ry = parse_y_position_unchecked (op->data.ctk_box.y, env);
      rwidth = parse_size_unchecked (op->data.ctk_box.width, env);
      rheight = parse_size_unchecked (op->data.ctk_box.height, env);

      ctk_style_context_set_state (style_ctk, op->data.ctk_box.state);
      ctk_render_background (style_ctk, cr, rx, ry, rwidth, rheight);
      ctk_render_frame (style_ctk, cr, rx, ry, rwidth, rheight);
    }
    break;

  case META_DRAW_CTK_VLINE:
    {
      int rx, ry1, ry2;

      rx = parse_x_position_unchecked (op->data.ctk_vline.x, env);
      ry1 = parse_y_position_unchecked (op->data.ctk_vline.y1, env);
      ry2 = parse_y_position_unchecked (op->data.ctk_vline.y2, env);

      ctk_style_context_set_state (style_ctk, op->data.ctk_vline.state);
      ctk_render_line (style_ctk, cr, rx, ry1, rx, ry2);
    }
    break;

  case META_DRAW_ICON:
    {
      gint scale;
      gdouble rx, ry, rwidth, rheight;
      cairo_surface_t *surface;

      scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());
      cairo_scale (cr, 1.0 / scale, 1.0 / scale);

      rwidth = parse_size_unchecked (op->data.icon.width, env) * scale;
      rheight = parse_size_unchecked (op->data.icon.height, env) * scale;

      surface = draw_op_as_surface (op, style_ctk, info, rwidth, rheight);

      if (surface)
        {
          rx = parse_x_position_unchecked (op->data.icon.x, env) * scale;
          ry = parse_y_position_unchecked (op->data.icon.y, env) * scale;

          cairo_set_source_surface (cr, surface, rx, ry);

          if (op->data.icon.alpha_spec)
            {
              cairo_pattern_t *pattern;

              cairo_translate (cr, rx, ry);
              cairo_scale (cr, rwidth, rheight);

              pattern = meta_alpha_gradient_spec_get_mask (op->data.icon.alpha_spec);
              cairo_mask (cr, pattern);

              cairo_pattern_destroy (pattern);
            }
          else
            {
              cairo_paint (cr);
            }

          cairo_surface_destroy (surface);
        }
    }
    break;

  case META_DRAW_TITLE:
    if (info->title_layout)
      {
        int rx, ry;
        PangoRectangle ink_rect, logical_rect;

        meta_color_spec_render (op->data.title.color_spec, style_ctk, &color);
        cdk_cairo_set_source_rgba (cr, &color);

        rx = parse_x_position_unchecked (op->data.title.x, env);
        ry = parse_y_position_unchecked (op->data.title.y, env);

        if (op->data.title.ellipsize_width)
          {
            int ellipsize_width;
            int right_bearing;

            ellipsize_width = parse_x_position_unchecked (op->data.title.ellipsize_width, env);
            /* HACK: parse_x_position_unchecked adds in env->rect.x, subtract out again */
            ellipsize_width -= env->rect.x;

            pango_layout_set_width (info->title_layout, -1);
            pango_layout_get_pixel_extents (info->title_layout,
                                            &ink_rect, &logical_rect);

            /* Pango's idea of ellipsization is with respect to the logical rect.
             * correct for this, by reducing the ellipsization width by the overflow
             * of the un-ellipsized text on the right... it's always the visual
             * right we want regardless of bidi, since since the X we pass in to
             * cairo_move_to() is always the left edge of the line.
             */
            right_bearing = (ink_rect.x + ink_rect.width) - (logical_rect.x + logical_rect.width);
            right_bearing = MAX (right_bearing, 0)(((right_bearing) > (0)) ? (right_bearing) : (0));

            ellipsize_width -= right_bearing;
            ellipsize_width = MAX (ellipsize_width, 0)(((ellipsize_width) > (0)) ? (ellipsize_width) : (0));

            /* Only ellipsizing when necessary is a performance optimization -
             * pango_layout_set_width() will force a relayout if it isn't the
             * same as the current width of -1.
             */
            if (ellipsize_width < logical_rect.width)
              pango_layout_set_width (info->title_layout, PANGO_SCALE1024 * ellipsize_width);
          }
        else if (rx - env->rect.x + env->title_width >= env->rect.width)
        {
          const double alpha_margin = 30.0;
          int text_space = env->rect.x + env->rect.width -
                           (rx - env->rect.x) - env->right_width;

          double startalpha = 1.0 - (alpha_margin/((double)text_space));

          cairo_pattern_t *linpat;
          linpat = cairo_pattern_create_linear (rx, ry, text_space,
                                                env->title_height);
          cairo_pattern_add_color_stop_rgba (linpat, 0, color.red,
                                                        color.green,
                                                        color.blue,
                                                        color.alpha);
          cairo_pattern_add_color_stop_rgba (linpat, startalpha,
                                                     color.red,
                                                     color.green,
                                                     color.blue,
                                                     color.alpha);
          cairo_pattern_add_color_stop_rgba (linpat, 1, color.red,
                                                        color.green,
                                                        color.blue, 0);
          cairo_set_source(cr, linpat);
          cairo_pattern_destroy(linpat);
        }

        cairo_move_to (cr, rx, ry);
        pango_cairo_show_layout (cr, info->title_layout);

        /* Remove any ellipsization we might have set; will short-circuit
         * if the width is already -1 */
        pango_layout_set_width (info->title_layout, -1);
      }
    break;

  case META_DRAW_OP_LIST:
    {
      MetaRectangle d_rect;

      d_rect.x = parse_x_position_unchecked (op->data.op_list.x, env);
      d_rect.y = parse_y_position_unchecked (op->data.op_list.y, env);
      d_rect.width = parse_size_unchecked (op->data.op_list.width, env);
      d_rect.height = parse_size_unchecked (op->data.op_list.height, env);

      meta_draw_op_list_draw_with_style (op->data.op_list.op_list,
                                         style_ctk,
                                         cr,
                                         info, d_rect);
    }
    break;

  case META_DRAW_TILE:
    {
      int rx, ry, rwidth, rheight;
      int tile_xoffset, tile_yoffset;
      MetaRectangle tile;

      rx = parse_x_position_unchecked (op->data.tile.x, env);
      ry = parse_y_position_unchecked (op->data.tile.y, env);
      rwidth = parse_size_unchecked (op->data.tile.width, env);
      rheight = parse_size_unchecked (op->data.tile.height, env);

      cairo_save (cr);

      cairo_rectangle (cr, rx, ry, rwidth, rheight);
      cairo_clip (cr);

      tile_xoffset = parse_x_position_unchecked (op->data.tile.tile_xoffset, env);
      tile_yoffset = parse_y_position_unchecked (op->data.tile.tile_yoffset, env);
      /* tile offset should not include x/y */
      tile_xoffset -= rect.x;
      tile_yoffset -= rect.y;

      tile.width = parse_size_unchecked (op->data.tile.tile_width, env);
      tile.height = parse_size_unchecked (op->data.tile.tile_height, env);

      tile.x = rx - tile_xoffset;

      while (tile.x < (rx + rwidth))
        {
          tile.y = ry - tile_yoffset;
          while (tile.y < (ry + rheight))
            {
              meta_draw_op_list_draw_with_style (op->data.tile.op_list,
                                                 style_ctk, cr, info,
                                                 tile);

              tile.y += tile.height;
            }

          tile.x += tile.width;
        }
      cairo_restore (cr);
    }
    break;
  }

cairo_restore (cr);
ctk_style_context_restore (style_ctk);
4429}

4431void
4432meta_draw_op_draw_with_style (const MetaDrawOp    *op,
                            CtkStyleContext     *style_ctk,
                            cairo_t             *cr,
                            const MetaDrawInfo  *info,
                            MetaRectangle        logical_region)
4437{
MetaPositionExprEnv env;

fill_env (&env, info, logical_region);

meta_draw_op_draw_with_env (op,
                            style_ctk,
                            cr,
                            info, logical_region,
                            &env);

4448}

4450void
4451meta_draw_op_draw (const MetaDrawOp    *op,
                 CtkWidget           *widget,
                 cairo_t             *cr,
                 const MetaDrawInfo  *info,
                 MetaRectangle        logical_region)
4456{
meta_draw_op_draw_with_style (op,
                              ctk_widget_get_style_context (widget),
                              cr,
                              info, logical_region);
4461}

4463MetaDrawOpList*
4464meta_draw_op_list_new (int n_preallocs)
4465{
MetaDrawOpList *op_list;

g_return_val_if_fail (n_preallocs >= 0, NULL)do { if ((n_preallocs >= 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "n_preallocs >= 0")
; return (((void*)0)); } } while (0);

op_list = g_new (MetaDrawOpList, 1)((MetaDrawOpList *) g_malloc_n ((1), sizeof (MetaDrawOpList))
);

op_list->refcount = 1;
op_list->n_allocated = n_preallocs;
op_list->ops = g_new (MetaDrawOp*, op_list->n_allocated)((MetaDrawOp* *) g_malloc_n ((op_list->n_allocated), sizeof
 (MetaDrawOp*)));
op_list->n_ops = 0;

return op_list;
4478}

4480void
4481meta_draw_op_list_ref (MetaDrawOpList *op_list)
4482{
g_return_if_fail (op_list != NULL)do { if ((op_list != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "op_list != NULL"); return
; } } while (0);

op_list->refcount += 1;
4486}

4488void
4489meta_draw_op_list_unref (MetaDrawOpList *op_list)
4490{
g_return_if_fail (op_list != NULL)do { if ((op_list != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "op_list != NULL"); return
; } } while (0);
g_return_if_fail (op_list->refcount > 0)do { if ((op_list->refcount > 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "op_list->refcount > 0"
); return; } } while (0);

op_list->refcount -= 1;

if (op_list->refcount == 0)
  {
    int i;

    for (i = 0; i < op_list->n_ops; i++)
      meta_draw_op_free (op_list->ops[i]);

    g_free (op_list->ops);

    DEBUG_FILL_STRUCT (op_list)memset ((op_list), 0xef, sizeof (*(op_list)));
    g_free (op_list);
  }
4508}

4510void
4511meta_draw_op_list_draw_with_style  (const MetaDrawOpList *op_list,
                                  CtkStyleContext      *style_ctk,
                                  cairo_t              *cr,
                                  const MetaDrawInfo   *info,
                                  MetaRectangle         rect)
4516{
/* BOOKMARK */

int i;
MetaPositionExprEnv env;

if (op_list->n_ops == 0)
  return;

fill_env (&env, info, rect);

/* FIXME this can be optimized, potentially a lot, by
 * compressing multiple ops when possible. For example,
 * anything convertible to a pixbuf can be composited
 * client-side, and putting a color tint over a pixbuf
 * can be done without creating the solid-color pixbuf.
 *
 * To implement this my plan is to have the idea of a
 * compiled draw op (with the string expressions already
 * evaluated), we make an array of those, and then fold
 * adjacent items when possible.
 */

cairo_save (cr);

for (i = 0; i < op_list->n_ops; i++)
  {
    MetaDrawOp *op = op_list->ops[i];

    if (op->type == META_DRAW_CLIP)
      {
        cairo_restore (cr);

        cairo_rectangle (cr,
                         parse_x_position_unchecked (op->data.clip.x, &env),
                         parse_y_position_unchecked (op->data.clip.y, &env),
                         parse_size_unchecked (op->data.clip.width, &env),
                         parse_size_unchecked (op->data.clip.height, &env));
        cairo_clip (cr);

        cairo_save (cr);
      }
    else if (cdk_cairo_get_clip_rectangle (cr, NULL((void*)0)))
      {
        meta_draw_op_draw_with_env (op, style_ctk, cr, info, rect, &env);
      }
  }

  cairo_restore (cr);
4565}

4567void
4568meta_draw_op_list_draw  (const MetaDrawOpList *op_list,
                       CtkWidget            *widget,
                       cairo_t              *cr,
                       const MetaDrawInfo   *info,
                       MetaRectangle         rect)

4574{
meta_draw_op_list_draw_with_style (op_list,
                                   ctk_widget_get_style_context (widget),
                                   cr,
                                   info, rect);
4579}

4581void
4582meta_draw_op_list_append (MetaDrawOpList       *op_list,
                        MetaDrawOp           *op)
4584{
if (op_list->n_ops == op_list->n_allocated)
  {
    op_list->n_allocated *= 2;
    op_list->ops = g_renew (MetaDrawOp*, op_list->ops, op_list->n_allocated)((MetaDrawOp* *) g_realloc_n (op_list->ops, (op_list->n_allocated
), sizeof (MetaDrawOp*)));
  }

op_list->ops[op_list->n_ops] = op;
op_list->n_ops += 1;
4593}

4595gboolean
4596meta_draw_op_list_validate (MetaDrawOpList    *op_list,
                          GError           **error)
4598{
g_return_val_if_fail (op_list != NULL, FALSE)do { if ((op_list != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "op_list != NULL"); return
 ((0)); } } while (0);

/* empty lists are OK, nothing else to check really */

return TRUE(!(0));
4604}

4606/* This is not done in validate, since we wouldn't know the name
* of the list to report the error. It might be nice to
* store names inside the list sometime.
*/
4610gboolean
4611meta_draw_op_list_contains (MetaDrawOpList    *op_list,
                          MetaDrawOpList    *child)
4613{
int i;

/* mmm, huge tree recursion */

for (i = 0; i < op_list->n_ops; i++)
  {
    if (op_list->ops[i]->type == META_DRAW_OP_LIST)
      {
        if (op_list->ops[i]->data.op_list.op_list == child)
          return TRUE(!(0));

        if (meta_draw_op_list_contains (op_list->ops[i]->data.op_list.op_list,
                                        child))
          return TRUE(!(0));
      }
    else if (op_list->ops[i]->type == META_DRAW_TILE)
      {
        if (op_list->ops[i]->data.tile.op_list == child)
          return TRUE(!(0));

        if (meta_draw_op_list_contains (op_list->ops[i]->data.tile.op_list,
                                        child))
          return TRUE(!(0));
      }
  }

return FALSE(0);
4641}

4643/**
* Constructor for a MetaFrameStyle.
*
* \param parent  The parent style. Data not filled in here will be
*                looked for in the parent style, and in its parent
*                style, and so on.
*
* \return The newly-constructed style.
*/
4652MetaFrameStyle*
4653meta_frame_style_new (MetaFrameStyle *parent)
4654{
MetaFrameStyle *style;

style = g_new0 (MetaFrameStyle, 1)((MetaFrameStyle *) g_malloc0_n ((1), sizeof (MetaFrameStyle)
));

style->refcount = 1;

/* Default alpha is fully opaque */
style->window_background_alpha = 255;

style->parent = parent;
if (parent)
  meta_frame_style_ref (parent);

return style;
4669}

4671/**
* Increases the reference count of a frame style.
* If the style is NULL, this is a no-op.
*
* \param style  The style.
*/
4677void
4678meta_frame_style_ref (MetaFrameStyle *style)
4679{
g_return_if_fail (style != NULL)do { if ((style != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style != NULL"); return
; } } while (0);

style->refcount += 1;
4683}

4685static void
4686free_button_ops (MetaDrawOpList *op_lists[META_BUTTON_TYPE_LAST][META_BUTTON_STATE_LAST])
4687{
int i, j;

for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
  for (j = 0; j < META_BUTTON_STATE_LAST; j++)
    if (op_lists[i][j])
      meta_draw_op_list_unref (op_lists[i][j]);
4694}

4696void
4697meta_frame_style_unref (MetaFrameStyle *style)
4698{
g_return_if_fail (style != NULL)do { if ((style != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style != NULL"); return
; } } while (0);
g_return_if_fail (style->refcount > 0)do { if ((style->refcount > 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style->refcount > 0"
); return; } } while (0);

style->refcount -= 1;

if (style->refcount == 0)
  {
    int i;

    free_button_ops (style->buttons);

    for (i = 0; i < META_FRAME_PIECE_LAST; i++)
      if (style->pieces[i])
        meta_draw_op_list_unref (style->pieces[i]);

    if (style->layout)
      meta_frame_layout_unref (style->layout);

    if (style->window_background_color)
      meta_color_spec_free (style->window_background_color);

    /* we hold a reference to any parent style */
    if (style->parent)
      meta_frame_style_unref (style->parent);

    DEBUG_FILL_STRUCT (style)memset ((style), 0xef, sizeof (*(style)));
    g_free (style);
  }
4727}

4729static MetaButtonState
4730map_button_state (MetaButtonType           button_type,
                const MetaFrameGeometry *fgeom,
                int                      middle_bg_offset,
                MetaButtonState          button_states[META_BUTTON_TYPE_LAST])
4734{
MetaButtonFunction function = META_BUTTON_FUNCTION_LAST;

switch (button_type)
  {
  /* First handle functions, which map directly */
  case META_BUTTON_TYPE_SHADE:
  case META_BUTTON_TYPE_ABOVE:
  case META_BUTTON_TYPE_STICK:
  case META_BUTTON_TYPE_UNSHADE:
  case META_BUTTON_TYPE_UNABOVE:
  case META_BUTTON_TYPE_UNSTICK:
  case META_BUTTON_TYPE_MENU:
  case META_BUTTON_TYPE_APPMENU:
  case META_BUTTON_TYPE_MINIMIZE:
  case META_BUTTON_TYPE_MAXIMIZE:
  case META_BUTTON_TYPE_CLOSE:
    return button_states[button_type];

  /* Map position buttons to the corresponding function */
  case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
  case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
    if (fgeom->n_right_buttons > 0)
      function = fgeom->button_layout.right_buttons[0];
    break;
  case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
    if (fgeom->n_right_buttons > 0)
      function = fgeom->button_layout.right_buttons[fgeom->n_right_buttons - 1];
    break;
  case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
    if (middle_bg_offset + 1 < fgeom->n_right_buttons)
      function = fgeom->button_layout.right_buttons[middle_bg_offset + 1];
    break;
  case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
  case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
    if (fgeom->n_left_buttons > 0)
      function = fgeom->button_layout.left_buttons[0];
    break;
  case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
    if (fgeom->n_left_buttons > 0)
      function = fgeom->button_layout.left_buttons[fgeom->n_left_buttons - 1];
    break;
  case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
    if (middle_bg_offset + 1 < fgeom->n_left_buttons)
      function = fgeom->button_layout.left_buttons[middle_bg_offset + 1];
    break;
  case META_BUTTON_TYPE_LAST:
    break;
  }

if (function != META_BUTTON_FUNCTION_LAST)
  return button_states[map_button_function_to_type (function)];

return META_BUTTON_STATE_LAST;
4788}

4790static MetaDrawOpList*
4791get_button (MetaFrameStyle *style,
          MetaButtonType  type,
          MetaButtonState state)
4794{
MetaDrawOpList *op_list;
MetaFrameStyle *parent;

parent = style;
op_list = NULL((void*)0);
while (parent && op_list == NULL((void*)0))
  {
    op_list = parent->buttons[type][state];
    parent = parent->parent;
  }

/* We fall back to the side buttons if we don't have
 * single button backgrounds, and to middle button
 * backgrounds if we don't have the ones on the sides
 */

if (op_list == NULL((void*)0) &&
    type == META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND)
  return get_button (style, META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND, state);

if (op_list == NULL((void*)0) &&
    type == META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND)
  return get_button (style, META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND, state);

if (op_list == NULL((void*)0) &&
    (type == META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND ||
     type == META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND))
  return get_button (style, META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND,
                     state);

if (op_list == NULL((void*)0) &&
    (type == META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND ||
     type == META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND))
  return get_button (style, META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND,
                     state);

/* We fall back to normal if no prelight */
if (op_list == NULL((void*)0) &&
    state == META_BUTTON_STATE_PRELIGHT)
  return get_button (style, type, META_BUTTON_STATE_NORMAL);

return op_list;
4837}

4839gboolean
4840meta_frame_style_validate (MetaFrameStyle    *style,
                         guint              current_theme_version,
                         GError           **error)
4843{
int i, j;

g_return_val_if_fail (style != NULL, FALSE)do { if ((style != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style != NULL"); return
 ((0)); } } while (0);
g_return_val_if_fail (style->layout != NULL, FALSE)do { if ((style->layout != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style->layout != NULL"
); return ((0)); } } while (0);

for (i = 0; i < META_BUTTON_TYPE_LAST; i++)
  {
    /* for now the "positional" buttons are optional */
    if (i >= META_BUTTON_TYPE_CLOSE)
      {
        for (j = 0; j < META_BUTTON_STATE_LAST; j++)
          {
            if (get_button (style, i, j) == NULL((void*)0) &&
                meta_theme_earliest_version_with_button (i) <= current_theme_version
                )
              {
                g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                             META_THEME_ERROR_FAILED,
                             _("<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be specified for this frame style")dgettext ("croma", "<button function=\"%s\" state=\"%s\" draw_ops=\"whatever\"/> must be specified for this frame style"
),
                             meta_button_type_to_string (i),
                             meta_button_state_to_string (j));
                return FALSE(0);
              }
          }
      }
  }

return TRUE(!(0));
4872}

4874static void
4875get_button_rect (MetaButtonType           type,
               const MetaFrameGeometry *fgeom,
               int                      middle_background_offset,
               CdkRectangle            *rect)
4879{
switch (type)
  {
  case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
    *rect = fgeom->left_left_background;
    break;

  case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
    *rect = fgeom->left_middle_backgrounds[middle_background_offset];
    break;

  case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
    *rect = fgeom->left_right_background;
    break;

  case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
    *rect = fgeom->left_single_background;
    break;

  case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
    *rect = fgeom->right_left_background;
    break;

  case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
    *rect = fgeom->right_middle_backgrounds[middle_background_offset];
    break;

  case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
    *rect = fgeom->right_right_background;
    break;

  case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
    *rect = fgeom->right_single_background;
    break;

  case META_BUTTON_TYPE_CLOSE:
    *rect = fgeom->close_rect.visible;
    break;

  case META_BUTTON_TYPE_SHADE:
    *rect = fgeom->shade_rect.visible;
    break;

  case META_BUTTON_TYPE_UNSHADE:
    *rect = fgeom->unshade_rect.visible;
    break;

  case META_BUTTON_TYPE_ABOVE:
    *rect = fgeom->above_rect.visible;
    break;

  case META_BUTTON_TYPE_UNABOVE:
    *rect = fgeom->unabove_rect.visible;
    break;

  case META_BUTTON_TYPE_STICK:
    *rect = fgeom->stick_rect.visible;
    break;

  case META_BUTTON_TYPE_UNSTICK:
    *rect = fgeom->unstick_rect.visible;
    break;

  case META_BUTTON_TYPE_MAXIMIZE:
    *rect = fgeom->max_rect.visible;
    break;

  case META_BUTTON_TYPE_MINIMIZE:
    *rect = fgeom->min_rect.visible;
    break;

  case META_BUTTON_TYPE_MENU:
    *rect = fgeom->menu_rect.visible;
    break;

  case META_BUTTON_TYPE_APPMENU:
    *rect = fgeom->appmenu_rect.visible;
    break;

  case META_BUTTON_TYPE_LAST:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 4959, (
(const char*) (__func__)), ((void*)0)); } while (0);
    break;
  }
4962}

4964void
4965meta_frame_style_draw_with_style (MetaFrameStyle          *style,
                                CtkStyleContext         *style_ctk,
                                cairo_t                 *cr,
                                const MetaFrameGeometry *fgeom,
                                int                      client_width,
                                int                      client_height,
                                PangoLayout             *title_layout,
                                int                      text_height,
                                MetaButtonState          button_states[META_BUTTON_TYPE_LAST],
                                GdkPixbuf               *mini_icon,
                                GdkPixbuf               *icon)
4976{
  /* BOOKMARK */
int i, j;
CdkRectangle visible_rect;
CdkRectangle titlebar_rect;
CdkRectangle left_titlebar_edge;
CdkRectangle right_titlebar_edge;
CdkRectangle bottom_titlebar_edge;
CdkRectangle top_titlebar_edge;
CdkRectangle left_edge, right_edge, bottom_edge;
PangoRectangle extents;
MetaDrawInfo draw_info;
const MetaFrameBorders *borders;

borders = &fgeom->borders;

visible_rect.x = borders->invisible.left;
visible_rect.y = borders->invisible.top;
visible_rect.width = fgeom->width - borders->invisible.left - borders->invisible.right;
visible_rect.height = fgeom->height - borders->invisible.top - borders->invisible.bottom;

titlebar_rect.x = visible_rect.x;
titlebar_rect.y = visible_rect.y;
titlebar_rect.width = visible_rect.width;
titlebar_rect.height = borders->visible.top;

left_titlebar_edge.x = titlebar_rect.x;
left_titlebar_edge.y = titlebar_rect.y + fgeom->top_titlebar_edge;
left_titlebar_edge.width = fgeom->left_titlebar_edge;
left_titlebar_edge.height = titlebar_rect.height - fgeom->top_titlebar_edge - fgeom->bottom_titlebar_edge;

right_titlebar_edge.y = left_titlebar_edge.y;
right_titlebar_edge.height = left_titlebar_edge.height;
right_titlebar_edge.width = fgeom->right_titlebar_edge;
right_titlebar_edge.x = titlebar_rect.x + titlebar_rect.width - right_titlebar_edge.width;

top_titlebar_edge.x = titlebar_rect.x;
top_titlebar_edge.y = titlebar_rect.y;
top_titlebar_edge.width = titlebar_rect.width;
top_titlebar_edge.height = fgeom->top_titlebar_edge;

bottom_titlebar_edge.x = titlebar_rect.x;
bottom_titlebar_edge.width = titlebar_rect.width;
bottom_titlebar_edge.height = fgeom->bottom_titlebar_edge;
bottom_titlebar_edge.y = titlebar_rect.y + titlebar_rect.height - bottom_titlebar_edge.height;

left_edge.x = visible_rect.x;
left_edge.y = visible_rect.y + borders->visible.top;
left_edge.width = borders->visible.left;
left_edge.height = visible_rect.height - borders->visible.top - borders->visible.bottom;

right_edge.x = visible_rect.x + visible_rect.width - borders->visible.right;
right_edge.y = visible_rect.y + borders->visible.top;
right_edge.width = borders->visible.right;
right_edge.height = visible_rect.height - borders->visible.top - borders->visible.bottom;

bottom_edge.x = visible_rect.x;
bottom_edge.y = visible_rect.y + visible_rect.height - borders->visible.bottom;
bottom_edge.width = visible_rect.width;
bottom_edge.height = borders->visible.bottom;

if (title_layout)
  pango_layout_get_pixel_extents (title_layout,
                                  NULL((void*)0), &extents);

draw_info.mini_icon = mini_icon;
draw_info.icon = icon;
draw_info.title_layout = title_layout;
draw_info.title_layout_width = title_layout ? extents.width : 0;
draw_info.title_layout_height = title_layout ? extents.height : 0;
draw_info.fgeom = fgeom;

/* The enum is in the order the pieces should be rendered. */
i = 0;
while (i < META_FRAME_PIECE_LAST)
  {
    CdkRectangle rect;

    switch ((MetaFramePiece) i)
      {
      case META_FRAME_PIECE_ENTIRE_BACKGROUND:
        rect = visible_rect;
        break;

      case META_FRAME_PIECE_TITLEBAR:
        rect = titlebar_rect;
        break;

      case META_FRAME_PIECE_LEFT_TITLEBAR_EDGE:
        rect = left_titlebar_edge;
        break;

      case META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE:
        rect = right_titlebar_edge;
        break;

      case META_FRAME_PIECE_TOP_TITLEBAR_EDGE:
        rect = top_titlebar_edge;
        break;

      case META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE:
        rect = bottom_titlebar_edge;
        break;

      case META_FRAME_PIECE_TITLEBAR_MIDDLE:
        rect.x = left_titlebar_edge.x + left_titlebar_edge.width;
        rect.y = top_titlebar_edge.y + top_titlebar_edge.height;
        rect.width = titlebar_rect.width - left_titlebar_edge.width -
          right_titlebar_edge.width;
        rect.height = titlebar_rect.height - top_titlebar_edge.height - bottom_titlebar_edge.height;
        break;

      case META_FRAME_PIECE_TITLE:
        rect = fgeom->title_rect;
        break;

      case META_FRAME_PIECE_LEFT_EDGE:
        rect = left_edge;
        break;

      case META_FRAME_PIECE_RIGHT_EDGE:
        rect = right_edge;
        break;

      case META_FRAME_PIECE_BOTTOM_EDGE:
        rect = bottom_edge;
        break;

      case META_FRAME_PIECE_OVERLAY:
        rect = visible_rect;
        break;

      case META_FRAME_PIECE_LAST:
        g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5109, (
(const char*) (__func__)), ((void*)0)); } while (0);
        break;
      }

    cairo_save (cr);

    cdk_cairo_rectangle (cr, &rect);
    cairo_clip (cr);

    if (cdk_cairo_get_clip_rectangle (cr, NULL((void*)0)))
      {
        MetaDrawOpList *op_list;
        MetaFrameStyle *parent;

        parent = style;
        op_list = NULL((void*)0);
        while (parent && op_list == NULL((void*)0))
          {
            op_list = parent->pieces[i];
            parent = parent->parent;
          }

        if (op_list)
          {
            MetaRectangle m_rect;
            m_rect = meta_rect (rect.x, rect.y, rect.width, rect.height);
            meta_draw_op_list_draw_with_style (op_list,
                                               style_ctk,
                                               cr,
                                               &draw_info,
                                               m_rect);
          }
      }

    cairo_restore (cr);

    /* Draw buttons just before overlay */
    if ((i + 1) == META_FRAME_PIECE_OVERLAY)
      {
        int middle_bg_offset;

        middle_bg_offset = 0;
        j = 0;
        while (j < META_BUTTON_TYPE_LAST)
          {
            MetaDrawOpList *op_list;
            MetaButtonState button_state;

            get_button_rect (j, fgeom, middle_bg_offset, &rect);

            button_state = map_button_state (j, fgeom, middle_bg_offset, button_states);
            op_list = get_button (style, j, button_state);

            if (op_list)
              {
                cairo_save (cr);
                cdk_cairo_rectangle (cr, &rect);
                cairo_clip (cr);

                if (cdk_cairo_get_clip_rectangle (cr, NULL((void*)0)))
                  {
                    MetaRectangle m_rect;

                    m_rect = meta_rect (rect.x, rect.y,
                                        rect.width, rect.height);

                    meta_draw_op_list_draw_with_style (op_list,
                                                       style_ctk,
                                                       cr,
                                                       &draw_info,
                                                       m_rect);
                  }

                cairo_restore (cr);
              }

            /* MIDDLE_BACKGROUND type may get drawn more than once */
            if ((j == META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND ||
                 j == META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND) &&
                middle_bg_offset < MAX_MIDDLE_BACKGROUNDS(META_BUTTON_FUNCTION_LAST - 2))
              {
                ++middle_bg_offset;
              }
            else
              {
                middle_bg_offset = 0;
                ++j;
              }
          }
      }

    ++i;
  }
5202}

5204void
5205meta_frame_style_draw (MetaFrameStyle          *style,
                     CtkWidget               *widget,
                     cairo_t                 *cr,
                     const MetaFrameGeometry *fgeom,
                     int                      client_width,
                     int                      client_height,
                     PangoLayout             *title_layout,
                     int                      text_height,
                     MetaButtonState          button_states[META_BUTTON_TYPE_LAST],
                     GdkPixbuf               *mini_icon,
                     GdkPixbuf               *icon)
5216{
meta_frame_style_draw_with_style (style,
                                  ctk_widget_get_style_context (widget),
                                  cr,
                                  fgeom, client_width, client_height,
                                  title_layout, text_height,
                                  button_states, mini_icon, icon);
5223}

5225MetaFrameStyleSet*
5226meta_frame_style_set_new (MetaFrameStyleSet *parent)
5227{
MetaFrameStyleSet *style_set;

style_set = g_new0 (MetaFrameStyleSet, 1)((MetaFrameStyleSet *) g_malloc0_n ((1), sizeof (MetaFrameStyleSet
)));

style_set->parent = parent;
if (parent)
  meta_frame_style_set_ref (parent);

style_set->refcount = 1;

return style_set;
5239}

5241static void
5242free_focus_styles (MetaFrameStyle *focus_styles[META_FRAME_FOCUS_LAST])
5243{
int i;

for (i = 0; i < META_FRAME_FOCUS_LAST; i++)
  if (focus_styles[i])
    meta_frame_style_unref (focus_styles[i]);
5249}

5251void
5252meta_frame_style_set_ref (MetaFrameStyleSet *style_set)
5253{
g_return_if_fail (style_set != NULL)do { if ((style_set != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style_set != NULL"); return
; } } while (0);

style_set->refcount += 1;
5257}

5259void
5260meta_frame_style_set_unref (MetaFrameStyleSet *style_set)
5261{
g_return_if_fail (style_set != NULL)do { if ((style_set != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style_set != NULL"); return
; } } while (0);
g_return_if_fail (style_set->refcount > 0)do { if ((style_set->refcount > 0)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style_set->refcount > 0"
); return; } } while (0);

style_set->refcount -= 1;

if (style_set->refcount == 0)
  {
    int i;

    for (i = 0; i < META_FRAME_RESIZE_LAST; i++)
      {
        free_focus_styles (style_set->normal_styles[i]);
        free_focus_styles (style_set->shaded_styles[i]);
      }

    free_focus_styles (style_set->maximized_styles);
    free_focus_styles (style_set->tiled_left_styles);
    free_focus_styles (style_set->tiled_right_styles);
    free_focus_styles (style_set->maximized_and_shaded_styles);
    free_focus_styles (style_set->tiled_left_and_shaded_styles);
    free_focus_styles (style_set->tiled_right_and_shaded_styles);

    if (style_set->parent)
      meta_frame_style_set_unref (style_set->parent);

    DEBUG_FILL_STRUCT (style_set)memset ((style_set), 0xef, sizeof (*(style_set)));
    g_free (style_set);
  }
5290}


5293static MetaFrameStyle*
5294get_style (MetaFrameStyleSet *style_set,
         MetaFrameState     state,
         MetaFrameResize    resize,
         MetaFrameFocus     focus)
5298{
MetaFrameStyle *style;

style = NULL((void*)0);

switch (state)
  {
  case META_FRAME_STATE_NORMAL:
  case META_FRAME_STATE_SHADED:
    {
      if (state == META_FRAME_STATE_SHADED)
        style = style_set->shaded_styles[resize][focus];
      else
        style = style_set->normal_styles[resize][focus];

      /* Try parent if we failed here */
      if (style == NULL((void*)0) && style_set->parent)
        style = get_style (style_set->parent, state, resize, focus);

      /* Allow people to omit the vert/horz/none resize modes */
      if (style == NULL((void*)0) &&
          resize != META_FRAME_RESIZE_BOTH)
        style = get_style (style_set, state, META_FRAME_RESIZE_BOTH, focus);
    }
    break;
  default:
    {
      MetaFrameStyle **styles;

      styles = NULL((void*)0);

      switch (state)
        {
        case META_FRAME_STATE_MAXIMIZED:
          styles = style_set->maximized_styles;
          break;
        case META_FRAME_STATE_TILED_LEFT:
          styles = style_set->tiled_left_styles;
          break;
        case META_FRAME_STATE_TILED_RIGHT:
          styles = style_set->tiled_right_styles;
          break;
        case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
          styles = style_set->maximized_and_shaded_styles;
          break;
        case META_FRAME_STATE_TILED_LEFT_AND_SHADED:
          styles = style_set->tiled_left_and_shaded_styles;
          break;
        case META_FRAME_STATE_TILED_RIGHT_AND_SHADED:
          styles = style_set->tiled_right_and_shaded_styles;
          break;
        case META_FRAME_STATE_NORMAL:
        case META_FRAME_STATE_SHADED:
        case META_FRAME_STATE_LAST:
          g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5352, (
(const char*) (__func__)), ((void*)0)); } while (0);
          break;
        }

      style = styles[focus];

      /* Tiled states are optional, try falling back to non-tiled states */
      if (style == NULL((void*)0))
        {
          if (state == META_FRAME_STATE_TILED_LEFT ||
              state == META_FRAME_STATE_TILED_RIGHT)
            style = get_style (style_set, META_FRAME_STATE_NORMAL,
                               resize, focus);
          else if (state == META_FRAME_STATE_TILED_LEFT_AND_SHADED ||
                   state == META_FRAME_STATE_TILED_RIGHT_AND_SHADED)
            style = get_style (style_set, META_FRAME_STATE_SHADED,
                               resize, focus);
        }

      /* Try parent if we failed here */
      if (style == NULL((void*)0) && style_set->parent)
        style = get_style (style_set->parent, state, resize, focus);
    }
  }

return style;
5378}

5380static gboolean
5381check_state  (MetaFrameStyleSet *style_set,
            MetaFrameState     state,
            GError           **error)
5384{
int i;

for (i = 0; i < META_FRAME_FOCUS_LAST; i++)
  {
    if (get_style (style_set, state,
                   META_FRAME_RESIZE_NONE, i) == NULL((void*)0))
      {
        /* Translators: This error occurs when a <frame> tag is missing
         * in theme XML.  The "<frame ...>" is intended as a noun phrase,
         * and the "missing" qualifies it.  You should translate "whatever".
         */
        g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>")dgettext ("croma", "Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"
),
                     meta_frame_state_to_string (state),
                     meta_frame_resize_to_string (META_FRAME_RESIZE_NONE),
                     meta_frame_focus_to_string (i));
        return FALSE(0);
      }
  }

return TRUE(!(0));
5407}

5409gboolean
5410meta_frame_style_set_validate  (MetaFrameStyleSet *style_set,
                              GError           **error)
5412{
int i, j;

g_return_val_if_fail (style_set != NULL, FALSE)do { if ((style_set != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "style_set != NULL"); return
 ((0)); } } while (0);

for (i = 0; i < META_FRAME_RESIZE_LAST; i++)
  for (j = 0; j < META_FRAME_FOCUS_LAST; j++)
    if (get_style (style_set, META_FRAME_STATE_NORMAL, i, j) == NULL((void*)0))
      {
        g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")),
                     META_THEME_ERROR_FAILED,
                     _("Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>")dgettext ("croma", "Missing <frame state=\"%s\" resize=\"%s\" focus=\"%s\" style=\"whatever\"/>"
),
                     meta_frame_state_to_string (META_FRAME_STATE_NORMAL),
                     meta_frame_resize_to_string (i),
                     meta_frame_focus_to_string (j));
        return FALSE(0);
      }

if (!check_state (style_set, META_FRAME_STATE_SHADED, error))
  return FALSE(0);

if (!check_state (style_set, META_FRAME_STATE_MAXIMIZED, error))
  return FALSE(0);

if (!check_state (style_set, META_FRAME_STATE_MAXIMIZED_AND_SHADED, error))
  return FALSE(0);

return TRUE(!(0));
5440}

5442MetaTheme*
5443meta_theme_get_current (void)
5444{
return meta_current_theme;
5446}

5448void
5449meta_theme_set_current (const char *name,
                      gboolean    force_reload)
5451{
MetaTheme *new_theme;
GError *err;

meta_topicmeta_topic_real (META_DEBUG_THEMES, "Setting current theme to \"%s\"\n", name);

if (!force_reload &&
    meta_current_theme &&
    strcmp (name, meta_current_theme->name) == 0)
  return;

err = NULL((void*)0);
new_theme = meta_theme_load (name, &err);

if (new_theme == NULL((void*)0))
  {
    meta_warning (_("Failed to load theme \"%s\": %s\n")dgettext ("croma", "Failed to load theme \"%s\": %s\n"),
                  name, err->message);
    g_error_free (err);
  }
else
  {
    if (meta_current_theme)
      meta_theme_free (meta_current_theme);

    meta_current_theme = new_theme;

    meta_topicmeta_topic_real (META_DEBUG_THEMES, "New theme is \"%s\"\n", meta_current_theme->name);
  }
5480}

5482MetaTheme*
5483meta_theme_new (void)
5484{
MetaTheme *theme;

theme = g_new0 (MetaTheme, 1)((MetaTheme *) g_malloc0_n ((1), sizeof (MetaTheme)));

theme->images_by_filename =
  g_hash_table_new_full (g_str_hash,
                         g_str_equal,
                         g_free,
                         g_object_unref);

theme->layouts_by_name =
  g_hash_table_new_full (g_str_hash,
                         g_str_equal,
                         g_free,
                         (GDestroyNotify) meta_frame_layout_unref);

theme->draw_op_lists_by_name =
  g_hash_table_new_full (g_str_hash,
                         g_str_equal,
                         g_free,
                         (GDestroyNotify) meta_draw_op_list_unref);

theme->styles_by_name =
  g_hash_table_new_full (g_str_hash,
                         g_str_equal,
                         g_free,
                         (GDestroyNotify) meta_frame_style_unref);

theme->style_sets_by_name =
  g_hash_table_new_full (g_str_hash,
                         g_str_equal,
                         g_free,
                         (GDestroyNotify) meta_frame_style_set_unref);

/* Create our variable quarks so we can look up variables without
   having to strcmp for the names */
theme->quark_width = g_quark_from_static_string ("width");
theme->quark_height = g_quark_from_static_string ("height");
theme->quark_object_width = g_quark_from_static_string ("object_width");
theme->quark_object_height = g_quark_from_static_string ("object_height");
theme->quark_left_width = g_quark_from_static_string ("left_width");
theme->quark_right_width = g_quark_from_static_string ("right_width");
theme->quark_top_height = g_quark_from_static_string ("top_height");
theme->quark_bottom_height = g_quark_from_static_string ("bottom_height");
theme->quark_mini_icon_width = g_quark_from_static_string ("mini_icon_width");
theme->quark_mini_icon_height = g_quark_from_static_string ("mini_icon_height");
theme->quark_icon_width = g_quark_from_static_string ("icon_width");
theme->quark_icon_height = g_quark_from_static_string ("icon_height");
theme->quark_title_width = g_quark_from_static_string ("title_width");
theme->quark_title_height = g_quark_from_static_string ("title_height");
theme->quark_frame_x_center = g_quark_from_static_string ("frame_x_center");
theme->quark_frame_y_center = g_quark_from_static_string ("frame_y_center");
return theme;
5538}


5541void
5542meta_theme_free (MetaTheme *theme)
5543{
int i;

g_return_if_fail (theme != NULL)do { if ((theme != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "theme != NULL"); return
; } } while (0);

g_free (theme->name);
g_free (theme->dirname);
g_free (theme->filename);
g_free (theme->readable_name);
g_free (theme->date);
g_free (theme->description);
g_free (theme->author);
g_free (theme->copyright);

/* be more careful when destroying the theme hash tables,
   since they are only constructed as needed, and may be NULL. */
if (theme->integer_constants)
  g_hash_table_destroy (theme->integer_constants);
if (theme->images_by_filename)
  g_hash_table_destroy (theme->images_by_filename);
if (theme->layouts_by_name)
  g_hash_table_destroy (theme->layouts_by_name);
if (theme->draw_op_lists_by_name)
  g_hash_table_destroy (theme->draw_op_lists_by_name);
if (theme->styles_by_name)
  g_hash_table_destroy (theme->styles_by_name);
if (theme->style_sets_by_name)
  g_hash_table_destroy (theme->style_sets_by_name);

for (i = 0; i < META_FRAME_TYPE_LAST; i++)
  if (theme->style_sets_by_type[i])
    meta_frame_style_set_unref (theme->style_sets_by_type[i]);

DEBUG_FILL_STRUCT (theme)memset ((theme), 0xef, sizeof (*(theme)));
g_free (theme);
5578}

5580gboolean
5581meta_theme_validate (MetaTheme *theme,
                   GError   **error)
5583{
int i;

g_return_val_if_fail (theme != NULL, FALSE)do { if ((theme != ((void*)0))) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "theme != NULL"); return
 ((0)); } } while (0);

/* FIXME what else should be checked? */

g_assert (theme->name)do { if (theme->name) ; else g_assertion_message_expr ("croma"
, "ui/theme.c", 5590, ((const char*) (__func__)), "theme->name"
); } while (0);

if (theme->readable_name == NULL((void*)0))
  {
    /* Translators: This error means that a necessary XML tag (whose name
     * is given in angle brackets) was not found in a given theme (whose
     * name is given second, in quotation marks).
     */
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "name", theme->name);
    return FALSE(0);
  }

if (theme->author == NULL((void*)0))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "author", theme->name);
    return FALSE(0);
  }

if (theme->date == NULL((void*)0))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "date", theme->name);
    return FALSE(0);
  }

if (theme->description == NULL((void*)0))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "description", theme->name);
    return FALSE(0);
  }

if (theme->copyright == NULL((void*)0))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("No <%s> set for theme \"%s\"")dgettext ("croma", "No <%s> set for theme \"%s\""), "copyright", theme->name);
    return FALSE(0);
  }

for (i = 0; i < (int)META_FRAME_TYPE_LAST; i++)
  if (i != (int)META_FRAME_TYPE_ATTACHED && theme->style_sets_by_type[i] == NULL((void*)0))
    {
      g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                   _("No frame style set for window type \"%s\" in theme \"%s\", add a <window type=\"%s\" style_set=\"whatever\"/> element")dgettext ("croma", "No frame style set for window type \"%s\" in theme \"%s\", add a <window type=\"%s\" style_set=\"whatever\"/> element"
),
                   meta_frame_type_to_string (i),
                   theme->name,
                   meta_frame_type_to_string (i));

      return FALSE(0);
    }

return TRUE(!(0));
5644}

5646GdkPixbuf*
5647meta_theme_load_image (MetaTheme  *theme,
                     const char *filename,
                     guint size_of_theme_icons,
                     GError    **error)
5651{
GdkPixbuf *pixbuf;
int scale;

pixbuf = g_hash_table_lookup (theme->images_by_filename,
                              filename);

scale = cdk_window_get_scale_factor (cdk_get_default_root_window ());

if (pixbuf == NULL((void*)0))
  {

    if (g_str_has_prefix (filename, "theme:")(__builtin_constant_p ("theme:")? __extension__ ({ const char
 * const __str = (filename); const char * const __prefix = ("theme:"
); gboolean __result = (0); if (__str == ((void*)0) || __prefix
 == ((void*)0)) __result = (g_str_has_prefix) (__str, __prefix
); else { const size_t __str_len = strlen (((__str) + !(__str
))); const size_t __prefix_len = strlen (((__prefix) + !(__prefix
))); if (__str_len >= __prefix_len) __result = memcmp (((__str
) + !(__str)), ((__prefix) + !(__prefix)), __prefix_len) == 0
; } __result; }) : (g_str_has_prefix) (filename, "theme:") ) &&
        META_THEME_ALLOWS (theme, META_THEME_IMAGES_FROM_ICON_THEMES)(theme->format_version >= 2))
      {
        pixbuf = ctk_icon_theme_load_icon_for_scale (
            ctk_icon_theme_get_default (),
            filename+6,
            size_of_theme_icons,
            scale,
            0,
            error);
        if (pixbuf == NULL((void*)0)) return NULL((void*)0);
       }
    else
      {
        char *full_path;
        full_path = g_build_filename (theme->dirname, filename, NULL((void*)0));

        gint width, height;

        if (gdk_pixbuf_get_file_info (full_path, &width, &height) == NULL((void*)0))
          {
            g_free (full_path);
            return NULL((void*)0);
          }

        width *= scale;
        height *= scale;

        pixbuf = gdk_pixbuf_new_from_file_at_size (full_path, width, height, error);

        if (pixbuf == NULL((void*)0))
          {
            g_free (full_path);
            return NULL((void*)0);
          }

        g_free (full_path);
      }
    g_hash_table_replace (theme->images_by_filename,
                          g_strdup (filename)g_strdup_inline (filename),
                          pixbuf);
  }

g_assert (pixbuf)do { if (pixbuf) ; else g_assertion_message_expr ("croma", "ui/theme.c"
, 5706, ((const char*) (__func__)), "pixbuf"); } while (0);

g_object_ref (G_OBJECT (pixbuf))((__typeof__ (((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((pixbuf)), (((GType) ((20) << (2)))
))))))) (g_object_ref) (((((GObject*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((pixbuf)), (((GType) ((20) << (2)))
)))))));

return pixbuf;
5711}

5713static MetaFrameStyle*
5714theme_get_style (MetaTheme     *theme,
               MetaFrameType  type,
               MetaFrameFlags flags)
5717{
MetaFrameState state;
MetaFrameResize resize;
MetaFrameFocus focus;
MetaFrameStyle *style;
MetaFrameStyleSet *style_set;

style_set = theme->style_sets_by_type[type];

if (style_set == NULL((void*)0) && type == META_FRAME_TYPE_ATTACHED)
  style_set = theme->style_sets_by_type[META_FRAME_TYPE_BORDER];

/* Right now the parser forces a style set for all other types,
 * but this fallback code is here in case I take that out.
 */
if (style_set == NULL((void*)0))
  style_set = theme->style_sets_by_type[META_FRAME_TYPE_NORMAL];
if (style_set == NULL((void*)0))
  return NULL((void*)0);

switch (flags & (META_FRAME_MAXIMIZED | META_FRAME_SHADED | META_FRAME_TILED_LEFT | META_FRAME_TILED_RIGHT))
  {
  case 0:
    state = META_FRAME_STATE_NORMAL;
    break;
  case META_FRAME_MAXIMIZED:
    state = META_FRAME_STATE_MAXIMIZED;
    break;
  case META_FRAME_TILED_LEFT:
  case (META_FRAME_MAXIMIZED | META_FRAME_TILED_LEFT):
    state = META_FRAME_STATE_TILED_LEFT;
    break;
  case META_FRAME_TILED_RIGHT:
  case (META_FRAME_MAXIMIZED | META_FRAME_TILED_RIGHT):
    state = META_FRAME_STATE_TILED_RIGHT;
    break;
  case META_FRAME_SHADED:
    state = META_FRAME_STATE_SHADED;
    break;
  case (META_FRAME_MAXIMIZED | META_FRAME_SHADED):
    state = META_FRAME_STATE_MAXIMIZED_AND_SHADED;
    break;
  case (META_FRAME_TILED_LEFT | META_FRAME_SHADED):
    state = META_FRAME_STATE_TILED_LEFT_AND_SHADED;
    break;
  case (META_FRAME_TILED_RIGHT | META_FRAME_SHADED):
    state = META_FRAME_STATE_TILED_RIGHT_AND_SHADED;
    break;
  default:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5766, (
(const char*) (__func__)), ((void*)0)); } while (0);
    state = META_FRAME_STATE_LAST; /* compiler */
    break;
  }

switch (flags & (META_FRAME_ALLOWS_VERTICAL_RESIZE | META_FRAME_ALLOWS_HORIZONTAL_RESIZE))
  {
  case 0:
    resize = META_FRAME_RESIZE_NONE;
    break;
  case META_FRAME_ALLOWS_VERTICAL_RESIZE:
    resize = META_FRAME_RESIZE_VERTICAL;
    break;
  case META_FRAME_ALLOWS_HORIZONTAL_RESIZE:
    resize = META_FRAME_RESIZE_HORIZONTAL;
    break;
  case (META_FRAME_ALLOWS_VERTICAL_RESIZE | META_FRAME_ALLOWS_HORIZONTAL_RESIZE):
    resize = META_FRAME_RESIZE_BOTH;
    break;
  default:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 5786, (
(const char*) (__func__)), ((void*)0)); } while (0);
    resize = META_FRAME_RESIZE_LAST; /* compiler */
    break;
  }

/* re invert the styles used for focus/unfocussed while flashing a frame */
if (((flags & META_FRAME_HAS_FOCUS) && !(flags & META_FRAME_IS_FLASHING))
    || (!(flags & META_FRAME_HAS_FOCUS) && (flags & META_FRAME_IS_FLASHING)))
  focus = META_FRAME_FOCUS_YES;
else
  focus = META_FRAME_FOCUS_NO;

style = get_style (style_set, state, resize, focus);

return style;
5801}

5803MetaFrameStyle*
5804meta_theme_get_frame_style (MetaTheme     *theme,
                          MetaFrameType  type,
                          MetaFrameFlags flags)
5807{
MetaFrameStyle *style;

g_return_val_if_fail (type < META_FRAME_TYPE_LAST, NULL)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST"
); return (((void*)0)); } } while (0);

style = theme_get_style (theme, type, flags);

return style;
5815}

5817double
5818meta_theme_get_title_scale (MetaTheme     *theme,
                          MetaFrameType  type,
                          MetaFrameFlags flags)
5821{
MetaFrameStyle *style;

g_return_val_if_fail (type < META_FRAME_TYPE_LAST, 1.0)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST"
); return (1.0); } } while (0);

style = theme_get_style (theme, type, flags);

/* Parser is not supposed to allow this currently */
if (style == NULL((void*)0))
  return 1.0;

return style->layout->title_scale;
5833}

5835void
5836meta_theme_draw_frame (MetaTheme              *theme,
                     CtkStyleContext        *style_ctk,
                     cairo_t                *cr,
                     MetaFrameType           type,
                     MetaFrameFlags          flags,
                     int                     client_width,
                     int                     client_height,
                     PangoLayout            *title_layout,
                     int                     text_height,
                     const MetaButtonLayout *button_layout,
                     MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
                     GdkPixbuf              *mini_icon,
                     GdkPixbuf              *icon)
5849{
MetaFrameGeometry fgeom;
MetaFrameStyle *style;

g_return_if_fail (type < META_FRAME_TYPE_LAST)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST"
); return; } } while (0);

style = theme_get_style (theme, type, flags);

/* Parser is not supposed to allow this currently */
if (style == NULL((void*)0))
  return;

meta_frame_layout_calc_geometry (style->layout,
                                 text_height,
                                 flags,
                                 client_width, client_height,
                                 button_layout,
                                 &fgeom,
                                 theme);

meta_frame_style_draw_with_style (style,
                                  style_ctk,
                                  cr,
                                  &fgeom,
                                  client_width, client_height,
                                  title_layout,
                                  text_height,
                                  button_states,
                                  mini_icon, icon);
5878}

5880void
5881meta_theme_draw_frame_by_name (MetaTheme              *theme,
                             CtkWidget              *widget,
                             cairo_t                *cr,
                             const gchar             *style_name,
                             MetaFrameFlags          flags,
                             int                     client_width,
                             int                     client_height,
                             PangoLayout            *title_layout,
                             int                     text_height,
                             const MetaButtonLayout *button_layout,
                             MetaButtonState         button_states[META_BUTTON_TYPE_LAST],
                             GdkPixbuf              *mini_icon,
                             GdkPixbuf              *icon)
5894{
MetaFrameGeometry fgeom;
MetaFrameStyle *style;

style = meta_theme_lookup_style (theme, style_name);

/* Parser is not supposed to allow this currently */
if (style == NULL((void*)0))
  return;

meta_frame_layout_calc_geometry (style->layout,
                                 text_height,
                                 flags,
                                 client_width, client_height,
                                 button_layout,
                                 &fgeom,
                                 theme);

meta_frame_style_draw (style,
                       widget,
                       cr,
                       &fgeom,
                       client_width, client_height,
                       title_layout,
                       text_height,
                       button_states,
                       mini_icon, icon);
5921}

5923void
5924meta_theme_get_frame_borders (MetaTheme        *theme,
                            MetaFrameType     type,
                            int               text_height,
                            MetaFrameFlags    flags,
                            MetaFrameBorders *borders)
5929{
MetaFrameStyle *style;

g_return_if_fail (type < META_FRAME_TYPE_LAST)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST"
); return; } } while (0);

style = theme_get_style (theme, type, flags);

meta_frame_borders_clear (borders);

/* Parser is not supposed to allow this currently */
if (style == NULL((void*)0))
  return;

meta_frame_layout_get_borders (style->layout,
                               text_height,
                               flags,
                               borders);
5946}

5948void
5949meta_theme_calc_geometry (MetaTheme              *theme,
                        MetaFrameType           type,
                        int                     text_height,
                        MetaFrameFlags          flags,
                        int                     client_width,
                        int                     client_height,
                        const MetaButtonLayout *button_layout,
                        MetaFrameGeometry      *fgeom)
5957{
MetaFrameStyle *style;

g_return_if_fail (type < META_FRAME_TYPE_LAST)do { if ((type < META_FRAME_TYPE_LAST)) { } else { g_return_if_fail_warning
 ("croma", ((const char*) (__func__)), "type < META_FRAME_TYPE_LAST"
); return; } } while (0);

style = theme_get_style (theme, type, flags);

/* Parser is not supposed to allow this currently */
if (style == NULL((void*)0))
  return;

meta_frame_layout_calc_geometry (style->layout,
                                 text_height,
                                 flags,
                                 client_width, client_height,
                                 button_layout,
                                 fgeom,
                                 theme);
5975}

5977MetaFrameLayout*
5978meta_theme_lookup_layout (MetaTheme         *theme,
                        const char        *name)
5980{
return g_hash_table_lookup (theme->layouts_by_name, name);
5982}

5984void
5985meta_theme_insert_layout (MetaTheme         *theme,
                        const char        *name,
                        MetaFrameLayout   *layout)
5988{
meta_frame_layout_ref (layout);
g_hash_table_replace (theme->layouts_by_name, g_strdup (name)g_strdup_inline (name), layout);
5991}

5993MetaDrawOpList*
5994meta_theme_lookup_draw_op_list (MetaTheme         *theme,
                              const char        *name)
5996{
return g_hash_table_lookup (theme->draw_op_lists_by_name, name);
5998}

6000void
6001meta_theme_insert_draw_op_list (MetaTheme         *theme,
                              const char        *name,
                              MetaDrawOpList    *op_list)
6004{
meta_draw_op_list_ref (op_list);
g_hash_table_replace (theme->draw_op_lists_by_name, g_strdup (name)g_strdup_inline (name), op_list);
6007}

6009MetaFrameStyle*
6010meta_theme_lookup_style (MetaTheme         *theme,
                       const char        *name)
6012{
return g_hash_table_lookup (theme->styles_by_name, name);
6014}

6016void
6017meta_theme_insert_style (MetaTheme         *theme,
                       const char        *name,
                       MetaFrameStyle    *style)
6020{
meta_frame_style_ref (style);
g_hash_table_replace (theme->styles_by_name, g_strdup (name)g_strdup_inline (name), style);
6023}

6025MetaFrameStyleSet*
6026meta_theme_lookup_style_set (MetaTheme         *theme,
                           const char        *name)
6028{
return g_hash_table_lookup (theme->style_sets_by_name, name);
6030}

6032void
6033meta_theme_insert_style_set    (MetaTheme         *theme,
                              const char        *name,
                              MetaFrameStyleSet *style_set)
6036{
meta_frame_style_set_ref (style_set);
g_hash_table_replace (theme->style_sets_by_name, g_strdup (name)g_strdup_inline (name), style_set);
6039}

6041static gboolean
6042first_uppercase (const char *str)
6043{
return g_ascii_isupper (*str)((g_ascii_table[(guchar) (*str)] & G_ASCII_UPPER) != 0);
6045}

6047gboolean
6048meta_theme_define_int_constant (MetaTheme   *theme,
                              const char  *name,
                              int          value,
                              GError     **error)
6052{
if (theme->integer_constants == NULL((void*)0))
  theme->integer_constants = g_hash_table_new_full (g_str_hash,
                                                    g_str_equal,
                                                    g_free,
                                                    NULL((void*)0));

if (!first_uppercase (name))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("User-defined constants must begin with a capital letter; \"%s\" does not")dgettext ("croma", "User-defined constants must begin with a capital letter; \"%s\" does not"
),
                 name);
    return FALSE(0);
  }

if (g_hash_table_lookup_extended (theme->integer_constants, name, NULL((void*)0), NULL((void*)0)))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("Constant \"%s\" has already been defined")dgettext ("croma", "Constant \"%s\" has already been defined"
),
                 name);

    return FALSE(0);
  }

g_hash_table_insert (theme->integer_constants,
                     g_strdup (name)g_strdup_inline (name),
                     GINT_TO_POINTER (value)((gpointer) (glong) (value)));

return TRUE(!(0));
6081}

6083gboolean
6084meta_theme_lookup_int_constant (MetaTheme   *theme,
                              const char  *name,
                              int         *value)
6087{
gpointer old_value;

*value = 0;

if (theme->integer_constants == NULL((void*)0))
  return FALSE(0);

if (g_hash_table_lookup_extended (theme->integer_constants,
                                  name, NULL((void*)0), &old_value))
  {
    *value = GPOINTER_TO_INT (old_value)((gint) (glong) (old_value));
    return TRUE(!(0));
  }
else
  {
    return FALSE(0);
  }
6105}

6107gboolean
6108meta_theme_define_float_constant (MetaTheme   *theme,
                                const char  *name,
                                double       value,
                                GError     **error)
6112{
double *d;

if (theme->float_constants == NULL((void*)0))
  theme->float_constants = g_hash_table_new_full (g_str_hash,
                                                  g_str_equal,
                                                  g_free,
                                                  g_free);

if (!first_uppercase (name))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("User-defined constants must begin with a capital letter; \"%s\" does not")dgettext ("croma", "User-defined constants must begin with a capital letter; \"%s\" does not"
),
                 name);
    return FALSE(0);
  }

if (g_hash_table_lookup_extended (theme->float_constants, name, NULL((void*)0), NULL((void*)0)))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("Constant \"%s\" has already been defined")dgettext ("croma", "Constant \"%s\" has already been defined"
),
                 name);

    return FALSE(0);
  }

d = g_new (double, 1)((double *) g_malloc_n ((1), sizeof (double)));
*d = value;

g_hash_table_insert (theme->float_constants,
                     g_strdup (name)g_strdup_inline (name), d);

return TRUE(!(0));
6145}

6147gboolean
6148meta_theme_lookup_float_constant (MetaTheme   *theme,
                                const char  *name,
                                double      *value)
6151{
double *d;

*value = 0.0;

if (theme->float_constants == NULL((void*)0))
  return FALSE(0);

d = g_hash_table_lookup (theme->float_constants, name);

if (d)
  {
    *value = *d;
    return TRUE(!(0));
  }
else
  {
    return FALSE(0);
  }
6170}

6172gboolean
6173meta_theme_define_color_constant (MetaTheme   *theme,
                                const char  *name,
                                const char  *value,
                                GError     **error)
6177{
if (theme->color_constants == NULL((void*)0))
  theme->color_constants = g_hash_table_new_full (g_str_hash,
                                                  g_str_equal,
                                                  g_free,
                                                  NULL((void*)0));

if (!first_uppercase (name))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("User-defined constants must begin with a capital letter; \"%s\" does not")dgettext ("croma", "User-defined constants must begin with a capital letter; \"%s\" does not"
),
                 name);
    return FALSE(0);
  }

if (g_hash_table_lookup_extended (theme->color_constants, name, NULL((void*)0), NULL((void*)0)))
  {
    g_set_error (error, META_THEME_ERROR(g_quark_from_static_string ("meta-theme-error")), META_THEME_ERROR_FAILED,
                 _("Constant \"%s\" has already been defined")dgettext ("croma", "Constant \"%s\" has already been defined"
),
                 name);

    return FALSE(0);
  }

g_hash_table_insert (theme->color_constants,
                     g_strdup (name)g_strdup_inline (name),
                     g_strdup (value)g_strdup_inline (value));

return TRUE(!(0));
6206}

6208/**
* Looks up a colour constant.
*
* \param theme  the theme containing the constant
* \param name  the name of the constant
* \param value  [out] the string representation of the colour, or NULL if it
*               doesn't exist
* \return  TRUE if it exists, FALSE otherwise
*/
6217gboolean
6218meta_theme_lookup_color_constant (MetaTheme   *theme,
                                const char  *name,
                                char       **value)
6221{
char *result;

*value = NULL((void*)0);

if (theme->color_constants == NULL((void*)0))
  return FALSE(0);

result = g_hash_table_lookup (theme->color_constants, name);

if (result)
  {
    *value = result;
    return TRUE(!(0));
  }
else
  {
    return FALSE(0);
  }
6240}


6243PangoFontDescription*
6244meta_ctk_widget_get_font_desc (CtkWidget *widget,
                             double     scale,
	       const PangoFontDescription *override)
6247{
PangoFontDescription *font_desc;

CtkStyleContext *style = ctk_widget_get_style_context (widget);
CtkStateFlags state = ctk_widget_get_state_flags (widget);
ctk_style_context_get(style, state, CTK_STYLE_PROPERTY_FONT"font", &font_desc, NULL((void*)0));
font_desc = pango_font_description_copy (font_desc);

if (override)
  pango_font_description_merge (font_desc, override, TRUE(!(0)));

pango_font_description_set_size (font_desc,
                                 MAX (pango_font_description_get_size (font_desc) * scale, 1)(((pango_font_description_get_size (font_desc) * scale) > (
1)) ? (pango_font_description_get_size (font_desc) * scale) :
 (1)));

return font_desc;
6262}

6264/**
* Returns the height of the letters in a particular font.
*
* \param font_desc  the font
* \param context  the context of the font
* \return  the height of the letters
*/
6271int
6272meta_pango_font_desc_get_text_height (const PangoFontDescription *font_desc,
                                    PangoContext         *context)
6274{
PangoFontMetrics *metrics;
PangoLanguage *lang;
int retval;

lang = pango_context_get_language (context);
metrics = pango_context_get_metrics (context, font_desc, lang);

retval = PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +(((int)(pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent
 (metrics)) + 512) >> 10)
                       pango_font_metrics_get_descent (metrics))(((int)(pango_font_metrics_get_ascent (metrics) + pango_font_metrics_get_descent
 (metrics)) + 512) >> 10);

pango_font_metrics_unref (metrics);

return retval;
6288}

6290MetaCtkColorComponent
6291meta_color_component_from_string (const char *str)
6292{
if (strcmp ("fg", str) == 0)
  return META_CTK_COLOR_FG;
else if (strcmp ("bg", str) == 0)
  return META_CTK_COLOR_BG;
else if (strcmp ("light", str) == 0)
  return META_CTK_COLOR_LIGHT;
else if (strcmp ("dark", str) == 0)
  return META_CTK_COLOR_DARK;
else if (strcmp ("mid", str) == 0)
  return META_CTK_COLOR_MID;
else if (strcmp ("text", str) == 0)
  return META_CTK_COLOR_TEXT;
else if (strcmp ("base", str) == 0)
  return META_CTK_COLOR_BASE;
else if (strcmp ("text_aa", str) == 0)
  return META_CTK_COLOR_TEXT_AA;
else
  return META_CTK_COLOR_LAST;
6311}

6313const char*
6314meta_color_component_to_string (MetaCtkColorComponent component)
6315{
switch (component)
  {
  case META_CTK_COLOR_FG:
    return "fg";
  case META_CTK_COLOR_BG:
    return "bg";
  case META_CTK_COLOR_LIGHT:
    return "light";
  case META_CTK_COLOR_DARK:
    return "dark";
  case META_CTK_COLOR_MID:
    return "mid";
  case META_CTK_COLOR_TEXT:
    return "text";
  case META_CTK_COLOR_BASE:
    return "base";
  case META_CTK_COLOR_TEXT_AA:
    return "text_aa";
  case META_CTK_COLOR_LAST:
    break;
  }

return "<unknown>";
6339}

6341MetaButtonState
6342meta_button_state_from_string (const char *str)
6343{
if (strcmp ("normal", str) == 0)
  return META_BUTTON_STATE_NORMAL;
else if (strcmp ("pressed", str) == 0)
  return META_BUTTON_STATE_PRESSED;
else if (strcmp ("prelight", str) == 0)
  return META_BUTTON_STATE_PRELIGHT;
else
  return META_BUTTON_STATE_LAST;
6352}

6354const char*
6355meta_button_state_to_string (MetaButtonState state)
6356{
switch (state)
  {
  case META_BUTTON_STATE_NORMAL:
    return "normal";
  case META_BUTTON_STATE_PRESSED:
    return "pressed";
  case META_BUTTON_STATE_PRELIGHT:
    return "prelight";
  case META_BUTTON_STATE_LAST:
    break;
  }

return "<unknown>";
6370}

6372MetaButtonType
6373meta_button_type_from_string (const char *str, MetaTheme *theme)
6374{
if (META_THEME_ALLOWS(theme, META_THEME_SHADE_STICK_ABOVE_BUTTONS)(theme->format_version >= 2))
  {
    if (strcmp ("shade", str) == 0)
      return META_BUTTON_TYPE_SHADE;
    else if (strcmp ("above", str) == 0)
      return META_BUTTON_TYPE_ABOVE;
    else if (strcmp ("stick", str) == 0)
      return META_BUTTON_TYPE_STICK;
    else if (strcmp ("unshade", str) == 0)
      return META_BUTTON_TYPE_UNSHADE;
    else if (strcmp ("unabove", str) == 0)
      return META_BUTTON_TYPE_UNABOVE;
    else if (strcmp ("unstick", str) == 0)
      return META_BUTTON_TYPE_UNSTICK;
   }

if (strcmp ("close", str) == 0)
  return META_BUTTON_TYPE_CLOSE;
else if (strcmp ("maximize", str) == 0)
  return META_BUTTON_TYPE_MAXIMIZE;
else if (strcmp ("minimize", str) == 0)
  return META_BUTTON_TYPE_MINIMIZE;
else if (strcmp ("menu", str) == 0)
  return META_BUTTON_TYPE_MENU;
else if (strcmp ("appmenu", str) == 0)
  return META_BUTTON_TYPE_APPMENU;
else if (strcmp ("left_left_background", str) == 0)
  return META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND;
else if (strcmp ("left_middle_background", str) == 0)
  return META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND;
else if (strcmp ("left_right_background", str) == 0)
  return META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND;
else if (strcmp ("left_single_background", str) == 0)
  return META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND;
else if (strcmp ("right_left_background", str) == 0)
  return META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND;
else if (strcmp ("right_middle_background", str) == 0)
  return META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND;
else if (strcmp ("right_right_background", str) == 0)
  return META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND;
else if (strcmp ("right_single_background", str) == 0)
  return META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND;
else
  return META_BUTTON_TYPE_LAST;
6419}

6421const char*
6422meta_button_type_to_string (MetaButtonType type)
6423{
switch (type)
  {
  case META_BUTTON_TYPE_CLOSE:
    return "close";
  case META_BUTTON_TYPE_MAXIMIZE:
    return "maximize";
  case META_BUTTON_TYPE_MINIMIZE:
    return "minimize";
  case META_BUTTON_TYPE_SHADE:
   return "shade";
  case META_BUTTON_TYPE_ABOVE:
    return "above";
  case META_BUTTON_TYPE_STICK:
    return "stick";
  case META_BUTTON_TYPE_UNSHADE:
    return "unshade";
  case META_BUTTON_TYPE_UNABOVE:
    return "unabove";
  case META_BUTTON_TYPE_UNSTICK:
    return "unstick";
  case META_BUTTON_TYPE_MENU:
    return "menu";
  case META_BUTTON_TYPE_APPMENU:
    return "appmenu";
  case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
    return "left_left_background";
  case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
    return "left_middle_background";
  case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
    return "left_right_background";
  case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
    return "left_single_background";
  case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
    return "right_left_background";
  case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
    return "right_middle_background";
  case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
    return "right_right_background";
  case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
    return "right_single_background";
  case META_BUTTON_TYPE_LAST:
    break;
  }

return "<unknown>";
6469}

6471MetaFramePiece
6472meta_frame_piece_from_string (const char *str)
6473{
if (strcmp ("entire_background", str) == 0)
  return META_FRAME_PIECE_ENTIRE_BACKGROUND;
else if (strcmp ("titlebar", str) == 0)
  return META_FRAME_PIECE_TITLEBAR;
else if (strcmp ("titlebar_middle", str) == 0)
  return META_FRAME_PIECE_TITLEBAR_MIDDLE;
else if (strcmp ("left_titlebar_edge", str) == 0)
  return META_FRAME_PIECE_LEFT_TITLEBAR_EDGE;
else if (strcmp ("right_titlebar_edge", str) == 0)
  return META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE;
else if (strcmp ("top_titlebar_edge", str) == 0)
  return META_FRAME_PIECE_TOP_TITLEBAR_EDGE;
else if (strcmp ("bottom_titlebar_edge", str) == 0)
  return META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE;
else if (strcmp ("title", str) == 0)
  return META_FRAME_PIECE_TITLE;
else if (strcmp ("left_edge", str) == 0)
  return META_FRAME_PIECE_LEFT_EDGE;
else if (strcmp ("right_edge", str) == 0)
  return META_FRAME_PIECE_RIGHT_EDGE;
else if (strcmp ("bottom_edge", str) == 0)
  return META_FRAME_PIECE_BOTTOM_EDGE;
else if (strcmp ("overlay", str) == 0)
  return META_FRAME_PIECE_OVERLAY;
else
  return META_FRAME_PIECE_LAST;
6500}

6502const char*
6503meta_frame_piece_to_string (MetaFramePiece piece)
6504{
switch (piece)
  {
  case META_FRAME_PIECE_ENTIRE_BACKGROUND:
    return "entire_background";
  case META_FRAME_PIECE_TITLEBAR:
    return "titlebar";
  case META_FRAME_PIECE_TITLEBAR_MIDDLE:
    return "titlebar_middle";
  case META_FRAME_PIECE_LEFT_TITLEBAR_EDGE:
    return "left_titlebar_edge";
  case META_FRAME_PIECE_RIGHT_TITLEBAR_EDGE:
    return "right_titlebar_edge";
  case META_FRAME_PIECE_TOP_TITLEBAR_EDGE:
    return "top_titlebar_edge";
  case META_FRAME_PIECE_BOTTOM_TITLEBAR_EDGE:
    return "bottom_titlebar_edge";
  case META_FRAME_PIECE_TITLE:
    return "title";
  case META_FRAME_PIECE_LEFT_EDGE:
    return "left_edge";
  case META_FRAME_PIECE_RIGHT_EDGE:
    return "right_edge";
  case META_FRAME_PIECE_BOTTOM_EDGE:
    return "bottom_edge";
  case META_FRAME_PIECE_OVERLAY:
    return "overlay";
  case META_FRAME_PIECE_LAST:
    break;
  }

return "<unknown>";
6536}

6538MetaFrameState
6539meta_frame_state_from_string (const char *str)
6540{
if (strcmp ("normal", str) == 0)
  return META_FRAME_STATE_NORMAL;
else if (strcmp ("maximized", str) == 0)
  return META_FRAME_STATE_MAXIMIZED;
else if (strcmp ("tiled_left", str) == 0)
  return META_FRAME_STATE_TILED_LEFT;
else if (strcmp ("tiled_right", str) == 0)
  return META_FRAME_STATE_TILED_RIGHT;
else if (strcmp ("shaded", str) == 0)
  return META_FRAME_STATE_SHADED;
else if (strcmp ("maximized_and_shaded", str) == 0)
  return META_FRAME_STATE_MAXIMIZED_AND_SHADED;
else if (strcmp ("tiled_left_and_shaded", str) == 0)
  return META_FRAME_STATE_TILED_LEFT_AND_SHADED;
else if (strcmp ("tiled_right_and_shaded", str) == 0)
  return META_FRAME_STATE_TILED_RIGHT_AND_SHADED;
else
  return META_FRAME_STATE_LAST;
6559}

6561const char*
6562meta_frame_state_to_string (MetaFrameState state)
6563{
switch (state)
  {
  case META_FRAME_STATE_NORMAL:
    return "normal";
  case META_FRAME_STATE_MAXIMIZED:
    return "maximized";
  case META_FRAME_STATE_TILED_LEFT:
    return "tiled_left";
  case META_FRAME_STATE_TILED_RIGHT:
    return "tiled_right";
  case META_FRAME_STATE_SHADED:
    return "shaded";
  case META_FRAME_STATE_MAXIMIZED_AND_SHADED:
    return "maximized_and_shaded";
  case META_FRAME_STATE_TILED_LEFT_AND_SHADED:
    return "tiled_left_and_shaded";
  case META_FRAME_STATE_TILED_RIGHT_AND_SHADED:
    return "tiled_right_and_shaded";
  case META_FRAME_STATE_LAST:
    break;
  }

return "<unknown>";
6587}

6589MetaFrameResize
6590meta_frame_resize_from_string (const char *str)
6591{
if (strcmp ("none", str) == 0)
  return META_FRAME_RESIZE_NONE;
else if (strcmp ("vertical", str) == 0)
  return META_FRAME_RESIZE_VERTICAL;
else if (strcmp ("horizontal", str) == 0)
  return META_FRAME_RESIZE_HORIZONTAL;
else if (strcmp ("both", str) == 0)
  return META_FRAME_RESIZE_BOTH;
else
  return META_FRAME_RESIZE_LAST;
6602}

6604const char*
6605meta_frame_resize_to_string (MetaFrameResize resize)
6606{
switch (resize)
  {
  case META_FRAME_RESIZE_NONE:
    return "none";
  case META_FRAME_RESIZE_VERTICAL:
    return "vertical";
  case META_FRAME_RESIZE_HORIZONTAL:
    return "horizontal";
  case META_FRAME_RESIZE_BOTH:
    return "both";
  case META_FRAME_RESIZE_LAST:
    break;
  }

return "<unknown>";
6622}

6624MetaFrameFocus
6625meta_frame_focus_from_string (const char *str)
6626{
if (strcmp ("no", str) == 0)
  return META_FRAME_FOCUS_NO;
else if (strcmp ("yes", str) == 0)
  return META_FRAME_FOCUS_YES;
else
  return META_FRAME_FOCUS_LAST;
6633}

6635const char*
6636meta_frame_focus_to_string (MetaFrameFocus focus)
6637{
switch (focus)
  {
  case META_FRAME_FOCUS_NO:
    return "no";
  case META_FRAME_FOCUS_YES:
    return "yes";
  case META_FRAME_FOCUS_LAST:
    break;
  }

return "<unknown>";
6649}

6651MetaFrameType
6652meta_frame_type_from_string (const char *str)
6653{
if (strcmp ("normal", str) == 0)
  return META_FRAME_TYPE_NORMAL;
else if (strcmp ("dialog", str) == 0)
  return META_FRAME_TYPE_DIALOG;
else if (strcmp ("modal_dialog", str) == 0)
  return META_FRAME_TYPE_MODAL_DIALOG;
else if (strcmp ("utility", str) == 0)
  return META_FRAME_TYPE_UTILITY;
else if (strcmp ("menu", str) == 0)
  return META_FRAME_TYPE_MENU;
else if (strcmp ("border", str) == 0)
  return META_FRAME_TYPE_BORDER;
else if (strcmp ("attached", str) == 0)
  return META_FRAME_TYPE_ATTACHED;
6668#if 0
else if (strcmp ("toolbar", str) == 0)
  return META_FRAME_TYPE_TOOLBAR;
6671#endif
else
  return META_FRAME_TYPE_LAST;
6674}

6676const char*
6677meta_frame_type_to_string (MetaFrameType type)
6678{
switch (type)
  {
  case META_FRAME_TYPE_NORMAL:
    return "normal";
  case META_FRAME_TYPE_DIALOG:
    return "dialog";
  case META_FRAME_TYPE_MODAL_DIALOG:
    return "modal_dialog";
  case META_FRAME_TYPE_UTILITY:
    return "utility";
  case META_FRAME_TYPE_MENU:
    return "menu";
  case META_FRAME_TYPE_BORDER:
    return "border";
  case META_FRAME_TYPE_ATTACHED:
    return "attached";
6695#if 0
  case META_FRAME_TYPE_TOOLBAR:
    return "toolbar";
6698#endif
  case  META_FRAME_TYPE_LAST:
    break;
  }

return "<unknown>";
6704}

6706MetaGradientType
6707meta_gradient_type_from_string (const char *str)
6708{
if (strcmp ("vertical", str) == 0)
  return META_GRADIENT_VERTICAL;
else if (strcmp ("horizontal", str) == 0)
  return META_GRADIENT_HORIZONTAL;
else if (strcmp ("diagonal", str) == 0)
  return META_GRADIENT_DIAGONAL;
else
  return META_GRADIENT_LAST;
6717}

6719const char*
6720meta_gradient_type_to_string (MetaGradientType type)
6721{
switch (type)
  {
  case META_GRADIENT_VERTICAL:
    return "vertical";
  case META_GRADIENT_HORIZONTAL:
    return "horizontal";
  case META_GRADIENT_DIAGONAL:
    return "diagonal";
  case META_GRADIENT_LAST:
    break;
  }

return "<unknown>";
6735}

6737CtkStateFlags
6738meta_ctk_state_from_string (const char *str)
6739{
if (g_ascii_strcasecmp ("normal", str) == 0)
  return CTK_STATE_FLAG_NORMAL;
else if (g_ascii_strcasecmp ("prelight", str) == 0)
  return CTK_STATE_FLAG_PRELIGHT;
else if (g_ascii_strcasecmp ("active", str) == 0)
  return CTK_STATE_FLAG_ACTIVE;
else if (g_ascii_strcasecmp ("selected", str) == 0)
  return CTK_STATE_FLAG_SELECTED;
else if (g_ascii_strcasecmp ("insensitive", str) == 0)
  return CTK_STATE_FLAG_INSENSITIVE;
else if (g_ascii_strcasecmp ("inconsistent", str) == 0)
  return CTK_STATE_FLAG_INCONSISTENT;
else if (g_ascii_strcasecmp ("focused", str) == 0)
  return CTK_STATE_FLAG_FOCUSED;
else if (g_ascii_strcasecmp ("backdrop", str) == 0)
  return CTK_STATE_FLAG_BACKDROP;
else
  return -1; /* hack */
6758}

6760CtkShadowType
6761meta_ctk_shadow_from_string (const char *str)
6762{
if (strcmp ("none", str) == 0)
  return CTK_SHADOW_NONE;
else if (strcmp ("in", str) == 0)
  return CTK_SHADOW_IN;
else if (strcmp ("out", str) == 0)
  return CTK_SHADOW_OUT;
else if (strcmp ("etched_in", str) == 0)
  return CTK_SHADOW_ETCHED_IN;
else if (strcmp ("etched_out", str) == 0)
  return CTK_SHADOW_ETCHED_OUT;
else
  return -1;
6775}

6777const char*
6778meta_ctk_shadow_to_string (CtkShadowType shadow)
6779{
switch (shadow)
  {
  case CTK_SHADOW_NONE:
    return "none";
  case CTK_SHADOW_IN:
    return "in";
  case CTK_SHADOW_OUT:
    return "out";
  case CTK_SHADOW_ETCHED_IN:
    return "etched_in";
  case CTK_SHADOW_ETCHED_OUT:
    return "etched_out";
  }

return "<unknown>";
6795}

6797CtkArrowType
6798meta_ctk_arrow_from_string (const char *str)
6799{
if (strcmp ("up", str) == 0)
  return CTK_ARROW_UP;
else if (strcmp ("down", str) == 0)
  return CTK_ARROW_DOWN;
else if (strcmp ("left", str) == 0)
  return CTK_ARROW_LEFT;
else if (strcmp ("right", str) == 0)
  return CTK_ARROW_RIGHT;
else if (strcmp ("none", str) == 0)
  return CTK_ARROW_NONE;
else
  return -1;
6812}

6814const char*
6815meta_ctk_arrow_to_string (CtkArrowType arrow)
6816{
switch (arrow)
  {
  case CTK_ARROW_UP:
    return "up";
  case CTK_ARROW_DOWN:
    return "down";
  case CTK_ARROW_LEFT:
    return "left";
  case CTK_ARROW_RIGHT:
    return "right";
  case CTK_ARROW_NONE:
    return "none";
  }

return "<unknown>";
6832}

6834/**
* Returns a fill_type from a string.  The inverse of
* meta_image_fill_type_to_string().
*
* \param str  a string representing a fill_type
* \result  the fill_type, or -1 if it represents no fill_type.
*/
6841MetaImageFillType
6842meta_image_fill_type_from_string (const char *str)
6843{
if (strcmp ("tile", str) == 0)
  return META_IMAGE_FILL_TILE;
else if (strcmp ("scale", str) == 0)
  return META_IMAGE_FILL_SCALE;
else
  return -1;
6850}

6852/**
* Returns a string representation of a fill_type.  The inverse of
* meta_image_fill_type_from_string().
*
* \param fill_type  the fill type
* \result  a string representing that type
*/
6859const char*
6860meta_image_fill_type_to_string (MetaImageFillType fill_type)
6861{
switch (fill_type)
  {
  case META_IMAGE_FILL_TILE:
    return "tile";
  case META_IMAGE_FILL_SCALE:
    return "scale";
  }

return "<unknown>";
6871}

6873/**
* Takes a colour "a", scales the lightness and saturation by a certain amount,
* and sets "b" to the resulting colour.
* ctkstyle.c cut-and-pastage.
*
* \param a  the starting colour
* \param b  [out] the resulting colour
* \param k  amount to scale lightness and saturation by
*/
6882static void
6883ctk_style_shade (CdkRGBA *a,
               CdkRGBA *b,
               gdouble  k)
6886{
gdouble red;
gdouble green;
gdouble blue;

red = a->red;
green = a->green;
blue = a->blue;

rgb_to_hls (&red, &green, &blue);

green *= k;
if (green > 1.0)
  green = 1.0;
else if (green < 0.0)
  green = 0.0;

blue *= k;
if (blue > 1.0)
  blue = 1.0;
else if (blue < 0.0)
  blue = 0.0;

hls_to_rgb (&red, &green, &blue);

b->red = red;
b->green = green;
b->blue = blue;
6914}

6916/**
* Converts a red/green/blue triplet to a hue/lightness/saturation triplet.
*
* \param r  on input, red; on output, hue
* \param g  on input, green; on output, lightness
* \param b  on input, blue; on output, saturation
*/
6923static void
6924rgb_to_hls (gdouble *r,
          gdouble *g,
          gdouble *b)
6927{
gdouble min;
gdouble max;
gdouble red;
gdouble green;
gdouble blue;
gdouble h, l, s;
gdouble delta;

red = *r;
green = *g;
blue = *b;

if (red > green)
  {
    if (red > blue)
      max = red;
    else
      max = blue;

    if (green < blue)
      min = green;
    else
      min = blue;
  }
else
  {
    if (green > blue)
      max = green;
    else
      max = blue;

    if (red < blue)
      min = red;
    else
      min = blue;
  }

l = (max + min) / 2;
s = 0;
h = 0;

if (max != min)
  {
    if (l <= 0.5)
      s = (max - min) / (max + min);
    else
      s = (max - min) / (2 - max - min);

    delta = max -min;
    if (red == max)
      h = (green - blue) / delta;
    else if (green == max)
      h = 2 + (blue - red) / delta;
    else if (blue == max)
      h = 4 + (red - green) / delta;

    h *= 60;
    if (h < 0.0)
      h += 360;
  }

*r = h;
*g = l;
*b = s;
6992}

6994/**
* Converts a hue/lightness/saturation triplet to a red/green/blue triplet.
*
* \param h  on input, hue; on output, red
* \param l  on input, lightness; on output, green
* \param s  on input, saturation; on output, blue
*/
7001static void
7002hls_to_rgb (gdouble *h,
          gdouble *l,
          gdouble *s)
7005{
gdouble hue;
gdouble lightness;
gdouble saturation;
gdouble m1, m2;
gdouble r, g, b;

lightness = *l;
saturation = *s;

if (lightness <= 0.5)
  m2 = lightness * (1 + saturation);
else
  m2 = lightness + saturation - lightness * saturation;
m1 = 2 * lightness - m2;

if (saturation == 0)
  {
    *h = lightness;
    *l = lightness;
    *s = lightness;
  }
else
  {
    hue = *h + 120;
    while (hue > 360)
      hue -= 360;
    while (hue < 0)
      hue += 360;

    if (hue < 60)
      r = m1 + (m2 - m1) * hue / 60;
    else if (hue < 180)
      r = m2;
    else if (hue < 240)
      r = m1 + (m2 - m1) * (240 - hue) / 60;
    else
      r = m1;

    hue = *h;
    while (hue > 360)
      hue -= 360;
    while (hue < 0)
      hue += 360;

    if (hue < 60)
      g = m1 + (m2 - m1) * hue / 60;
    else if (hue < 180)
      g = m2;
    else if (hue < 240)
      g = m1 + (m2 - m1) * (240 - hue) / 60;
    else
      g = m1;

    hue = *h - 120;
    while (hue > 360)
      hue -= 360;
    while (hue < 0)
      hue += 360;

    if (hue < 60)
      b = m1 + (m2 - m1) * hue / 60;
    else if (hue < 180)
      b = m2;
    else if (hue < 240)
      b = m1 + (m2 - m1) * (240 - hue) / 60;
    else
      b = m1;

    *h = r;
    *l = g;
    *s = b;
  }
7078}

7080#if 0
7081/* These are some functions I'm saving to use in optimizing
* MetaDrawOpList, namely to pre-composite pixbufs on client side
* prior to rendering to the server
*/
7085static void
7086draw_bg_solid_composite (const MetaTextureSpec *bg,
                       const MetaTextureSpec *fg,
                       double                 alpha,
                       CtkWidget             *widget,
                       CdkDrawable           *drawable,
                       const CdkRectangle    *clip,
                       MetaTextureDrawMode    mode,
                       double                 xalign,
                       double                 yalign,
                       int                    x,
                       int                    y,
                       int                    width,
                       int                    height)
7099{
CdkColor bg_color;

g_assert (bg->type == META_TEXTURE_SOLID)do { if (bg->type == META_TEXTURE_SOLID) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7102, ((const char*) (__func__)), "bg->type == META_TEXTURE_SOLID"
); } while (0);
g_assert (fg->type != META_TEXTURE_COMPOSITE)do { if (fg->type != META_TEXTURE_COMPOSITE) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7103, ((const char*) (__func__)), "fg->type != META_TEXTURE_COMPOSITE"
); } while (0);
g_assert (fg->type != META_TEXTURE_SHAPE_LIST)do { if (fg->type != META_TEXTURE_SHAPE_LIST) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7104, ((const char*) (__func__)), "fg->type != META_TEXTURE_SHAPE_LIST"
); } while (0);

meta_color_spec_render (bg->data.solid.color_spec,
                        widget,
                        &bg_color);

switch (fg->type)
  {
  case META_TEXTURE_SOLID:
    {
      CdkColor fg_color;

      meta_color_spec_render (fg->data.solid.color_spec,
                              widget,
                              &fg_color);

      color_composite (&bg_color, &fg_color,
                       alpha, &fg_color);

      draw_color_rectangle (widget, drawable, &fg_color, clip,
                            x, y, width, height);
    }
    break;

  case META_TEXTURE_GRADIENT:
    /* FIXME I think we could just composite all the colors in
     * the gradient prior to generating the gradient?
     */
    /* FALL THRU */
  case META_TEXTURE_IMAGE:
    {
      GdkPixbuf *pixbuf;
      GdkPixbuf *composited;

      pixbuf = meta_texture_spec_render (fg, widget, mode, 255,
                                         width, height);

      if (pixbuf == NULL((void*)0))
        return;

      composited = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                                   gdk_pixbuf_get_has_alpha (pixbuf), 8,
                                   gdk_pixbuf_get_width (pixbuf),
                                   gdk_pixbuf_get_height (pixbuf));

      if (composited == NULL((void*)0))
        {
          g_object_unref (G_OBJECT (pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((pixbuf)), (((GType) ((20) << (2)))))))));
          return;
        }

      gdk_pixbuf_composite_color (pixbuf,
                                  composited,
                                  0, 0,
                                  gdk_pixbuf_get_width (pixbuf),
                                  gdk_pixbuf_get_height (pixbuf),
                                  0.0, 0.0, /* offsets */
                                  1.0, 1.0, /* scale */
                                  GDK_INTERP_BILINEAR,
                                  255 * alpha,
                                  0, 0,     /* check offsets */
                                  0,        /* check size */
                                  CDK_COLOR_RGB (bg_color)((guint32) (((int)((bg_color).red * 255) << 16) | ((int
)((bg_color).green * 255) << 8) | ((int)((bg_color).blue
 * 255)))),
                                  CDK_COLOR_RGB (bg_color)((guint32) (((int)((bg_color).red * 255) << 16) | ((int
)((bg_color).green * 255) << 8) | ((int)((bg_color).blue
 * 255)))));

      /* Need to draw background since pixbuf is not
       * necessarily covering the whole thing
       */
      draw_color_rectangle (widget, drawable, &bg_color, clip,
                            x, y, width, height);

      render_pixbuf_aligned (drawable, clip, composited,
                             xalign, yalign,
                             x, y, width, height);

      g_object_unref (G_OBJECT (pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((pixbuf)), (((GType) ((20) << (2)))))))));
      g_object_unref (G_OBJECT (composited)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((composited)), (((GType) ((20) << (2)))))))));
    }
    break;

  case META_TEXTURE_BLANK:
  case META_TEXTURE_COMPOSITE:
  case META_TEXTURE_SHAPE_LIST:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 7187, (
(const char*) (__func__)), ((void*)0)); } while (0);
    break;
  }
7190}

7192static void
7193draw_bg_gradient_composite (const MetaTextureSpec *bg,
                          const MetaTextureSpec *fg,
                          double                 alpha,
                          CtkWidget             *widget,
                          CdkDrawable           *drawable,
                          const CdkRectangle    *clip,
                          MetaTextureDrawMode    mode,
                          double                 xalign,
                          double                 yalign,
                          int                    x,
                          int                    y,
                          int                    width,
                          int                    height)
7206{
g_assert (bg->type == META_TEXTURE_GRADIENT)do { if (bg->type == META_TEXTURE_GRADIENT) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7207, ((const char*) (__func__)), "bg->type == META_TEXTURE_GRADIENT"
); } while (0);
g_assert (fg->type != META_TEXTURE_COMPOSITE)do { if (fg->type != META_TEXTURE_COMPOSITE) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7208, ((const char*) (__func__)), "fg->type != META_TEXTURE_COMPOSITE"
); } while (0);
g_assert (fg->type != META_TEXTURE_SHAPE_LIST)do { if (fg->type != META_TEXTURE_SHAPE_LIST) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7209, ((const char*) (__func__)), "fg->type != META_TEXTURE_SHAPE_LIST"
); } while (0);

switch (fg->type)
  {
  case META_TEXTURE_SOLID:
  case META_TEXTURE_GRADIENT:
  case META_TEXTURE_IMAGE:
    {
      GdkPixbuf *bg_pixbuf;
      GdkPixbuf *fg_pixbuf;
      GdkPixbuf *composited;
      int fg_width, fg_height;

      bg_pixbuf = meta_texture_spec_render (bg, widget, mode, 255,
                                            width, height);

      if (bg_pixbuf == NULL((void*)0))
        return;

      fg_pixbuf = meta_texture_spec_render (fg, widget, mode, 255,
                                            width, height);

      if (fg_pixbuf == NULL((void*)0))
        {
          g_object_unref (G_OBJECT (bg_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bg_pixbuf)), (((GType) ((20) << (2)))))))));
          return;
        }

      /* gradients always fill the entire target area */
      g_assert (gdk_pixbuf_get_width (bg_pixbuf) == width)do { if (gdk_pixbuf_get_width (bg_pixbuf) == width) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7238, ((const char*) (__func__)), "gdk_pixbuf_get_width (bg_pixbuf) == width"
); } while (0);
      g_assert (gdk_pixbuf_get_height (bg_pixbuf) == height)do { if (gdk_pixbuf_get_height (bg_pixbuf) == height) ; else g_assertion_message_expr
 ("croma", "ui/theme.c", 7239, ((const char*) (__func__)), "gdk_pixbuf_get_height (bg_pixbuf) == height"
); } while (0);

      composited = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                                   gdk_pixbuf_get_has_alpha (bg_pixbuf), 8,
                                   gdk_pixbuf_get_width (bg_pixbuf),
                                   gdk_pixbuf_get_height (bg_pixbuf));

      if (composited == NULL((void*)0))
        {
          g_object_unref (G_OBJECT (bg_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bg_pixbuf)), (((GType) ((20) << (2)))))))));
          g_object_unref (G_OBJECT (fg_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((fg_pixbuf)), (((GType) ((20) << (2)))))))));
          return;
        }

      fg_width = gdk_pixbuf_get_width (fg_pixbuf);
      fg_height = gdk_pixbuf_get_height (fg_pixbuf);

      /* If we wanted to be all cool we could deal with the
       * offsets and try to composite only in the clip rectangle,
       * but I just don't care enough to figure it out.
       */

      gdk_pixbuf_composite (fg_pixbuf,
                            composited,
                            x + (width - fg_width) * xalign,
                            y + (height - fg_height) * yalign,
                            gdk_pixbuf_get_width (fg_pixbuf),
                            gdk_pixbuf_get_height (fg_pixbuf),
                            0.0, 0.0, /* offsets */
                            1.0, 1.0, /* scale */
                            GDK_INTERP_BILINEAR,
                            255 * alpha);

      cdk_cairo_set_source_pixbuf (cr, composited, x, y);
      cairo_paint (cr);

      g_object_unref (G_OBJECT (bg_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bg_pixbuf)), (((GType) ((20) << (2)))))))));
      g_object_unref (G_OBJECT (fg_pixbuf)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((fg_pixbuf)), (((GType) ((20) << (2)))))))));
      g_object_unref (G_OBJECT (composited)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((composited)), (((GType) ((20) << (2)))))))));
    }
    break;

  case META_TEXTURE_BLANK:
  case META_TEXTURE_SHAPE_LIST:
  case META_TEXTURE_COMPOSITE:
    g_assert_not_reached ()do { g_assertion_message_expr ("croma", "ui/theme.c", 7284, (
(const char*) (__func__)), ((void*)0)); } while (0);
    break;
  }
7287}
7288#endif

7290/**
* Returns the earliest version of the theme format which required support
* for a particular button.  (For example, "shade" first appeared in v2, and
* "close" in v1.)
*
* \param type  the button type
* \return  the number of the theme format
*/
7298guint
7299meta_theme_earliest_version_with_button (MetaButtonType type)
7300{
switch (type)
  {
  case META_BUTTON_TYPE_CLOSE:
  case META_BUTTON_TYPE_MAXIMIZE:
  case META_BUTTON_TYPE_MINIMIZE:
  case META_BUTTON_TYPE_MENU:
  case META_BUTTON_TYPE_LEFT_LEFT_BACKGROUND:
  case META_BUTTON_TYPE_LEFT_MIDDLE_BACKGROUND:
  case META_BUTTON_TYPE_LEFT_RIGHT_BACKGROUND:
  case META_BUTTON_TYPE_RIGHT_LEFT_BACKGROUND:
  case META_BUTTON_TYPE_RIGHT_MIDDLE_BACKGROUND:
  case META_BUTTON_TYPE_RIGHT_RIGHT_BACKGROUND:
    return 1000;

  case META_BUTTON_TYPE_SHADE:
  case META_BUTTON_TYPE_ABOVE:
  case META_BUTTON_TYPE_STICK:
  case META_BUTTON_TYPE_UNSHADE:
  case META_BUTTON_TYPE_UNABOVE:
  case META_BUTTON_TYPE_UNSTICK:
    return 2000;

  case META_BUTTON_TYPE_LEFT_SINGLE_BACKGROUND:
  case META_BUTTON_TYPE_RIGHT_SINGLE_BACKGROUND:
    return 3003;

  case META_BUTTON_TYPE_APPMENU:
    return 3005;

  default:
    meta_warning("Unknown button %d\n", type);
    return 1000;
  }
7334}