Federico gets into pixel-perfect neurosis. Xmag is my best friend.

2000-12-01  Federico Mena Quintero  <federico@helixcode.com>

	Federico gets into pixel-perfect neurosis.  Xmag is my best friend.

	* e-table-item.c (eti_draw): Set the focus_gc stipple origin to
	match the upper-left corner of the focus rectangle.  This way
	focusing will look consistent even among rows/columns with odd
	pixel sizes.  Also, make the focus rectangle span the whole cell;
	there was one blank pixel column to the left of the rectangle.

	* e-table-header-utils.c: New file with utilities for drawing
	header buttons.  This is so that ETableHeaderItem and
	ETableFieldChooserItem can share the same code.
	(e_table_header_compute_height): New function to compute the
	height of a column button.
	(make_composite_pixmap): New function to composite a pixbuf
	against a solid background and make a pixmap out of the result.
	This does some ultra-fancy fading-out of the original pixbuf if
	the destination area is smaller than the source.
	(compute_elision_length): New function to compute the elision
	length in O(n log n) instead of O(n^2), for n = strlen (str).
	(e_table_header_draw_button): New function to draw a header
	button.
	(e_table_draw_elided_string): New function to draw a string elided
	to a maximum width.

	* e-table-defines.h (HEADER_PADDING): Made the default padding be
	1; now a header button's height is
	content_height + 2 * (HEADER_PADDING + style->ythickness).  This
	is the correct way to measure button heights.

	* e-table-field-chooser-item.c (etfci_find_button): Use
	e_table_header_compute_height().
	(etfci_reflow): Likewise.
	(etfci_draw): Use e_table_header_draw_button().
	(etfci_start_drag): Likewise.
	(etfci_draw): Likewise.
	(etfci_start_drag): Likewise.
	(etfci_button_height): Removed function.
	(draw_button): Removed function.

	* e-table-header-item.c (draw_button): Removed function.
	(e_table_header_item_get_height): Use e_table_header_compute_height().
	(ethi_draw): e_table_header_draw_button().
	(ethi_start_drag): Likewise.
	(make_shaped_window_from_xpm): Fixed misspelling in function name.
	(draw_button): Removed function.

	* Makefile.am: Added e-table-header-utils.[ch].

svn path=/trunk/; revision=6766

1 files changed, 419 insertions, 0 deletions

