Initial revision

1 files changed, 360 insertions, 0 deletions

diff --git a/eazel-engine/src/eazel-theme-gradient.c b/eazel-engine/src/eazel-theme-gradient.c
new file mode 100644
index 0000000..fad6d4c
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-gradient.c
@@ -0,0 +1,360 @@
+/* eazel-theme-gradient.c -- code for drawing gradients
+
+   Copyright (C) 2000 Eazel, Inc.
+
+   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-gradient.c,v 1.6 2001/01/18 01:20:04 jsh Exp $
+
+   Authors: John Harper <jsh@eazel.com>  */
+
+/* AIX requires this to be the first thing in the file.  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+ #pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+   char *alloca ();
+#   endif
+#  endif
+# endif
+#endif
+
+#include "eazel-theme.h"
+#include <gdk/gdkrgb.h>
+#include <stdlib.h>
+
+static GdkRgbDither dither_mode = GDK_RGB_DITHER_MAX;
+
+eazel_engine_gradient *
+eazel_engine_gradient_new (eazel_engine_gradient_direction direction,
+			   GdkColor *from, GSList *components)
+{
+    eazel_engine_gradient *g;
+
+    g_return_val_if_fail (from != NULL, NULL);
+
+    g = g_new (eazel_engine_gradient, 1);
+    g->refcount = 1;
+    g->direction = direction;
+    g->from = *from;
+    g->components = components;
+    return g;
+}
+
+eazel_engine_gradient *
+eazel_engine_gradient_ref (eazel_engine_gradient *g)
+{
+    g_return_val_if_fail (g != NULL, NULL);
+
+    g->refcount++;
+    return g;
+}
+
+void
+eazel_engine_gradient_unref (eazel_engine_gradient *g)
+{
+    g_return_if_fail (g != NULL);
+    g->refcount--;
+
+    if (g->refcount == 0)
+    {
+	GSList *x;
+	for (x = g->components; x != 0; x = x->next)
+	    g_free (x->data);
+	g_slist_free (g->components);
+	g_free (g);
+    }
+}
+
+eazel_engine_gradient *
+eazel_engine_make_two_point_gradient (eazel_engine_gradient_direction direction,
+				      gulong from_rgb, gulong to_rgb)
+{
+    GdkColor from, to;
+    eazel_engine_gradient_component *component;
+
+    g_return_val_if_fail (direction != GRADIENT_NONE, NULL);
+
+    from.red = (from_rgb >> 16) & 255;
+    from.red |= from.red << 8;
+    from.green = (from_rgb >> 8) & 255;
+    from.green |= from.green << 8;
+    from.blue = (from_rgb >> 0) & 255;
+    from.blue |= from.blue << 8;
+
+    to.red = (to_rgb >> 16) & 255;
+    to.red |= to.red << 8;
+    to.green = (to_rgb >> 8) & 255;
+    to.green |= to.green << 8;
+    to.blue = (to_rgb >> 0) & 255;
+    to.blue |= to.blue << 8;
+
+    component = g_new (eazel_engine_gradient_component, 1);
+    component->color = to;
+    component->weight = 1.0;
+
+    return eazel_engine_gradient_new (direction, &from,
+				      g_slist_prepend (NULL, component));
+}
+
+
+/* rendering */
+
+static inline void
+fill_gradient_rgb_buffer_1 (const GdkColor *from, const GdkColor *to,
+			    int rgb_total, guchar *rgb_buf,
+			    int rgb_first, int rgb_last)
+{
+    int delta_r = to->red - from->red;
+    int delta_g = to->green - from->green;
+    int delta_b = to->blue - from->blue;
+    guchar *rgb_ptr = rgb_buf;
+    int i;
+
+    g_return_if_fail (rgb_first <= rgb_last && rgb_last <= rgb_total);
+
+    for (i = rgb_first; i < rgb_last; i++)
+    {
+	*rgb_ptr++ = (from->red + (delta_r * i) / rgb_total) >> 8;
+	*rgb_ptr++ = (from->green + (delta_g * i) / rgb_total) >> 8;
+	*rgb_ptr++ = (from->blue + (delta_b * i) / rgb_total) >> 8;
+    }
+}
+
+void
+eazel_engine_fill_gradient_rgb_buffer (const eazel_engine_gradient *gradient,
+				       int rgb_total, guchar *rgb_buf,
+				       int rgb_first, int rgb_last)
+{
+    g_return_if_fail (gradient != NULL);
+    g_return_if_fail (rgb_buf != NULL);
+
+    if (gradient->components == 0)
+    {
+	/* Single color `gradient' */
+	fill_gradient_rgb_buffer_1 (&gradient->from, &gradient->from,
+				     rgb_total, rgb_buf, rgb_first, rgb_last);
+    }
+    else
+    {
+	float total_weight, weight_ptr;
+	int rgb_ptr;
+	GSList *x;
+	const GdkColor *pred;
+
+	total_weight = 0.0;
+	for (x = gradient->components; x != 0; x = x->next)
+	{
+	    eazel_engine_gradient_component *c = x->data;
+	    total_weight += c->weight;
+	}
+
+	rgb_ptr = 0;
+	weight_ptr = 0.0;
+	pred = &gradient->from;
+	for (x = gradient->components; x != 0; x = x->next)
+	{
+	    eazel_engine_gradient_component *c = x->data;
+	    int rgb_chunk = (c->weight * rgb_total) / total_weight;
+
+	    int first = MAX (rgb_first, rgb_ptr);
+	    int last = MIN (rgb_last, rgb_ptr + rgb_chunk);
+
+	    if (x->next == 0)
+		last = rgb_last;
+
+	    if (last > first)
+	    {
+		fill_gradient_rgb_buffer_1 (pred, &c->color,
+					    last - first,
+					    rgb_buf + rgb_ptr * 3,
+					    first - rgb_ptr,
+					    last - rgb_ptr);
+	    }
+
+	    pred = &c->color;
+	    weight_ptr += c->weight;
+	    rgb_ptr += rgb_chunk;
+	}
+    }
+}
+
+static void
+draw_vertical_gradient (GdkDrawable *drawable, GdkGC *gc,
+			const GdkRectangle *full_rect,
+			const GdkRectangle *clip_rect,
+			const eazel_engine_gradient *gradient)
+{
+    int rgb_size = clip_rect->height;
+    guchar *rgb = alloca (rgb_size * 3), *ptr;
+
+    eazel_engine_fill_gradient_rgb_buffer (gradient, full_rect->height, rgb,
+					   clip_rect->y - full_rect->y,
+					   (clip_rect->y + clip_rect->height)
+					   - full_rect->y);
+
+    if (dither_mode == GDK_RGB_DITHER_NONE)
+    {
+	GdkColormap *sys_lut = gdk_colormap_get_system ();
+	GdkGCValues old_values;
+	int y;
+
+	gdk_gc_get_values (gc, &old_values);
+
+	ptr = rgb;
+	for (y = clip_rect->y; y < clip_rect->y + clip_rect->height; y++)
+	{
+	    guchar r = *ptr++;
+	    guchar g = *ptr++;
+	    guchar b = *ptr++;
+	    GdkColor color = { 0, r << 8, g << 8, b << 8 };
+	    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+	    gdk_gc_set_foreground (gc, &color);
+	    gdk_draw_line (drawable, gc, clip_rect->x, y,
+			   clip_rect->x + clip_rect->width - 1, y);
+	}
+
+	gdk_gc_set_foreground (gc, &old_values.foreground);
+    }
+    else
+    {
+	guchar *xrgb = alloca (clip_rect->width * clip_rect->height * 3);
+	int x, y;
+	guchar *ptr_in = rgb, *ptr_out = xrgb;
+	for (y = 0; y < clip_rect->height; y++)
+	{
+	    guchar r = *ptr_in++;
+	    guchar g = *ptr_in++;
+	    guchar b = *ptr_in++;
+	    for (x = 0; x < clip_rect->width; x++)
+	    {
+		*ptr_out++ = r;
+		*ptr_out++ = g;
+		*ptr_out++ = b;
+	    }
+	}
+	gdk_draw_rgb_image (drawable, gc, clip_rect->x, clip_rect->y,
+			    clip_rect->width, clip_rect->height,
+			    dither_mode, xrgb, clip_rect->width * 3);
+    }
+}
+
+static void
+draw_horizontal_gradient (GdkDrawable *drawable, GdkGC *gc,
+			  const GdkRectangle *full_rect,
+			  const GdkRectangle *clip_rect,
+			  const eazel_engine_gradient *gradient)
+{
+    int rgb_size = clip_rect->width;
+    guchar *rgb = alloca (rgb_size * 3), *ptr;
+
+    eazel_engine_fill_gradient_rgb_buffer (gradient, full_rect->width, rgb,
+					   clip_rect->x - full_rect->x,
+					   (clip_rect->x + clip_rect->width)
+					   - full_rect->x);
+
+    if (dither_mode == GDK_RGB_DITHER_NONE)
+    {
+	GdkColormap *sys_lut = gdk_colormap_get_system ();
+	GdkGCValues old_values;
+	int x;
+
+	gdk_gc_get_values (gc, &old_values);
+
+	ptr = rgb;
+	for (x = clip_rect->x; x < clip_rect->x + clip_rect->width; x++)
+	{
+	    guchar r = *ptr++;
+	    guchar g = *ptr++;
+	    guchar b = *ptr++;
+	    GdkColor color = { 0, r << 8, g << 8, b << 8 };
+	    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+	    gdk_gc_set_foreground (gc, &color);
+	    gdk_draw_line (drawable, gc, x, clip_rect->y,
+			   x, clip_rect->y + clip_rect->height - 1);
+	}
+
+	gdk_gc_set_foreground (gc, &old_values.foreground);
+    }
+    else
+    {
+	/* Using a row-stride of zero means we only need a single
+	   row of rgb-data (inspired by nautilus-background.c) */
+	gdk_draw_rgb_image (drawable, gc, clip_rect->x, clip_rect->y,
+			    clip_rect->width, clip_rect->height,
+			    dither_mode, rgb, 0);
+    }
+}
+
+void
+eazel_engine_draw_gradient (GdkDrawable *drawable,
+			    GdkGC *gc,
+			    const GdkRectangle *full_rect,
+			    const GdkRectangle *clip_rect,
+			    const eazel_engine_gradient *gradient)
+{
+    if (gradient->direction == GRADIENT_VERTICAL)
+    {
+	draw_vertical_gradient (drawable, gc, full_rect, clip_rect, gradient);
+    }
+    else if (gradient->direction == GRADIENT_HORIZONTAL)
+    {
+	draw_horizontal_gradient (drawable, gc, full_rect, clip_rect, gradient);
+    }
+}
+
+void
+eazel_engine_set_bg_gradient (GdkWindow *window,
+			      eazel_engine_gradient *gradient)
+{
+    /* Render a tile of the specified gradient to a pixmap, then
+       set it as the background pixmap of the window. */
+
+    GdkRectangle area = { 0, 0 };
+    GdkPixmap *pixmap;
+    GdkGC *pixmap_gc;
+
+    int window_x, window_y, window_width, window_height, window_depth;
+
+    gdk_window_get_geometry (window, &window_x, &window_y,
+			     &window_width, &window_height, &window_depth);
+
+    if (gradient->direction == GRADIENT_VERTICAL)
+    {
+	area.width = 32;
+	area.height = window_height;
+    }
+    else
+    {
+	area.width = window_width;
+	area.height = 32;
+    }
+    
+    pixmap = gdk_pixmap_new (window, area.width, area.height, window_depth);
+    pixmap_gc = gdk_gc_new (pixmap);
+
+    eazel_engine_draw_gradient (pixmap, pixmap_gc, &area, &area, gradient);
+
+    gdk_window_set_back_pixmap (window, pixmap, FALSE);
+    gdk_gc_unref (pixmap_gc);
+    gdk_pixmap_unref (pixmap);
+}