fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2026-01-11 01:40:17 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

[test] Add a test case for drawing glyphs with different metrics.

Browse source 
The ability to draw glyphs with different metrics is useful when doing
font substitution with fixed layout like in pdf and I eventually plan on
adding code to poppler to do something similar.
This commit is contained in:
Jeff Muizelaar 2008-09-16 01:45:10 +01:00 • committed by Chris Wilson
parent 9c207b2454
commit e53fe3ec24
4 changed files with 332 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
test/.gitignore vendored
View file

@ -222,6 +222,7 @@ unbounded-operator
user-data
user-font
user-font-proxy
user-font-rescale
xlib-expose-event
xlib-surface
xlib-surface-source

2
test/Makefile.am
View file

@ -174,6 +174,7 @@ unbounded-operator$(EXEEXT) \
user-data$(EXEEXT) \
user-font$(EXEEXT) \
user-font-proxy$(EXEEXT) \
user-font-rescale$(EXEEXT) \
zero-alpha$(EXEEXT)
# XXX: Here are some existing tests that are currently disabled for
@ -740,6 +741,7 @@ REFERENCE_IMAGES = \
user-font-proxy-pdf-ref.png \
user-font-proxy-ps-ref.png \
user-font-proxy-svg-ref.png \
user-font-rescale-ref.png \
unbounded-operator-quartz-ref.png \
unbounded-operator-quartz-rgb24-ref.png \
xlib-expose-event-ref.png \

BIN
test/user-font-rescale-ref.png Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 15 KiB

329
test/user-font-rescale.c Normal file
View file

