#define __USE_XOPEN

#include <math.h>

#define GDK_COLOR_RGBA(color) \

((guint32) (0xff | \

(((color).red / 256) << 24) | \

((guint32) ((((color).red / 256) << 16) | \

(((color).green / 256) << 8) | \

(((color).blue / 256))))

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

#define CLAMP_UCHAR(v) ((guchar) (CLAMP (((int)v), (int)0, (int)255)))

#define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11)

static void gtk_style_shade (GdkColor *a,

GdkColor *b,

gdouble k);

static void rgb_to_hls (gdouble *r,

gdouble *g,

gdouble *b);

*/

static MetaTheme *meta_current_theme = NULL;

static GdkPixbuf *

colorize_pixbuf (GdkPixbuf *orig,

GdkColor *new_color)

{

GdkPixbuf *pixbuf;

double intensity;

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) / 65535.0;

dg = (new_color->green * intensity * 2.0) / 65535.0;

db = (new_color->blue * intensity * 2.0) / 65535.0;

}

else

{

/* Go from new_color at intensity = 0.5 to white at intensity = 1.0 */

dr = (new_color->red + (65535 - new_color->red) * (intensity - 0.5) * 2.0) / 65535.0;

dg = (new_color->green + (65535 - new_color->green) * (intensity - 0.5) * 2.0) / 65535.0;

db = (new_color->blue + (65535 - new_color->blue) * (intensity - 0.5) * 2.0) / 65535.0;

}

dest[0] = CLAMP_UCHAR (255 * dr);

return pixbuf;

}

static void

color_composite (const GdkColor *bg,

const GdkColor *fg,

color->green = color->green + (((fg->green - color->green) * alpha + 0x8000) >> 16);

color->blue = color->blue + (((fg->blue - color->blue) * alpha + 0x8000) >> 16);

}

