diff --git a/test/.gitignore b/test/.gitignore index 374bbf55d..a66739ec2 100644 --- a/test/.gitignore +++ b/test/.gitignore @@ -222,6 +222,7 @@ unbounded-operator user-data user-font user-font-proxy +user-font-rescale xlib-expose-event xlib-surface xlib-surface-source diff --git a/test/Makefile.am b/test/Makefile.am index 2a273100e..57aa781bf 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -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 \ diff --git a/test/user-font-rescale-ref.png b/test/user-font-rescale-ref.png new file mode 100644 index 000000000..39bce60e8 Binary files /dev/null and b/test/user-font-rescale-ref.png differ diff --git a/test/user-font-rescale.c b/test/user-font-rescale.c new file mode 100644 index 000000000..a65d7e5aa --- /dev/null +++ b/test/user-font-rescale.c @@ -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 + * Kristian Høgsberg + * Behdad Esfahbod + */ + +#include +#include +#define __USE_ISOC99 +#include + +#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; iglyph_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 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