@ -0,0 +1,329 @@
/*
* Copyright © 2008 Jeff Muizelaar
*
* Permission to use, copy, modify, distribute, and sell this software
* and its documentation for any purpose is hereby granted without
* fee, provided that the above copyright notice appear in all copies
* and that both that copyright notice and this permission notice
* appear in supporting documentation, and that the name of
* Jeff Muizelaar not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. Jeff Muizelaar makes no representations about the
* suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* JEFF MUIZELAAR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL JEFF MUIZELAAR BE LIABLE FOR ANY SPECIAL,
* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Contributor(s):
* Jeff Muizelaar <jeff@infidigm.net>
* Kristian Høgsberg <krh@redhat.com>
* Behdad Esfahbod <behdad@behdad.org>
*/
#include <stdlib.h>
#include <stdio.h>
#define __USE_ISOC99
#include <math.h>
#include "cairo-test.h"
#define BORDER 10
#define TEXT_SIZE 32
#define WIDTH (TEXT_SIZE * 13.75 + 2*BORDER)
#define HEIGHT ((TEXT_SIZE + 2*BORDER)*3 + BORDER)
#define TEXT "test of rescaled glyphs";
static cairo_test_draw_function_t draw;
static const cairo_test_t test = {
"user-font-rescale",
"Tests drawing text with user defined widths",
WIDTH, HEIGHT,
draw
};
static const cairo_user_data_key_t rescale_font_closure_key;
struct rescaled_font {
cairo_font_face_t *substitute_font;
cairo_scaled_font_t *measuring_font;
unsigned long glyph_count;
unsigned long start;
double *desired_width;
double *rescale_factor;
};
static cairo_status_t
test_scaled_font_render_glyph (cairo_scaled_font_t *scaled_font,
unsigned long glyph,
cairo_t *cr,
cairo_text_extents_t *metrics)
{
cairo_font_face_t *user_font = cairo_scaled_font_get_font_face (scaled_font);
struct rescaled_font *r = cairo_font_face_get_user_data (user_font, &rescale_font_closure_key);
cairo_glyph_t cairo_glyph;
cairo_glyph.index = glyph;
cairo_glyph.x = 0;
cairo_glyph.y = 0;
cairo_set_font_face (cr, r->substitute_font);
if (glyph - r->start < r->glyph_count) {
cairo_matrix_t matrix;
if (isnan (r->rescale_factor[glyph - r->start])) {
double desired_width;
double actual_width;
cairo_text_extents_t extents;
/* measure the glyph and compute the necessary rescaling factor */
cairo_scaled_font_glyph_extents (r->measuring_font, &cairo_glyph, 1, &extents);
desired_width = r->desired_width[glyph - r->start];
actual_width = extents.x_advance;
r->rescale_factor[glyph - r->start] = desired_width / actual_width;
}
/* scale the font so that the glyph width matches the desired width */
cairo_get_font_matrix (cr, &matrix);
cairo_matrix_scale (&matrix, r->rescale_factor[glyph - r->start], 1.);
cairo_set_font_matrix (cr, &matrix);
}
cairo_show_glyphs (cr, &cairo_glyph, 1);
cairo_glyph_extents (cr, &cairo_glyph, 1, metrics);
return CAIRO_STATUS_SUCCESS;
}
/* UNICHAR_TO_UTF8 from Behdad
* http://mces.blogspot.com/2004/07/static-unicode-to-utf-8-converter.html */
#define UNICHAR_TO_UTF8(Char) \
(const char []) \
{ \
/* first octet */ \
(Char) < 0x00000080 ? (Char) : \
(Char) < 0x00000800 ? ((Char) >> 6) | 0xC0 : \
(Char) < 0x00010000 ? ((Char) >> 12) | 0xE0 : \
(Char) < 0x00200000 ? ((Char) >> 18) | 0xF0 : \
(Char) < 0x04000000 ? ((Char) >> 24) | 0xF8 : \
((Char) >> 30) | 0xFC, \
/* second octet */ \
(Char) < 0x00000080 ? 0 /* null-terminator */ : \
(Char) < 0x00000800 ? ((Char) & 0x3F) | 0x80 : \
(Char) < 0x00010000 ? (((Char) >> 6) & 0x3F) | 0x80 : \
(Char) < 0x00200000 ? (((Char) >> 12) & 0x3F) | 0x80 : \
(Char) < 0x04000000 ? (((Char) >> 18) & 0x3F) | 0x80 : \
(((Char) >> 24) & 0x3F) | 0x80, \
/* third octet */ \
(Char) < 0x00000800 ? 0 /* null-terminator */ : \
(Char) < 0x00010000 ? ((Char) & 0x3F) | 0x80 : \
(Char) < 0x00200000 ? (((Char) >> 6) & 0x3F) | 0x80 : \
(Char) < 0x04000000 ? (((Char) >> 12) & 0x3F) | 0x80 : \
(((Char) >> 18) & 0x3F) | 0x80, \
/* fourth octet */ \
(Char) < 0x00010000 ? 0 /* null-terminator */ : \
(Char) < 0x00200000 ? ((Char) & 0x3F) | 0x80 : \
(Char) < 0x04000000 ? (((Char) >> 6) & 0x3F) | 0x80 : \
(((Char) >> 12) & 0x3F) | 0x80, \
/* fifth octet */ \
(Char) < 0x00200000 ? 0 /* null-terminator */ : \
(Char) < 0x04000000 ? ((Char) & 0x3F) | 0x80 : \
(((Char) >> 6) & 0x3F) | 0x80, \
/* sixth octet */ \
(Char) < 0x04000000 ? 0 /* null-terminator */ : \
((Char) & 0x3F) | 0x80, \
0 /* null-terminator */ \
}
static cairo_status_t
test_scaled_font_unicode_to_glyph (cairo_scaled_font_t *scaled_font,
unsigned long unicode,
unsigned long *glyph_index) {
cairo_font_face_t *user_font = cairo_scaled_font_get_font_face (scaled_font);
struct rescaled_font *r = cairo_font_face_get_user_data (user_font, &rescale_font_closure_key);
int num_glyphs;
cairo_glyph_t *glyphs = NULL;
cairo_status_t status = cairo_scaled_font_text_to_glyphs (r->measuring_font, 0, 0,
UNICHAR_TO_UTF8(unicode), -1,
&glyphs, &num_glyphs,
NULL, NULL,
NULL);
if (status)
return status;
*glyph_index = glyphs[0].index;
cairo_glyph_free (glyphs);
return CAIRO_STATUS_SUCCESS;
}
static void rescale_font_closure_destroy (void *data) {
struct rescaled_font *r = data;
cairo_scaled_font_destroy (r->measuring_font);
free (r->desired_width);
free (r->rescale_factor);
free (r);
}
static cairo_font_face_t *
create_rescaled_font (cairo_font_face_t *substitute_font, int glyph_start, int glyph_count, double *desired_width)
{
cairo_font_face_t *user_font_face = NULL;
struct rescaled_font *r = xmalloc (sizeof(struct rescaled_font));
cairo_font_options_t *options = cairo_font_options_create ();
cairo_matrix_t m;
unsigned long i;
user_font_face = cairo_user_font_face_create ();
cairo_user_font_face_set_render_glyph_func (user_font_face, test_scaled_font_render_glyph);
cairo_user_font_face_set_unicode_to_glyph_func (user_font_face, test_scaled_font_unicode_to_glyph);
r->substitute_font = substitute_font;
/* we don't want any hinting when doing the measuring */
cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF);
cairo_matrix_init_identity (&m);
r->measuring_font = cairo_scaled_font_create (r->substitute_font, &m, &m, options);
r->start = glyph_start;
r->glyph_count = glyph_count;
r->desired_width = xcalloc (sizeof(double), r->glyph_count);
r->rescale_factor = xcalloc (sizeof(double), r->glyph_count);
for (i=0; i<r->glyph_count; i++) {
r->desired_width[i] = desired_width[i];
/* use NAN to specify unset */
r->rescale_factor[i] = NAN;
}
cairo_font_options_destroy (options);
cairo_font_face_set_user_data (user_font_face, &rescale_font_closure_key,
r, rescale_font_closure_destroy);
return user_font_face;
}
static cairo_font_face_t *
get_user_font_face (cairo_font_face_t *substitute_font, const char *text, cairo_font_face_t *old)
{
cairo_font_options_t *options = cairo_font_options_create ();
cairo_matrix_t m;
cairo_scaled_font_t *measure;
int i;
double *widths;
int count;
int num_glyphs;
unsigned long min_index, max_index;
cairo_font_face_t *ret;
cairo_glyph_t *glyphs = NULL;
/* we don't want any hinting when doing the measuring */
cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF);
cairo_matrix_init_identity (&m);
measure = cairo_scaled_font_create (old, &m, &m, options);
cairo_scaled_font_text_to_glyphs (measure, 0, 0,
text, -1,
&glyphs, &num_glyphs,
NULL, NULL,
NULL);
/* find the glyph range the text covers */
max_index = glyphs[0].index;
min_index = glyphs[0].index;
for (i=0; i<num_glyphs; i++) {
if (glyphs[i].index < min_index)
min_index = glyphs[i].index;
if (glyphs[i].index > max_index)
max_index = glyphs[i].index;
}
count = max_index - min_index + 1;
widths = xmalloc (sizeof(double) * count);
/* measure all of the necessary glyphs individually */
for (i=0; i<num_glyphs; i++) {
cairo_text_extents_t extents;
cairo_scaled_font_glyph_extents (measure, &glyphs[i], 1, &extents);
widths[glyphs[i].index - min_index] = extents.x_advance;
}
cairo_glyph_free (glyphs);
cairo_font_options_destroy (options);
cairo_scaled_font_destroy (measure);
ret = create_rescaled_font (substitute_font, min_index, count, widths);
free (widths);
return ret;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_font_extents_t font_extents;
cairo_text_extents_t extents;
cairo_font_face_t *rescaled;
cairo_font_face_t *old;
const char text[] = TEXT;
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
cairo_font_extents (cr, &font_extents);
cairo_text_extents (cr, text, &extents);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_move_to (cr, BORDER, BORDER + font_extents.ascent);
cairo_show_text (cr, text);
/* same text in 'mono' with widths that match the 'sans' version */
old = cairo_get_font_face (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans Mono", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
rescaled = get_user_font_face (cairo_get_font_face (cr), text, old);
cairo_set_font_face (cr, rescaled);
cairo_set_source_rgba (cr, 0, 0, 1, 0.5);
cairo_move_to (cr, BORDER, BORDER + font_extents.height + 2*BORDER + font_extents.ascent);
cairo_show_text (cr, text);
cairo_font_face_destroy (rescaled);
/* mono text */
cairo_select_font_face (cr, "Bitstream Vera Sans Mono", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_source_rgba (cr, 0, 0, 1, 0.5);
cairo_move_to (cr, BORDER, BORDER + 2*font_extents.height + 4*BORDER + font_extents.ascent);
cairo_show_text (cr, text);
return CAIRO_TEST_SUCCESS;
}
int
main (void)
{
return cairo_test (&test);
}