/**

* Sets all the fields of a border to dummy values.

else

g_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);

g_free (spec);

}

GdkPixbuf*

meta_gradient_spec_render (const MetaGradientSpec *spec,

int width,

int height)

{

int n_colors;

GdkColor *colors;

GSList *tmp;

int i;

GdkPixbuf *pixbuf;

if (n_colors == 0)

return NULL;

colors = g_new (GdkColor, n_colors);

i = 0;

tmp = spec->color_specs;

while (tmp != NULL)

{

tmp = tmp->next;

++i;

const char *bracket;

const char *end_bracket;

char *tmp;

GtkStateType state;

MetaGtkColorComponent component;

bracket = str;

{

spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);

if (!gdk_color_parse (str, &spec->data.basic.color))

{

g_set_error (err, META_THEME_ERROR,

META_THEME_ERROR_FAILED,

return spec;

}

MetaColorSpec*

meta_color_spec_new_gtk (MetaGtkColorComponent component,

GtkStateType state)

{

MetaColorSpec *spec;

return spec;

}

void

meta_color_spec_render (MetaColorSpec *spec,

GdkColor *color)

{

g_return_if_fail (spec != NULL);

switch (spec->type)

{

break;

case META_COLOR_SPEC_GTK:

break;

case META_COLOR_SPEC_BLEND:

{

GdkColor bg, fg;

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

&spec->data.blend.color);

case META_COLOR_SPEC_SHADE:

{

&spec->data.shade.color);

gtk_style_shade (&spec->data.shade.color,

static GdkPixbuf*

draw_op_as_pixbuf (const MetaDrawOp *op,

const MetaDrawInfo *info,

int width,

int height)

case META_DRAW_RECTANGLE:

if (op->data.rectangle.filled)

{

GdkColor color;

meta_color_spec_render (op->data.rectangle.color_spec,

&color);

pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,

case META_DRAW_TINT:

{

GdkColor color;

guint32 rgba;

gboolean has_alpha;

meta_color_spec_render (op->data.rectangle.color_spec,

&color);

has_alpha =

case META_DRAW_GRADIENT:

{

pixbuf = meta_gradient_spec_render (op->data.gradient.gradient_spec,

pixbuf = apply_alpha (pixbuf,

op->data.gradient.alpha_spec,

{

if (op->data.image.colorize_spec)

{

GdkColor color;

meta_color_spec_render (op->data.image.colorize_spec,

if (op->data.image.colorize_cache_pixbuf == NULL ||

op->data.image.colorize_cache_pixel != GDK_COLOR_RGB (color))

env->theme = meta_current_theme;

}

/* 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

meta_draw_op_draw_with_env (const MetaDrawOp *op,

#if GTK_CHECK_VERSION(3, 0, 0)

GtkStyleContext *style_gtk,

cairo_t *cr,

#else

GdkDrawable *drawable,

const GdkRectangle *clip,

#endif

MetaRectangle rect,

MetaPositionExprEnv *env)

{

#if GTK_CHECK_VERSION(3, 0, 0)

#else

cairo_t *cr;

cr = gdk_cairo_create (drawable);

#endif

{

int x1, x2, y1, y2;

gdk_cairo_set_source_color (cr, &color);

if (op->data.line.width > 0)

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

{

int rx, ry, rwidth, rheight;

gdk_cairo_set_source_color (cr, &color);

rx = parse_x_position_unchecked (op->data.rectangle.x, env);

ry = parse_y_position_unchecked (op->data.rectangle.y, env);

double start_angle, end_angle;

double center_x, center_y;

gdk_cairo_set_source_color (cr, &color);

rx = parse_x_position_unchecked (op->data.arc.x, env);

ry = parse_y_position_unchecked (op->data.arc.y, env);

if (!needs_alpha)

{

gdk_cairo_set_source_color (cr, &color);

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

cairo_fill (cr);

{

GdkPixbuf *pixbuf;

rwidth, rheight);

if (pixbuf)

rwidth = parse_size_unchecked (op->data.gradient.width, env);

rheight = parse_size_unchecked (op->data.gradient.height, env);

rwidth, rheight);

if (pixbuf)

rwidth = parse_size_unchecked (op->data.image.width, env);

rheight = parse_size_unchecked (op->data.image.height, env);

rwidth, rheight);

if (pixbuf)

return;

}

gtk_render_arrow (style_gtk, cr, angle, rx, ry, size);

#else

rheight = parse_size_unchecked (op->data.gtk_box.height, env);

#if GTK_CHECK_VERSION(3, 0, 0)

gtk_render_background (style_gtk, cr, rx, ry, rwidth, rheight);

gtk_render_frame (style_gtk, cr, rx, ry, rwidth, rheight);

#else

ry2 = parse_y_position_unchecked (op->data.gtk_vline.y2, env);

#if GTK_CHECK_VERSION(3, 0, 0)

gtk_render_line (style_gtk, cr, rx, ry1, rx, ry2);

#else

gtk_paint_vline (style_gtk,

rwidth = parse_size_unchecked (op->data.icon.width, env);

rheight = parse_size_unchecked (op->data.icon.height, env);

rwidth, rheight);

if (pixbuf)

{

int rx, ry;

gdk_cairo_set_source_color (cr, &color);

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

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

cairo_pattern_t *linpat;

linpat = cairo_pattern_create_linear (rx, ry, text_space,

env->title_height);

cairo_pattern_add_color_stop_rgb (linpat, 0, color.red/65535.0,

color.green/65535.0,

color.blue/65535.0);

cairo_pattern_add_color_stop_rgba (linpat, 1, color.red/65535.0,

color.green/65535.0,

color.blue/65535.0, 0);

cairo_set_source(cr, linpat);

cairo_pattern_destroy(linpat);

} else {

gdk_cairo_set_source_color (cr, &color);

}

cairo_move_to (cr, rx, ry);

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,

#if GTK_CHECK_VERSION(3, 0, 0)

cr,

#else

drawable, clip,

#endif

info, d_rect);

while (tile.y < (ry + rheight))

{

meta_draw_op_list_draw_with_style (op->data.tile.op_list,

tile);

tile.y += tile.height;

while (tile.y < (ry + rheight))

{

meta_draw_op_list_draw_with_style (op->data.tile.op_list,

tile);

tile.y += tile.height;

void

meta_draw_op_draw_with_style (const MetaDrawOp *op,

#if GTK_CHECK_VERSION(3, 0, 0)

cairo_t *cr,

#else

GdkDrawable *drawable,

const GdkRectangle *clip,

#endif

{

MetaPositionExprEnv env;

fill_env (&env, info, logical_region);

#if GTK_CHECK_VERSION(3, 0, 0)

cr,

#else

drawable, clip,

#endif

info, logical_region,

const MetaDrawInfo *info,

MetaRectangle logical_region)

{

#if GTK_CHECK_VERSION(3, 0, 0)

cr,

#else

drawable, clip,

#endif

info, logical_region);

void

meta_draw_op_list_draw_with_style (const MetaDrawOpList *op_list,

#if GTK_CHECK_VERSION(3, 0, 0)

cairo_t *cr,

#else

GdkDrawable *drawable,

const GdkRectangle *clip,

#endif

#endif

MetaPositionExprEnv env;

if (op_list->n_ops == 0)

return;

*/

