From 0b140650f239bd8fec38c9e5a2d09e95dd8440c0 Mon Sep 17 00:00:00 2001 From: Owen Taylor Date: Fri, 24 Sep 2004 17:40:46 +0000 Subject: Up version to 1.7.0. Fri Sep 24 12:59:22 2004 Owen Taylor * configure.in: Up version to 1.7.0. * pango/pango-renderer.[ch] pango/pango.h pango/Makefile.am: Add PangoRenderer, a base class that is subclassed to produce rendering drivers for different backends and purposes. * pango/pangoft2-private.h pango/pangoft2-render.c pango/pangoft2.c: Move rendering into pangoft2-render.c, use PangoRenderer. * pango/pangoft2-fontmap.c pango/pangoft2-private.h: Add _pango_ft2_font_map_get_renderer() to retrieve a singleton fontmap for the fontmap. * pango/pangoxft-render.[ch] pango/pangoxft.c pango/Makefile.am: Make Xft rendering use PangoRenderer, add publically visible, subclassable PangoXftRenderer. * pango/pangoxft-fontmap.c pango/pangoxft-private.h: Add _pango_xft_font_map_get_renderer() to retrieve a singleton fontmap for the fontmap. * examples/xftview.c examples/Makefile.am: Add a test program using the Xft backend. * docs/*: Update minimally for PangoRenderer. --- pango/pango-renderer.c | 1207 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1207 insertions(+) create mode 100644 pango/pango-renderer.c (limited to 'pango/pango-renderer.c') diff --git a/pango/pango-renderer.c b/pango/pango-renderer.c new file mode 100644 index 00000000..620685d1 --- /dev/null +++ b/pango/pango-renderer.c @@ -0,0 +1,1207 @@ +/* Pango + * pango-renderer.h: Base class for rendering + * + * Copyright (C) 2004 Red Hat, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include + +#include "pango-renderer.h" + +#define N_RENDER_PARTS 4 + +#define IS_VALID_PART(part) ((guint)part < N_RENDER_PARTS) + +typedef struct _LineState LineState; +typedef struct _Point Point; + +struct _Point +{ + double x, y; +}; + +struct _LineState +{ + PangoUnderline underline; + PangoRectangle underline_rect; + + gboolean strikethrough; + PangoRectangle strikethrough_rect; + + int logical_rect_end; +}; + +struct _PangoRendererPrivate +{ + PangoColor color[N_RENDER_PARTS]; + gboolean color_set[N_RENDER_PARTS]; + + LineState *line_state; +}; + +static void pango_renderer_finalize (GObject *gobject); +static void pango_renderer_default_draw_glyphs (PangoRenderer *renderer, + PangoFont *font, + PangoGlyphString *glyphs, + int x, + int y); +static void pango_renderer_default_draw_rectangle (PangoRenderer *renderer, + PangoRenderPart part, + int x, + int y, + int width, + int height); +static void pango_renderer_default_draw_error_underline (PangoRenderer *renderer, + int x, + int y, + int width, + int height); +static void pango_renderer_default_prepare_run (PangoRenderer *renderer, + PangoLayoutRun *run); + +static void pango_renderer_prepare_run (PangoRenderer *renderer, + PangoLayoutRun *run); + +static void +to_device (PangoMatrix *matrix, + double x, + double y, + Point *result) +{ + if (matrix) + { + result->x = (x * matrix->xx + y * matrix->xy) / PANGO_SCALE + matrix->x0; + result->y = (x * matrix->yx + y * matrix->yy) / PANGO_SCALE + matrix->y0; + } + else + { + result->x = x / PANGO_SCALE; + result->y = y / PANGO_SCALE; + } +} + +G_DEFINE_ABSTRACT_TYPE (PangoRenderer, pango_renderer, G_TYPE_OBJECT) + +static void +pango_renderer_class_init (PangoRendererClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + klass->draw_glyphs = pango_renderer_default_draw_glyphs; + klass->draw_rectangle = pango_renderer_default_draw_rectangle; + klass->draw_error_underline = pango_renderer_default_draw_error_underline; + klass->prepare_run = pango_renderer_default_prepare_run; + + gobject_class->finalize = pango_renderer_finalize; + + g_type_class_add_private (gobject_class, sizeof (PangoRendererPrivate)); +} + +static void +pango_renderer_init (PangoRenderer *renderer) +{ + renderer->priv = G_TYPE_INSTANCE_GET_PRIVATE (renderer, + PANGO_TYPE_RENDERER, + PangoRendererPrivate); + renderer->matrix = NULL; +} + +static void +pango_renderer_finalize (GObject *gobject) +{ + PangoRenderer *renderer = PANGO_RENDERER (gobject); + + if (renderer->matrix) + pango_matrix_free (renderer->matrix); +} + +/** + * pango_renderer_draw_layout: + * @renderer: a #PangoRenderer + * @layout: a #PangoLayout + * @x: x position of left edge of baseline, in user space coordinates + * in Pango units. + * @y: x position of left edge of baseline, in user space coordinates + * in Pango units. + * + * Draws @layout with the specified #PangoRenderer. + * + * Since: 1.8 + **/ +void +pango_renderer_draw_layout (PangoRenderer *renderer, + PangoLayout *layout, + int x, + int y) +{ + PangoLayoutIter *iter; + + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + g_return_if_fail (PANGO_IS_LAYOUT (layout)); + + /* We only change the matrix if the renderer isn't already + * active. + */ + if (!renderer->active_count) + { + PangoContext *context = pango_layout_get_context (layout); + pango_renderer_set_matrix (renderer, + pango_context_get_matrix (context)); + } + + pango_renderer_activate (renderer); + + iter = pango_layout_get_iter (layout); + + do + { + PangoRectangle logical_rect; + PangoLayoutLine *line; + int baseline; + + line = pango_layout_iter_get_line (iter); + + pango_layout_iter_get_line_extents (iter, NULL, &logical_rect); + baseline = pango_layout_iter_get_baseline (iter); + + pango_renderer_draw_layout_line (renderer, + line, + x + logical_rect.x, + y + baseline); + } + while (pango_layout_iter_next_line (iter)); + + pango_layout_iter_free (iter); + + pango_renderer_deactivate (renderer); +} + +static void +draw_underline (PangoRenderer *renderer, + LineState *state) +{ + PangoRectangle *rect = &state->underline_rect; + + switch (state->underline) + { + case PANGO_UNDERLINE_NONE: + break; + case PANGO_UNDERLINE_DOUBLE: + pango_renderer_draw_rectangle (renderer, + PANGO_RENDER_PART_UNDERLINE, + rect->x, + rect->y + 2 * rect->height, + rect->width, + rect->height); + /* Fall through */ + case PANGO_UNDERLINE_SINGLE: + case PANGO_UNDERLINE_LOW: + pango_renderer_draw_rectangle (renderer, + PANGO_RENDER_PART_UNDERLINE, + rect->x, + rect->y, + rect->width, + rect->height); + break; + case PANGO_UNDERLINE_ERROR: + pango_renderer_draw_error_underline (renderer, + rect->x, + rect->y, + rect->width, + 3 * rect->height); + break; + } + + state->underline = PANGO_UNDERLINE_NONE; +} + +static void +draw_strikethrough (PangoRenderer *renderer, + LineState *state) +{ + PangoRectangle *rect = &state->strikethrough_rect; + + if (state->strikethrough) + pango_renderer_draw_rectangle (renderer, + PANGO_RENDER_PART_STRIKETHROUGH, + rect->x, + rect->y, + rect->width, + rect->height); + + state->strikethrough = FALSE; +} + +static void +handle_line_state_change (PangoRenderer *renderer, + PangoRenderPart part) +{ + LineState *state = renderer->priv->line_state; + if (!state) + return; + + if (part == PANGO_RENDER_PART_UNDERLINE && + state->underline != PANGO_UNDERLINE_NONE) + { + PangoRectangle *rect = &state->underline_rect; + + rect->width = state->logical_rect_end - rect->x; + draw_underline (renderer, state); + state->underline = renderer->underline; + rect->x = state->logical_rect_end; + } + + if (part == PANGO_RENDER_PART_STRIKETHROUGH && + state->strikethrough) + { + PangoRectangle *rect = &state->strikethrough_rect; + + rect->width = state->logical_rect_end - rect->x; + draw_underline (renderer, state); + state->underline = renderer->underline; + rect->x = state->logical_rect_end; + } +} + +static void +add_underline (PangoRenderer *renderer, + LineState *state, + PangoFontMetrics *metrics, /* NULL if no underline */ + int base_x, + int base_y, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect) +{ + if (renderer->underline == PANGO_UNDERLINE_NONE) + { + draw_underline (renderer, state); + } + else + { + PangoRectangle *current_rect = &state->underline_rect; + PangoRectangle new_rect; + + int underline_thickness = pango_font_metrics_get_underline_thickness (metrics); + int underline_position = pango_font_metrics_get_underline_position (metrics); + + new_rect.x = base_x + ink_rect->x; + new_rect.width = ink_rect->width; + new_rect.height = underline_thickness; + + switch (renderer->underline) + { + case PANGO_UNDERLINE_NONE: + g_assert_not_reached (); + break; + case PANGO_UNDERLINE_SINGLE: + case PANGO_UNDERLINE_DOUBLE: + case PANGO_UNDERLINE_ERROR: + new_rect.y = base_y - underline_position; + break; + case PANGO_UNDERLINE_LOW: + new_rect.y = base_y + ink_rect->y + ink_rect->height + underline_thickness; + break; + } + + if (renderer->underline == state->underline && + new_rect.y == current_rect->y && + new_rect.height == current_rect->height) + { + current_rect->y = new_rect.y; + current_rect->width = new_rect.x + new_rect.width - current_rect->x; + current_rect->height = new_rect.height; + } + else + { + draw_underline (renderer, state); + + *current_rect = new_rect; + state->underline = renderer->underline; + } + } +} + +static void +add_strikethrough (PangoRenderer *renderer, + LineState *state, + PangoFontMetrics *metrics, /* NULL if no strikethrough */ + int base_x, + int base_y, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect) +{ + if (!renderer->strikethrough) + { + draw_strikethrough (renderer, state); + } + else + { + PangoRectangle *current_rect = &state->strikethrough_rect; + PangoRectangle new_rect; + + int strikethrough_thickness = pango_font_metrics_get_strikethrough_thickness (metrics); + int strikethrough_position = pango_font_metrics_get_strikethrough_position (metrics); + + new_rect.x = base_x + ink_rect->x; + new_rect.width = ink_rect->width; + new_rect.y = base_y - strikethrough_position; + new_rect.height = strikethrough_thickness; + + if (state->strikethrough && + new_rect.y == current_rect->y && + new_rect.height == current_rect->height) + { + current_rect->y = new_rect.y; + current_rect->width = new_rect.x + new_rect.width - current_rect->x; + current_rect->height = new_rect.height; + } + else + { + draw_strikethrough (renderer, state); + + *current_rect = new_rect; + state->strikethrough = TRUE; + } + } +} + +static void +get_item_properties (PangoItem *item, + gint *rise, + gboolean *shape_set, + PangoRectangle *ink_rect, + PangoRectangle *logical_rect) +{ + GSList *l; + + if (rise) + *rise = 0; + + if (shape_set) + *shape_set = FALSE; + + for (l = item->analysis.extra_attrs; l; l = l->next) + { + PangoAttribute *attr = l->data; + + switch (attr->klass->type) + { + case PANGO_ATTR_SHAPE: + if (shape_set) + *shape_set = TRUE; + if (logical_rect) + *logical_rect = ((PangoAttrShape *)attr)->logical_rect; + if (ink_rect) + *ink_rect = ((PangoAttrShape *)attr)->ink_rect; + break; + + case PANGO_ATTR_RISE: + if (rise) + *rise = ((PangoAttrInt *)attr)->value; + break; + + default: + break; + } + } +} + +/** + * pango_renderer_draw_layout_line: + * @renderer: a #PangoRenderer + * @line: a #PangoLayoutLine + * @x: x position of left edge of baseline, in user space coordinates + * in Pango units. + * @y: x position of left edge of baseline, in user space coordinates + * in Pango units. + * + * Draws @line with the specified #PangoRenderer. + * + * Since: 1.8 + **/ +void +pango_renderer_draw_layout_line (PangoRenderer *renderer, + PangoLayoutLine *line, + int x, + int y) +{ + int x_off = 0; + LineState state; + GSList *l; + gboolean got_overall = FALSE; + PangoRectangle overall_rect; + + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + /* We only change the matrix if the renderer isn't already + * active. + */ + if (!renderer->active_count) + { + PangoContext *context = pango_layout_get_context (line->layout); + pango_renderer_set_matrix (renderer, + pango_context_get_matrix (context)); + } + + pango_renderer_activate (renderer); + + renderer->priv->line_state = &state; + + state.underline = PANGO_UNDERLINE_NONE; + state.strikethrough = FALSE; + + for (l = line->runs; l; l = l->next) + { + PangoFontMetrics *metrics; + gint rise; + PangoLayoutRun *run = l->data; + PangoRectangle logical_rect; + PangoRectangle ink_rect; + gboolean shape_set; + + pango_renderer_prepare_run (renderer, run); + + get_item_properties (run->item, + &rise, + &shape_set, &ink_rect, &logical_rect); + + if (!shape_set) + { + if (renderer->underline != PANGO_UNDERLINE_NONE || + renderer->strikethrough) + pango_glyph_string_extents (run->glyphs, run->item->analysis.font, + &ink_rect, &logical_rect); + else + pango_glyph_string_extents (run->glyphs, run->item->analysis.font, + NULL, &logical_rect); + } + + state.logical_rect_end = x_off + logical_rect.x + logical_rect.width; + + if (renderer->priv->color_set[PANGO_RENDER_PART_BACKGROUND]) + { + if (!got_overall) + { + pango_layout_line_get_extents (line, NULL, &overall_rect); + got_overall = TRUE; + } + + pango_renderer_draw_rectangle (renderer, + PANGO_RENDER_PART_BACKGROUND, + x + x_off + logical_rect.x, + y - rise + overall_rect.y, + logical_rect.width, + overall_rect.height); + } + + if (!shape_set) + { + pango_renderer_draw_glyphs (renderer, + run->item->analysis.font, run->glyphs, + x + x_off, y - rise); + } +#if 0 + else + { + pango_renderer_draw_shaped (renderer, + x + x_off, y - rise); + } +#endif + + if (renderer->underline != PANGO_UNDERLINE_NONE || + renderer->strikethrough) + { + metrics = pango_font_get_metrics (run->item->analysis.font, + run->item->analysis.language); + + if (renderer->underline != PANGO_UNDERLINE_NONE) + add_underline (renderer, &state,metrics, + x + x_off, y - rise, + &ink_rect, &logical_rect); + + if (renderer->strikethrough) + add_strikethrough (renderer, &state, metrics, + x + x_off, y - rise, + &ink_rect, &logical_rect); + + pango_font_metrics_unref (metrics); + } + + x_off += logical_rect.width; + } + + /* Finish off any remaining underlines + */ + draw_underline (renderer, &state); + draw_strikethrough (renderer, &state); + + pango_renderer_deactivate (renderer); + +} + +/** + * pango_renderer_draw_glyphs: + * @renderer: a #PangoRenderer + * @font: a #PangoFont + * @glyphs: a #PangoGlyphString + * @x: x position of left edge of baseline, in user space coordinates + * in Pango units. + * @y: x position of left edge of baseline, in user space coordinates + * in Pango units. + * + * Draws the glyphs in @glyphs with the specified #PangoRenderer. + * + * Since: 1.8 + **/ +void +pango_renderer_draw_glyphs (PangoRenderer *renderer, + PangoFont *font, + PangoGlyphString *glyphs, + int x, + int y) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + PANGO_RENDERER_GET_CLASS (renderer)->draw_glyphs (renderer, font, glyphs, x, y); +} + +static void +pango_renderer_default_draw_glyphs (PangoRenderer *renderer, + PangoFont *font, + PangoGlyphString *glyphs, + int x, + int y) +{ + int i; + int x_position = 0; + + for (i = 0; i < glyphs->num_glyphs; i++) + { + PangoGlyphInfo *gi = &glyphs->glyphs[i]; + Point p; + + to_device (renderer->matrix, + x + x_position + gi->geometry.x_offset, + y + gi->geometry.y_offset, + &p); + + pango_renderer_draw_glyph (renderer, font, gi->glyph, p.x, p.y); + + x_position += gi->geometry.width; + } +} + +/** + * pango_renderer_draw_rectangle: + * @renderer: a #PangoRenderer + * @part: type of object this rectangle is part of + * @x: x position at which to draw rectangle, in user space coordinates in Pango units + * @y: y position at which to draw rectangle, in user space coordinates in Pango units + * @width: width of rectangle in PangoUnits in user space coordinates + * @height: height of rectangle in PangoUnits in user space coordinates + * + * Draws an axis-aligned rectangle in user space coordinates with the + * specified #PangoRenderer. + * + * Since: 1.8 + **/ +void +pango_renderer_draw_rectangle (PangoRenderer *renderer, + PangoRenderPart part, + int x, + int y, + int width, + int height) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + g_return_if_fail (IS_VALID_PART (part)); + + PANGO_RENDERER_GET_CLASS (renderer)->draw_rectangle (renderer, part, x, y, width, height); +} + +static int +compare_points (const void *a, + const void *b) +{ + const Point *pa = a; + const Point *pb = b; + + if (pa->y < pb->y) + return -1; + else if (pa->y > pb->y) + return 1; + else if (pa->x < pb->x) + return -1; + else if (pa->x > pb->x) + return 1; + else + return 0; +} + +static void +draw_rectangle (PangoRenderer *renderer, + PangoMatrix *matrix, + PangoRenderPart part, + int x, + int y, + int width, + int height) +{ + Point points[4]; + + /* Convert the points to device coordinates, and sort + * in ascending Y order. (Ordering by X for ties) + */ + to_device (matrix, x, y, &points[0]); + to_device (matrix, x + width, y, &points[1]); + to_device (matrix, x, y + height, &points[2]); + to_device (matrix, x + width, y + height, &points[3]); + + qsort (points, 4, sizeof (Point), compare_points); + + /* There are essentially three cases. (There is a fourth + * case where trapezoid B is degenerate and we just have + * two triangles, but we don't need to handle it separately.) + * + * 1 2 3 + * + * ______ /\ /\ + * / / /A \ /A \ + * / B / /____\ /____\ + * /_____/ / B / \ B \ + * /_____/ \_____\ + * \ C / \ C / + * \ / \ / + * \/ \/ + */ + if (points[0].y == points[1].y) + { + /* Case 1 (pure shear) */ + pango_renderer_draw_trapezoid (renderer, part, /* B */ + points[0].y, points[0].x, points[1].x, + points[2].y, points[2].x, points[3].x); + } + else if (points[1].x < points[2].x) + { + /* Case 2 */ + double tmp_width = ((points[2].x - points[0].x) * (points[1].y - points[0].y)) / (points[2].y - points[0].y); + double base_width = tmp_width + points[0].x - points[1].x; + + pango_renderer_draw_trapezoid (renderer, part, /* A */ + points[0].y, points[0].x, points[0].x, + points[1].y, points[1].x, points[1].x + base_width); + pango_renderer_draw_trapezoid (renderer, part, /* B */ + points[1].y, points[1].x, points[1].x + base_width, + points[2].y, points[2].x - base_width, points[2].x); + pango_renderer_draw_trapezoid (renderer, part, /* C */ + points[2].y, points[2].x - base_width, points[2].x, + points[3].y, points[3].x, points[3].x); + } + else + { + /* case 3 */ + double tmp_width = ((points[0].x - points[2].x) * (points[1].y - points[0].y)) / (points[2].y - points[0].y); + double base_width = tmp_width + points[1].x - points[0].x; + + pango_renderer_draw_trapezoid (renderer, part, /* A */ + points[0].y, points[0].x, points[0].x, + points[1].y, points[1].x - base_width, points[1].x); + pango_renderer_draw_trapezoid (renderer, part, /* B */ + points[1].y, points[1].x - base_width, points[1].x, + points[2].y, points[2].x, points[2].x + base_width); + pango_renderer_draw_trapezoid (renderer, part, /* C */ + points[2].y, points[2].x, points[2].x + base_width, + points[3].y, points[3].x, points[3].x); + } +} + +static void +pango_renderer_default_draw_rectangle (PangoRenderer *renderer, + PangoRenderPart part, + int x, + int y, + int width, + int height) +{ + draw_rectangle (renderer, renderer->matrix, part, x, y, width, height); +} + +/** + * pango_renderer_draw_error_underline: + * @renderer: a #PangoRenderer + * @x: X coordinate of underline, in Pango units in user coordinate system + * @y: Y coordinate of underline, in Pango units in user coordinate system + * @width: width of underline, in Pango units in user coordinate system + * @height: height of underline, in Pango units in user coordinate system + * + * Draw a squiggly line that approximately covers the given rectangle + * in the style of an underline used to indicate a spelling error. + * (The width of the underline is rounded to an integer number + * of up/down segments and the resulting rectangle is centered + * in the original rectangle) + * + * Since: 1.8 + **/ +void +pango_renderer_draw_error_underline (PangoRenderer *renderer, + int x, + int y, + int width, + int height) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + PANGO_RENDERER_GET_CLASS (renderer)->draw_error_underline (renderer, x, y, width, height); +} + +/* We are drawing an error underline that looks like one of: + * + * /\ /\ /\ /\ /\ - + * / \ / \ / \ / \ / \ | + * \ \ /\ \ / / \ \ /\ \ | + * \ \/B \ \/ C / \ \/B \ \ | height = HEIGHT_SQUARES * square + * \ A \ /\ A \ / \ A \ /\ A \ | + * \ \/ \ \/ \ \/ \ \ | + * \ / \ / \ / \ / | + * \/ \/ \/ \/ - + * + * |----| + * unit_width = (HEIGHT_SQUARES - 1) * square + * + * To do this conveniently, we work in a coordinate system where A,B,C + * are axis aligned rectangles. (If fonts were square, the diagrams + * would be clearer) + * + * (0,0) + * /\ /\ + * / \ / \ + * /\ /\ /\ / + * / \/ \/ \/ + * / \ /\ / + * Y axis \/ \/ + * \ /\ + * \/ \ + * \ X axis + * + * Note that the long side in this coordinate system is HEIGHT_SQUARES + 1 + * units long + * + * The diagrams above are shown with HEIGHT_SQUARES an integer, but + * that is actually incidental; the value 2.5 below seems better than + * either HEIGHT_SQUARES=3 (a little long and skinny) or + * HEIGHT_SQUARES=2 (a bit short and stubby) + */ + +#define HEIGHT_SQUARES 2.5 + +static void +get_total_matrix (PangoMatrix *total, + PangoMatrix *global, + int x, + int y, + int square) +{ + PangoMatrix local; + gdouble scale = 0.5 * square; + + /* The local matrix translates from the axis aligned coordinate system + * to the original user space coordinate system. + */ + local.xx = scale; + local.xy = - scale; + local.yx = scale; + local.yy = scale; + local.x0 = 0; + local.y0 = 0; + + *total = *global; + pango_matrix_concat (total, &local); + + total->x0 = (global->xx * x + global->xy * y) / PANGO_SCALE + global->x0; + total->y0 = (global->yx * x + global->yy * y) / PANGO_SCALE + global->y0; +} + +static void +pango_renderer_default_draw_error_underline (PangoRenderer *renderer, + int x, + int y, + int width, + int height) +{ + int square = height / HEIGHT_SQUARES; + int unit_width = (HEIGHT_SQUARES - 1) * square; + int width_units = (width + unit_width / 2) / unit_width; + static const PangoMatrix identity = PANGO_MATRIX_INIT; + const PangoMatrix *matrix; + + x += (width - width_units * unit_width) / 2; + width = width_units * unit_width; + + if (renderer->matrix) + matrix = renderer->matrix; + else + matrix = &identity; + + while (TRUE) + { + PangoMatrix total; + get_total_matrix (&total, renderer->matrix, x, y, square); + + draw_rectangle (renderer, &total, PANGO_RENDER_PART_UNDERLINE, /* A */ + 0, 0, + HEIGHT_SQUARES * 2 - 1, 1); + + if (width_units > 2) + { + draw_rectangle (renderer, &total, PANGO_RENDER_PART_UNDERLINE, /* B */ + HEIGHT_SQUARES * 2 - 2, - (HEIGHT_SQUARES * 2 - 3), + 1, HEIGHT_SQUARES * 2 - 3); + width_units -= 2; + x += unit_width * 2; + } + else if (width_units == 2) + { + draw_rectangle (renderer, &total, PANGO_RENDER_PART_UNDERLINE, /* C */ + HEIGHT_SQUARES * 2 - 2, - (HEIGHT_SQUARES * 2 - 2), + 1, HEIGHT_SQUARES * 2 - 2); + break; + } + else + break; + } +} + +/** + * pango_renderer_draw_trapezoid: + * @renderer: a #PangoRenderer + * @part: type of object this trapezoid is part of + * @y1: Y coordinate of top of trapezoid + * @x11: X coordinate of left end of top of trapezoid + * @x21: X coordinate of right end of top of trapezoid + * @y2: X coordinate of top of trapezoid + * @x12: X coordinate of left end of top of trapezoid + * @x22: Y coordinate of left end of top of trapezoid + * + * Draws a trapezoid with the parallel sides aligned with the X axis + * using the given #PangoRenderer; coordinates are in device space. + * + * Since: 1.8 + **/ +void +pango_renderer_draw_trapezoid (PangoRenderer *renderer, + PangoRenderPart part, + double y1, + double x11, + double x21, + double y2, + double x12, + double x22) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + PANGO_RENDERER_GET_CLASS (renderer)->draw_trapezoid (renderer, part, + y1, x11, x21, + y2, x12, x22); +} + +/** + * pango_renderer_draw_glyph: + * @renderer: a #PangoRenderer + * @font: a #PangoFont + * @glyph: the glyph index of a single glyph + * @x: X coordinate of left edge of baseline of glyph + * @y: Y coordinate of left edge of baseline of glyph + * + * Draws a single glyph with coordinates in device space. + * + * Since: 1.8 + **/ +void +pango_renderer_draw_glyph (PangoRenderer *renderer, + PangoFont *font, + PangoGlyph glyph, + double x, + double y) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + if (glyph == 0) /* glyph 0 never renders */ + return; + + PANGO_RENDERER_GET_CLASS (renderer)->draw_glyph (renderer, font, glyph, x, y); +} + +/** + * pango_renderer_activate: + * @renderer: a #PangoRenderer + * + * Does initial setup before rendering operations on @renderer. + * pango_renderer_deactivate() should be called when done drawing. + * Calls such as pango_renderer_draw_layout() automatically + * activate the layout before drawing on it. Calls to + * pango_renderer_activate() and pango_renderer_deactivate() can + * be nested and the renderer will only be initialized and + * deinitialized once. + * + * Since: 1.8 + **/ +void +pango_renderer_activate (PangoRenderer *renderer) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + renderer->active_count++; + if (renderer->active_count == 1) + { + if (PANGO_RENDERER_GET_CLASS (renderer)->begin) + PANGO_RENDERER_GET_CLASS (renderer)->begin (renderer); + } +} + +/** + * pango_renderer_deactivate: + * @renderer: a #PangoRenderer + * + * Cleans up after rendering operations on @renderer. See + * docs for pango_renderer_activate(). + * + * Since: 1.8 + **/ +void +pango_renderer_deactivate (PangoRenderer *renderer) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + g_return_if_fail (renderer->active_count > 0); + + if (renderer->active_count == 1) + { + if (PANGO_RENDERER_GET_CLASS (renderer)->end) + PANGO_RENDERER_GET_CLASS (renderer)->end (renderer); + } + renderer->active_count--; +} + +/** + * pango_renderer_set_color: + * @renderer: a #PangoRenderer + * @part: the part to change the color of + * @color: the new color or %NULL to unset the current color + * + * Sets the color for part of the rendering. + * + * Since: 1.8 + **/ +void +pango_renderer_set_color (PangoRenderer *renderer, + PangoRenderPart part, + PangoColor *color) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + g_return_if_fail (IS_VALID_PART (part)); + + pango_renderer_part_changed (renderer, part); + + if ((!color && !renderer->priv->color_set[part]) || + (color && renderer->priv->color_set[part] && + renderer->priv->color[part].red == color->red && + renderer->priv->color[part].green == color->green && + renderer->priv->color[part].blue == color->blue)) + return; + + if (color) + { + renderer->priv->color_set[part] = TRUE; + renderer->priv->color[part] = *color; + } + else + { + renderer->priv->color_set[part] = FALSE; + } + + if (PANGO_RENDERER_GET_CLASS (renderer)->color_set) + PANGO_RENDERER_GET_CLASS (renderer)->color_set (renderer, part, color); +} + +/** + * pango_renderer_get_color: + * @renderer: a #PangoRenderer + * @part: the part to get the color for + * + * Gets the current rendering color for the specified part. + * + * Return value: the color for the specified part, or %NULL + * if it hasn't been set and should be inherited from the + * environment. + * + * Since: 1.8 + **/ +PangoColor * +pango_renderer_get_color (PangoRenderer *renderer, + PangoRenderPart part) +{ + g_return_val_if_fail (PANGO_IS_RENDERER (renderer), NULL); + g_return_val_if_fail (IS_VALID_PART (part), NULL); + + if (renderer->priv->color_set[part]) + return &renderer->priv->color[part]; + else + return NULL; +} + +/** + * pango_renderer_part_changed: + * @renderer: a #PangoRenderer + * @part: the part for which rendering has changed. + * + * Informs Pango that the way that the renderering is done + * for @part has changed in a way that would prevent multiple + * pieces being joined together into one drawing call. For + * instance, if a subclass of #PangoRenderer was to add a stipple + * option for drawing underlines, it needs to call + * + * + * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE); + * + * + * When the stipple changes or underlines with different stipples + * might be joined together. Pango automatically calls this for + * changes to colors. (See pango_renderer_set_color()) + * + * Since: 1.8 + **/ +void +pango_renderer_part_changed (PangoRenderer *renderer, + PangoRenderPart part) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + g_return_if_fail (IS_VALID_PART (part)); + + handle_line_state_change (renderer, part); + + if (PANGO_RENDERER_GET_CLASS (renderer)->part_changed) + PANGO_RENDERER_GET_CLASS (renderer)->part_changed (renderer, part); +} + +/** + * pango_renderer_prepare_run: + * @renderer: a #PangoRenderer + * @run: a #PangoLayoutRun + * + * Set up the state of the PangoRenderer for rendering @run. + * + * Since: 1.8 + **/ +static void +pango_renderer_prepare_run (PangoRenderer *renderer, + PangoLayoutRun *run) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + PANGO_RENDERER_GET_CLASS (renderer)->prepare_run (renderer, run); +} + +static void +pango_renderer_default_prepare_run (PangoRenderer *renderer, + PangoLayoutRun *run) +{ + PangoColor *fg_color = NULL; + PangoColor *bg_color = NULL; + GSList *l; + + renderer->underline = PANGO_UNDERLINE_NONE; + renderer->strikethrough = FALSE; + + for (l = run->item->analysis.extra_attrs; l; l = l->next) + { + PangoAttribute *attr = l->data; + + switch (attr->klass->type) + { + case PANGO_ATTR_UNDERLINE: + renderer->underline = ((PangoAttrInt *)attr)->value; + break; + + case PANGO_ATTR_STRIKETHROUGH: + renderer->strikethrough = ((PangoAttrInt *)attr)->value; + break; + + case PANGO_ATTR_FOREGROUND: + fg_color = &((PangoAttrColor *)attr)->color; + break; + + case PANGO_ATTR_BACKGROUND: + bg_color = &((PangoAttrColor *)attr)->color; + break; + + default: + break; + } + } + + pango_renderer_set_color (renderer, PANGO_RENDER_PART_FOREGROUND, fg_color); + pango_renderer_set_color (renderer, PANGO_RENDER_PART_UNDERLINE, fg_color); + pango_renderer_set_color (renderer, PANGO_RENDER_PART_STRIKETHROUGH, fg_color); + pango_renderer_set_color (renderer, PANGO_RENDER_PART_BACKGROUND, bg_color); +} + +/** + * pango_renderer_set_matrix: + * @renderer: a #PangoRenderer + * @matrix: a #PangoMatrix, or %NULL to unset any existing matrix. + * (No matrix set is the same as setting the identity matrix.) + * + * Sets the transformation matrix that will be applied when rendering. + * + * Since: 1.8 + **/ +void +pango_renderer_set_matrix (PangoRenderer *renderer, + const PangoMatrix *matrix) +{ + g_return_if_fail (PANGO_IS_RENDERER (renderer)); + + if (renderer->matrix) + pango_matrix_free (renderer->matrix); + if (matrix) + renderer->matrix = pango_matrix_copy (matrix); + else + renderer->matrix = NULL; + +} + +/** + * pango_renderer_get_matrix: + * @renderer: a #PangoRenderer + * + * Gets the transformation matrix that will be applied when + * rendering. See pango_renderer_set_matrix(). + * + * Returns: the matrix, or %NULL if no matrix has been set + * (which is the same as the identity matrix). The returned + * matrix is owned by Pango and must not be modified or + * freed. + * + * Since: 1.8 + **/ +G_CONST_RETURN PangoMatrix * +pango_renderer_get_matrix (PangoRenderer *renderer) +{ + g_return_val_if_fail (PANGO_IS_RENDERER (renderer), NULL); + + return renderer->matrix; +} -- cgit v1.2.1