diff --git a/widgets/table/e-table-header-utils.c b/widgets/table/e-table-header-utils.c
new file mode 100644
index 0000000000..99fdba680f
--- /dev/null
+++ b/widgets/table/e-table-header-utils.c
@@ -0,0 +1,419 @@
+/* ETable widget - utilities for drawing table header buttons
+ *
+ * Copyright (C) 2000 Helix Code, Inc.
+ *
+ * Authors: Chris Lahey <clahey@helixcode.com>
+ *          Miguel de Icaza <miguel@helixcode.com>
+ *          Federico Mena-Quintero <federico@helixcode.com>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include "e-table-defines.h"
+#include "e-table-header-utils.h"
+
+
+
+/**
+ * e_table_header_compute_height:
+ * @ecol: Table column description.
+ * @style: Style for the button's bevel.
+ * @font: Font for the button's text, or NULL if no font is available.
+ *
+ * Computes the minimum height required for a table header button.
+ *
+ * Return value: The height of the button, in pixels.
+ **/
+int
+e_table_header_compute_height (ETableCol *ecol, GtkStyle *style, GdkFont *font)
+{
+	int ythick;
+	int height;
+
+	g_return_val_if_fail (ecol != NULL, -1);
+	g_return_val_if_fail (E_IS_TABLE_COL (ecol), -1);
+	g_return_val_if_fail (style != NULL, -1);
+
+	ythick = style->klass->ythickness;
+
+	if (font)
+		height = font->ascent + font->descent;
+	else
+		height = 16; /* FIXME: default? */
+
+	if (ecol->is_pixbuf) {
+		g_assert (ecol->pixbuf != NULL);
+		height = MAX (height, gdk_pixbuf_get_height (ecol->pixbuf));
+	}
+
+	height = MAX (height, MIN_ARROW_SIZE);
+
+	height += 2 * (ythick + HEADER_PADDING);
+
+	return height;
+}
+
+/* Creates a pixmap that is a composite of a background color and the upper-left
+ * corner rectangle of a pixbuf.
+ */
+static GdkPixmap *
+make_composite_pixmap (GdkDrawable *drawable, GdkGC *gc,
+		       GdkPixbuf *pixbuf, GdkColor *bg, int width, int height,
+		       int dither_xofs, int dither_yofs)
+{
+	int pwidth, pheight;
+	GdkPixmap *pixmap;
+	GdkPixbuf *tmp;
+	int color;
+
+	pwidth = gdk_pixbuf_get_width (pixbuf);
+	pheight = gdk_pixbuf_get_height (pixbuf);
+	g_assert (width <= pwidth && height <= pheight);
+
+	color = ((bg->red & 0xff00) << 8) | (bg->green & 0xff00) | ((bg->blue & 0xff00) >> 8);
+
+	if (width >= pwidth && height >= pheight) {
+		tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
+		if (!tmp)
+			return NULL;
+
+		gdk_pixbuf_composite_color (pixbuf, tmp,
+					    0, 0,
+					    width, height,
+					    0, 0,
+					    1.0, 1.0,
+					    GDK_INTERP_NEAREST,
+					    255,
+					    0, 0,
+					    16,
+					    color, color);
+	} else {
+		int x, y, rowstride;
+		GdkPixbuf *fade;
+		guchar *pixels;
+
+		/* Do a nice fade of the pixbuf down and to the right */
+
+		fade = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
+		if (!fade)
+			return NULL;
+
+		gdk_pixbuf_copy_area (pixbuf,
+				      0, 0,
+				      width, height,
+				      fade,
+				      0, 0);
+
+		rowstride = gdk_pixbuf_get_rowstride (fade);
+		pixels = gdk_pixbuf_get_pixels (fade);
+
+		for (y = 0; y < height; y++) {
+			guchar *p;
+			int yfactor;
+
+			p = pixels + y * rowstride;
+
+			if (height < pheight)
+				yfactor = height - y;
+			else
+				yfactor = height;
+
+			for (x = 0; x < width; x++) {
+				int xfactor;
+
+				if (width < pwidth)
+					xfactor = width - x;
+				else
+					xfactor = width;
+
+				p[3] = ((int) p[3] * xfactor * yfactor / (width * height));
+				p += 4;
+			}
+		}
+
+		tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
+		if (!tmp) {
+			gdk_pixbuf_unref (fade);
+			return NULL;
+		}
+
+		gdk_pixbuf_composite_color (fade, tmp,
+					    0, 0,
+					    width, height,
+					    0, 0,
+					    1.0, 1.0,
+					    GDK_INTERP_NEAREST,
+					    255,
+					    0, 0,
+					    16,
+					    color, color);
+
+		gdk_pixbuf_unref (fade);
+	}
+
+	pixmap = gdk_pixmap_new (drawable, width, height, gdk_rgb_get_visual ()->depth);
+	gdk_draw_rgb_image_dithalign (pixmap, gc,
+				      0, 0,
+				      width, height,
+				      GDK_RGB_DITHER_NORMAL,
+				      gdk_pixbuf_get_pixels (tmp),
+				      gdk_pixbuf_get_rowstride (tmp),
+				      dither_xofs, dither_yofs);
+	gdk_pixbuf_unref (tmp);
+
+	return pixmap;
+}
+
+/**
+ * e_table_header_draw_button:
+ * @drawable: Destination drawable.
+ * @ecol: Table column for the header information.
+ * @style: Style to use for drawing the button.
+ * @font: Font for the button's text.
+ * @state: State of the table widget.
+ * @widget: The table widget.
+ * @gc: GC to use for drawing.
+ * @x: Leftmost coordinate of the button.
+ * @y: Topmost coordinate of the button.
+ * @width: Width of the region to draw.
+ * @height: Height of the region to draw.
+ * @button_width: Width for the complete button.
+ * @button_height: Height for the complete button.
+ * @arrow: Arrow type to use as a sort indicator.
+ * 
+ * Draws a button suitable for a table header.
+ **/
+void
+e_table_header_draw_button (GdkDrawable *drawable, ETableCol *ecol,
+			    GtkStyle *style, GdkFont *font, GtkStateType state,
+			    GtkWidget *widget, GdkGC *gc,
+			    int x, int y, int width, int height,
+			    int button_width, int button_height,
+			    ETableColArrow arrow)
+{
+	int xthick, ythick;
+	int inner_x, inner_y;
+	int inner_width, inner_height;
+
+	g_return_if_fail (drawable != NULL);
+	g_return_if_fail (ecol != NULL);
+	g_return_if_fail (E_IS_TABLE_COL (ecol));
+	g_return_if_fail (style != NULL);
+	g_return_if_fail (font != NULL);
+	g_return_if_fail (widget != NULL);
+	g_return_if_fail (GTK_IS_WIDGET (widget));
+	g_return_if_fail (button_width > 0 && button_height > 0);
+
+	xthick = style->klass->xthickness;
+	ythick = style->klass->ythickness;
+
+	/* Button bevel */
+
+	gtk_paint_box (style, drawable, state, GTK_SHADOW_OUT,
+		       NULL, widget, "button",
+		       x, y, button_width, button_height);
+
+	/* Inside area */
+
+	inner_width = button_width - 2 * (xthick + HEADER_PADDING);
+	inner_height = button_height - 2 * (ythick + HEADER_PADDING);
+
+	if (inner_width < 1 || inner_height < 1)
+		return; /* nothing fits */
+
+	inner_x = x + xthick + HEADER_PADDING;
+	inner_y = y + ythick + HEADER_PADDING;
+
+	/* Arrow */
+
+	switch (arrow) {
+	case E_TABLE_COL_ARROW_NONE:
+		break;
+
+	case E_TABLE_COL_ARROW_UP:
+	case E_TABLE_COL_ARROW_DOWN: {
+		int arrow_width, arrow_height;
+
+		arrow_width = MIN (MIN_ARROW_SIZE, inner_width);
+		arrow_height = MIN (MIN_ARROW_SIZE, inner_height);
+
+		gtk_paint_arrow (style, drawable, state,
+				 GTK_SHADOW_IN, NULL, widget, "header",
+				 (arrow == E_TABLE_COL_ARROW_UP) ? GTK_ARROW_UP : GTK_ARROW_DOWN,
+				 TRUE,
+				 inner_x + inner_width - arrow_width,
+				 inner_y + (inner_height - arrow_height) / 2,
+				 arrow_width, arrow_height);
+
+		inner_width -= arrow_width + HEADER_PADDING;
+		break;
+	}
+
+	default:
+		g_assert_not_reached ();
+		return;
+	}
+
+	if (inner_width < 1)
+		return; /* nothing else fits */
+
+	/* Pixbuf or label */
+
+	if (ecol->is_pixbuf) {
+		int pwidth, pheight;
+		int clip_width, clip_height;
+		GdkPixmap *pixmap;
+
+		g_assert (ecol->pixbuf != NULL);
+
+		pwidth = gdk_pixbuf_get_width (ecol->pixbuf);
+		pheight = gdk_pixbuf_get_height (ecol->pixbuf);
+
+		clip_width = MIN (pwidth, inner_width);
+		clip_height = MIN (pheight, inner_height);
+
+		pixmap = make_composite_pixmap (drawable, gc,
+						ecol->pixbuf, &style->bg[state],
+						clip_width, clip_height,
+						inner_x,
+						inner_y + (inner_height - clip_height) / 2);
+		if (pixmap) {
+			gdk_draw_pixmap (drawable, gc, pixmap,
+					 0, 0,
+					 inner_x,
+					 inner_y + (inner_height - clip_height) / 2,
+					 clip_width, clip_height);
+			gdk_pixmap_unref (pixmap);
+		}
+	} else {
+		int ypos;
+
+		ypos = inner_y + (inner_height - font->ascent - font->descent) / 2 + font->ascent;
+
+		e_table_draw_elided_string (drawable, font, gc,
+					    inner_x, ypos,
+					    ecol->text, inner_width, TRUE);
+	}
+}
+
+/* Computes the length of a string that needs to be trimmed for elision */
+static int
+compute_elision_length (GdkFont *font, const char *str, int max_width)
+{
+	int len;
+	int l, left, right;
+	int rbearing;
+
+	len = strlen (str);
+	g_assert (len > 0);
+
+	left = 0;
+	right = len;
+
+	while (left < right) {
+		l = (left + right) / 2;
+		gdk_text_extents (font, str, l, NULL, &rbearing, NULL, NULL, NULL);
+
+		if (rbearing < max_width)
+			left = l + 1;
+		else if (rbearing > max_width)
+			right = l;
+		else
+			return l;
+	}
+
+	if (rbearing > max_width)
+		return MAX (0, l - 1);
+	else
+		return l;
+}
+
+/* Default width of the elision arrow in pixels */
+#define ARROW_WIDTH 4
+
+/**
+ * e_table_draw_elided_string:
+ * @drawable: Destination drawable.
+ * @font: Font for the text.
+ * @gc: GC to use for drawing.
+ * @x: X insertion point for the string.
+ * @y: Y insertion point for the string's baseline.
+ * @str: String to draw.
+ * @max_width: Maximum width in which the string must fit.
+ * @center: Whether to center the string in the available area if it does fit.
+ * 
+ * Draws a string, possibly trimming it so that it fits inside the specified
+ * maximum width.  If it does not fit, an elision indicator is drawn after the
+ * last character that does fit.
+ **/
+void
+e_table_draw_elided_string (GdkDrawable *drawable, GdkFont *font, GdkGC *gc,
+			    int x, int y, const char *str, int max_width, gboolean center)
+{
+	int rbearing;
+	int width;
+
+	g_return_if_fail (drawable != NULL);
+	g_return_if_fail (font != NULL);
+	g_return_if_fail (gc != NULL);
+	g_return_if_fail (str != NULL);
+	g_return_if_fail (max_width >= 0);
+
+	gdk_string_extents (font, str, NULL, &rbearing, &width, NULL, NULL);
+
+	if (rbearing <= max_width) {
+		int xpos;
+
+		if (center)
+			xpos = x + (max_width - width) / 2;
+		else
+			xpos = x;
+
+		gdk_draw_string (drawable, font, gc, xpos, y, str);
+	} else {
+		int arrow_width;
+		int len;
+		int i;
+
+		if (max_width < ARROW_WIDTH + 1)
+			arrow_width = max_width - 1;
+		else
+			arrow_width = ARROW_WIDTH;
+
+		len = compute_elision_length (font, str, max_width - arrow_width - 1);
+		gdk_draw_text (drawable, font, gc, x, y, str, len);
+
+		gdk_text_extents (font, str, len, NULL, &rbearing, NULL, NULL, NULL);
+
+		y -= font->ascent;
+
+		for (i = 0; i < arrow_width; i++) {
+			int h;
+
+			h = 2 * i + 1;
+
+			gdk_draw_line (drawable, gc,
+				       x + rbearing + arrow_width - i,
+				       y + (font->ascent + font->descent - h) / 2,
+				       x + rbearing + arrow_width - i,
+				       y + (font->ascent + font->descent - h) / 2 + h - 1);
+		}
+	}
+}