#if GTK_CHECK_VERSION(3, 0, 0)

#else

if (clip)

{

}

else if (gdk_cairo_get_clip_rectangle (cr, NULL))

{

}

#else

active_clip.height > 0)

{

meta_draw_op_draw_with_env (op,

rect,

&env);

}

}

#if GTK_CHECK_VERSION(3, 0, 0)

#endif

}

MetaRectangle rect)

{

#if GTK_CHECK_VERSION(3, 0, 0)

cr,

#else

drawable, clip,

#endif

info, rect);

meta_frame_style_draw_with_style (MetaFrameStyle *style,

#if GTK_CHECK_VERSION(3, 0, 0)

GtkStyleContext *style_gtk,

cairo_t *cr,

#else

GdkDrawable *drawable,

int x_offset,

int y_offset,

PangoRectangle extents;

MetaDrawInfo draw_info;

titlebar_rect.x = 0;

titlebar_rect.y = 0;

titlebar_rect.width = fgeom->width;

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

meta_draw_op_list_draw_with_style (op_list,

style_gtk,

cr,

&draw_info,

m_rect);

MetaRectangle m_rect;

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

meta_draw_op_list_draw_with_style (op_list,

widget,

drawable,

&combined_clip,

meta_draw_op_list_draw_with_style (op_list,

style_gtk,

cr,

&draw_info,

m_rect);

m_rect = meta_rect (rect.x, rect.y,

rect.width, rect.height);

meta_draw_op_list_draw_with_style (op_list,

widget,

drawable,

&combined_clip,

meta_frame_style_draw_with_style (style,

#if GTK_CHECK_VERSION(3, 0, 0)

gtk_widget_get_style_context (widget),

cr,

#else

drawable, x_offset, y_offset, clip,

#endif

fgeom, client_width, client_height,

meta_theme_draw_frame_with_style (MetaTheme *theme,

#if GTK_CHECK_VERSION(3, 0, 0)

GtkStyleContext *style_gtk,

cairo_t *cr,

#else

GdkDrawable *drawable,

const GdkRectangle *clip,

int x_offset,

theme);

meta_frame_style_draw_with_style (style,

#if GTK_CHECK_VERSION(3, 0, 0)

cr,

#else

drawable, x_offset, y_offset, clip,

#endif

&fgeom,

meta_theme_draw_frame_with_style (theme,

#if GTK_CHECK_VERSION(3, 0, 0)

gtk_widget_get_style_context (widget),

cr,

#else

drawable, clip, x_offset, y_offset,

#endif

type, flags, client_width, client_height,

g_return_val_if_fail (gtk_widget_get_realized (widget), NULL);

font_desc = pango_font_description_copy (gtk_widget_get_style (widget)->font_desc);

if (override)

pango_font_description_merge (font_desc, override, TRUE);

return "<unknown>";

}

GtkStateType

meta_gtk_state_from_string (const char *str)

{

return "<unknown>";

}

GtkShadowType

meta_gtk_shadow_from_string (const char *str)

* \param b [out] the resulting colour

* \param k amount to scale lightness and saturation by

*/

static void

gtk_style_shade (GdkColor *a,

GdkColor *b,

gdouble k)

{

gdouble red;

gdouble green;

gdouble blue;

red = (gdouble) a->red / 65535.0;

green = (gdouble) a->green / 65535.0;

blue = (gdouble) a->blue / 65535.0;

rgb_to_hls (&red, &green, &blue);

hls_to_rgb (&red, &green, &blue);

b->red = red * 65535.0;

b->green = green * 65535.0;

b->blue = blue * 65535.0;

}

/**