From c62b503770325819f249885dfc9d4683a69c9efd Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sat, 1 Aug 2009 19:54:49 -0400 Subject: [PATCH] [HB] Add abstract font and face API Not used yet. --- src/Makefile.am | 3 + src/hb-blob.c | 6 +- src/hb-font-private.h | 108 +++++++++++++ src/hb-font.c | 331 ++++++++++++++++++++++++++++++++++++++ src/hb-font.h | 182 +++++++++++++++++++++ src/hb-refcount-private.h | 14 +- 6 files changed, 636 insertions(+), 8 deletions(-) create mode 100644 src/hb-font-private.h create mode 100644 src/hb-font.c create mode 100644 src/hb-font.h diff --git a/src/Makefile.am b/src/Makefile.am index 0114d4ab6..c33c01926 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -14,6 +14,8 @@ HBSOURCES = \ hb-blob.c \ hb-buffer.c \ hb-buffer-private.h \ + hb-font.c \ + hb-font-private.h \ hb-private.h \ hb-ot-layout.cc \ hb-ot-layout-common-private.h \ @@ -30,6 +32,7 @@ HBHEADERS = \ hb-blob.h \ hb-buffer.h \ hb-common.h \ + hb-font.h \ hb-ot-layout.h \ $(NULL) diff --git a/src/hb-blob.c b/src/hb-blob.c index 87cd7a420..8edb221ac 100644 --- a/src/hb-blob.c +++ b/src/hb-blob.c @@ -76,7 +76,7 @@ hb_blob_create (const char *data, return &_hb_blob_nil; } - HB_REFERENCE_COUNT_DO_CREATE (blob); + HB_OBJECT_DO_CREATE (blob); blob->data = data; blob->len = len; @@ -96,13 +96,13 @@ hb_blob_create (const char *data, hb_blob_t * hb_blob_reference (hb_blob_t *blob) { - HB_REFERENCE_COUNT_DO_REFERENCE (blob); + HB_OBJECT_DO_REFERENCE (blob); } void hb_blob_destroy (hb_blob_t *blob) { - HB_REFERENCE_COUNT_DO_DESTROY (blob); + HB_OBJECT_DO_DESTROY (blob); _hb_blob_destroy_user_data (blob); diff --git a/src/hb-font-private.h b/src/hb-font-private.h new file mode 100644 index 000000000..7c354060a --- /dev/null +++ b/src/hb-font-private.h @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2009 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Behdad Esfahbod + */ + +#ifndef HB_FONT_PRIVATE_H +#define HB_FONT_PRIVATE_H + +#include "hb-private.h" + +#include "hb-font.h" +#include "hb-refcount-private.h" + +HB_BEGIN_DECLS + +/* + * hb_font_callbacks_t + */ + +struct _hb_font_callbacks_t { + hb_reference_count_t ref_count; + + /* + hb_font_get_glyph_func_t glyph_func; + hb_font_get_contour_point_func_t contour_point_func; + hb_font_get_glyph_metrics_func_t glyph_metrics_func; + hb_font_get_kerning_func_t kerning_func; + */ +}; + + +/* + * hb_unicode_callbacks_t + */ + +struct _hb_unicode_callbacks_t { + hb_reference_count_t ref_count; + + /* + hb_unicode_get_general_category_func_t general_category_func); + hb_unicode_get_combining_class_func_t combining_class_func); + hb_unicode_get_mirroring_char_func_t mirroring_char_func); + hb_unicode_get_script_func_t script_func); + hb_unicode_get_eastasian_width_func_t eastasian_width_func); + */ +}; + + +/* + * hb_face_t + */ + +struct _hb_face_t { + hb_reference_count_t ref_count; + + hb_blob_t *blob; + unsigned int index; + + hb_get_table_func_t get_table; + hb_destroy_func_t destroy; + void *user_data; + + hb_font_callbacks_t *fcallbacks; + hb_unicode_callbacks_t *ucallbacks; +}; + + +/* + * hb_font_t + */ + +struct _hb_font_t { + hb_reference_count_t ref_count; + + hb_face_t *face; + + hb_16dot16_t x_scale; + hb_16dot16_t y_scale; + + unsigned int x_ppem; + unsigned int y_ppem; +}; + + +HB_END_DECLS + +#endif /* HB_FONT_PRIVATE_H */ diff --git a/src/hb-font.c b/src/hb-font.c new file mode 100644 index 000000000..0d0d6209b --- /dev/null +++ b/src/hb-font.c @@ -0,0 +1,331 @@ +/* + * Copyright (C) 2009 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Behdad Esfahbod + */ + +#include "hb-private.h" + +#include "hb-font-private.h" + +#include "hb-blob.h" + + +/* + * hb_font_callbacks_t + */ + +static hb_font_callbacks_t _hb_font_callbacks_nil = { + HB_REFERENCE_COUNT_INVALID /* ref_count */ + /* + hb_font_get_glyph_func_t glyph_func; + hb_font_get_contour_point_func_t contour_point_func; + hb_font_get_glyph_metrics_func_t glyph_metrics_func; + hb_font_get_kerning_func_t kerning_func; + */ +}; + +hb_font_callbacks_t * +hb_font_callbacks_create (void) +{ + hb_font_callbacks_t *fcallbacks; + + fcallbacks = calloc (1, sizeof (hb_font_callbacks_t)); + if (!fcallbacks) + return &_hb_font_callbacks_nil; + + HB_OBJECT_DO_CREATE (fcallbacks); + + return fcallbacks; +} + +hb_font_callbacks_t * +hb_font_callbacks_reference (hb_font_callbacks_t *fcallbacks) +{ + HB_OBJECT_DO_REFERENCE (fcallbacks); +} + +void +hb_font_callbacks_destroy (hb_font_callbacks_t *fcallbacks) +{ + HB_OBJECT_DO_DESTROY (fcallbacks); + + free (fcallbacks); +} + +hb_font_callbacks_t * +hb_font_callbacks_duplicate (hb_font_callbacks_t *other_fcallbacks) +{ + hb_font_callbacks_t *fcallbacks; + + fcallbacks = calloc (1, sizeof (hb_font_callbacks_t)); + if (!fcallbacks) + return &_hb_font_callbacks_nil; + + *fcallbacks = *other_fcallbacks; + HB_OBJECT_DO_CREATE (fcallbacks); + + return fcallbacks; +} + + + +/* + * hb_unicode_callbacks_t + */ + +static hb_unicode_callbacks_t _hb_unicode_callbacks_nil = { + HB_REFERENCE_COUNT_INVALID /* ref_count */ + /* + hb_unicode_get_general_category_func_t general_category_func); + hb_unicode_get_combining_class_func_t combining_class_func); + hb_unicode_get_mirroring_char_func_t mirroring_char_func); + hb_unicode_get_script_func_t script_func); + hb_unicode_get_eastasian_width_func_t eastasian_width_func); + */ +}; + +hb_unicode_callbacks_t * +hb_unicode_callbacks_create (void) +{ + hb_unicode_callbacks_t *ucallbacks; + + ucallbacks = calloc (1, sizeof (hb_unicode_callbacks_t)); + if (!ucallbacks) + return &_hb_unicode_callbacks_nil; + + HB_OBJECT_DO_CREATE (ucallbacks); + + return ucallbacks; +} + +hb_unicode_callbacks_t * +hb_unicode_callbacks_reference (hb_unicode_callbacks_t *ucallbacks) +{ + HB_OBJECT_DO_REFERENCE (ucallbacks); +} + +void +hb_unicode_callbacks_destroy (hb_unicode_callbacks_t *ucallbacks) +{ + HB_OBJECT_DO_DESTROY (ucallbacks); + + free (ucallbacks); +} + +hb_unicode_callbacks_t * +hb_unicode_callbacks_duplicate (hb_unicode_callbacks_t *other_ucallbacks) +{ + hb_unicode_callbacks_t *ucallbacks; + + ucallbacks = calloc (1, sizeof (hb_unicode_callbacks_t)); + if (!ucallbacks) + return &_hb_unicode_callbacks_nil; + + *ucallbacks = *other_ucallbacks; + HB_OBJECT_DO_CREATE (ucallbacks); + + return ucallbacks; +} + + + +/* + * hb_face_t + */ + +static hb_face_t _hb_face_nil = { + HB_REFERENCE_COUNT_INVALID, /* ref_count */ + + NULL, /* blob */ + 0, /* index */ + + NULL, /* get_table */ + NULL, /* destroy */ + NULL, /* user_data */ + + NULL, /* fcallbacks */ + NULL /* ucallbacks */ +}; + +hb_face_t * +hb_face_create_for_data (hb_blob_t *blob, + unsigned int index) +{ + hb_face_t *face; + + face = calloc (1, sizeof (hb_face_t)); + if (!face) + return &_hb_face_nil; + + HB_OBJECT_DO_CREATE (face); + + face->blob = hb_blob_reference (blob); + face->index = index; + + return face; +} + +hb_face_t * +hb_face_create_for_tables (hb_get_table_func_t get_table, + hb_destroy_func_t destroy, + void *user_data) +{ + hb_face_t *face; + + face = calloc (1, sizeof (hb_face_t)); + if (!face) { + if (destroy) + destroy (user_data); + return &_hb_face_nil; + } + + HB_OBJECT_DO_CREATE (face); + + face->get_table = get_table; + face->destroy = destroy; + face->user_data = user_data; + + return face; +} + +hb_face_t * +hb_face_reference (hb_face_t *face) +{ + HB_OBJECT_DO_REFERENCE (face); +} + +void +hb_face_destroy (hb_face_t *face) +{ + HB_OBJECT_DO_DESTROY (face); + + hb_blob_destroy (face->blob); + + if (face->destroy) + face->destroy (face->user_data); + + hb_font_callbacks_destroy (face->fcallbacks); + hb_unicode_callbacks_destroy (face->ucallbacks); + + free (face); +} + +void +hb_face_set_font_callbacks (hb_face_t *face, + hb_font_callbacks_t *fcallbacks) +{ + if (HB_OBJECT_IS_INERT (face)) + return; + + hb_font_callbacks_reference (fcallbacks); + hb_font_callbacks_destroy (face->fcallbacks); + face->fcallbacks = fcallbacks; +} + +void +hb_face_set_unicode_callbacks (hb_face_t *face, + hb_unicode_callbacks_t *ucallbacks) +{ + if (HB_OBJECT_IS_INERT (face)) + return; + + hb_unicode_callbacks_reference (ucallbacks); + hb_unicode_callbacks_destroy (face->ucallbacks); + face->ucallbacks = ucallbacks; +} + + + +/* + * hb_font_t + */ + +static hb_font_t _hb_font_nil = { + HB_REFERENCE_COUNT_INVALID, /* ref_count */ + + NULL, /* face */ + + 0, /* x_scale */ + 0, /* y_scale */ + + 0, /* x_ppem */ + 0 /* y_ppem */ +}; + +hb_font_t * +hb_font_create (hb_face_t *face) +{ + hb_font_t *font; + + font = calloc (1, sizeof (hb_font_t)); + if (!font) + return &_hb_font_nil; + + HB_OBJECT_DO_CREATE (font); + + font->face = hb_face_reference (face); + + return font; +} + +hb_font_t * +hb_font_reference (hb_font_t *font) +{ + HB_OBJECT_DO_REFERENCE (font); +} + +void +hb_font_destroy (hb_font_t *font) +{ + HB_OBJECT_DO_DESTROY (font); + + hb_face_destroy (font->face); + + free (font); +} + +void +hb_font_set_scale (hb_font_t *font, + hb_16dot16_t x_scale, + hb_16dot16_t y_scale) +{ + if (HB_OBJECT_IS_INERT (font)) + return; + + font->x_scale = x_scale; + font->y_scale = y_scale; +} + +void +hb_font_set_ppem (hb_font_t *font, + unsigned int x_ppem, + unsigned int y_ppem) +{ + if (HB_OBJECT_IS_INERT (font)) + return; + + font->x_ppem = x_ppem; + font->y_ppem = y_ppem; +} + diff --git a/src/hb-font.h b/src/hb-font.h new file mode 100644 index 000000000..d28714578 --- /dev/null +++ b/src/hb-font.h @@ -0,0 +1,182 @@ +/* + * Copyright (C) 2009 Red Hat, Inc. + * + * This is part of HarfBuzz, an OpenType Layout engine library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Red Hat Author(s): Behdad Esfahbod + */ + +#ifndef HB_FONT_H +#define HB_FONT_H + +#include "hb-common.h" + +HB_BEGIN_DECLS + +/* + * hb_font_callbacks_t + */ + +hb_font_callbacks_t * +hb_font_callbacks_create (void); + +hb_font_callbacks_t * +hb_font_callbacks_reference (hb_font_callbacks_t *fcallbacks); + +void +hb_font_callbacks_destroy (hb_font_callbacks_t *fcallbacks); + +hb_font_callbacks_t * +hb_font_callbacks_duplicate (hb_font_callbacks_t *fcallbacks); + +/* + +void +hb_font_callbacks_set_glyph_func (hb_font_callbacks_t *fcallbacks, + hb_font_get_glyph_func_t glyph_func); + +void +hb_font_callbacks_set_contour_point_func (hb_font_callbacks_t *fcallbacks, + hb_font_get_contour_point_func_t contour_point_func); + +void +hb_font_callbacks_set_glyph_metrics_func (hb_font_callbacks_t *fcallbacks, + hb_font_get_glyph_metrics_func_t glyph_metrics_func); + +void +hb_font_callbacks_set_kerning_func (hb_font_callbacks_t *fcallbacks, + hb_font_get_kerning_func_t kerning_func); + +*/ + + +/* + * hb_unicode_callbacks_t + */ + +hb_unicode_callbacks_t * +hb_unicode_callbacks_create (void); + +hb_unicode_callbacks_t * +hb_unicode_callbacks_reference (hb_unicode_callbacks_t *ucallbacks); + +void +hb_unicode_callbacks_destroy (hb_unicode_callbacks_t *ucallbacks); + +hb_unicode_callbacks_t * +hb_unicode_callbacks_duplicate (hb_unicode_callbacks_t *ucallbacks); + +/* + +void +hb_unicode_callbacks_set_general_category_func (hb_unicode_callbacks_t *ucallbacks, + hb_unicode_get_general_category_func_t general_category_func); + +void +hb_unicode_callbacks_set_combining_class_func (hb_unicode_callbacks_t *ucallbacks, + hb_unicode_get_combining_class_func_t combining_class_func); + +void +hb_unicode_callbacks_set_mirroring_char_func (hb_unicode_callbacks_t *ucallbacks, + hb_unicode_get_mirroring_char_func_t mirroring_char_func); + +void +hb_unicode_callbacks_set_script_func (hb_unicode_callbacks_t *ucallbacks, + hb_unicode_get_script_func_t script_func); + +void +hb_unicode_callbacks_set_eastasian_width_func (hb_unicode_callbacks_t *ucallbacks, + hb_unicode_get_eastasian_width_func_t eastasian_width_func); + +*/ + + +/* + * hb_face_t + */ + +hb_face_t * +hb_face_create_for_data (hb_blob_t *blob, + unsigned int index); + +/* calls destory() when not needing user_data anymore */ +hb_face_t * +hb_face_create_for_tables (hb_get_table_func_t get_table, + hb_destroy_func_t destroy, + void *user_data); + +hb_face_t * +hb_face_reference (hb_face_t *face); + +void +hb_face_destroy (hb_face_t *face); + +void +hb_face_set_font_callbacks (hb_face_t *face, + hb_font_callbacks_t *fcallbacks); + +void +hb_face_set_unicode_callbacks (hb_face_t *face, + hb_unicode_callbacks_t *ucallbacks); + + + +/* + * hb_font_t + */ + +/* Fonts are very light-weight objects */ + +hb_font_t * +hb_font_create (hb_face_t *face); + +hb_font_t * +hb_font_reference (hb_font_t *font); + +void +hb_font_destroy (hb_font_t *font); + +/* + * XXX + * should we decompose this to units_per_EM and font-size? + * units_per_EM setting then can go into the face, or better, + * read from the 'head' table. + * + * Then we either need size+shape like freetype does, or a full + * matrix. + */ +void +hb_font_set_scale (hb_font_t *font, + hb_16dot16_t x_scale, + hb_16dot16_t y_scale); + +/* + * A zero value means "no hinting in that direction" + */ +void +hb_font_set_ppem (hb_font_t *font, + unsigned int x_ppem, + unsigned int y_ppem); + + +HB_END_DECLS + +#endif /* HB_FONT_H */ diff --git a/src/hb-refcount-private.h b/src/hb-refcount-private.h index 29c29431b..c9b350b71 100644 --- a/src/hb-refcount-private.h +++ b/src/hb-refcount-private.h @@ -54,25 +54,29 @@ typedef struct { #define HB_REFERENCE_COUNT_HAS_REFERENCE(RC) (HB_REFERENCE_COUNT_GET_VALUE (RC) > 0) + /* Helper macros */ -#define HB_REFERENCE_COUNT_DO_CREATE(obj) \ +#define HB_OBJECT_IS_INERT(obj) \ + ((obj) == NULL || HB_REFERENCE_COUNT_IS_INVALID ((obj)->ref_count)) + +#define HB_OBJECT_DO_CREATE(obj) \ HB_STMT_START { \ HB_REFERENCE_COUNT_INIT (obj->ref_count, 1); \ } HB_STMT_END -#define HB_REFERENCE_COUNT_DO_REFERENCE(obj) \ +#define HB_OBJECT_DO_REFERENCE(obj) \ HB_STMT_START { \ - if (obj == NULL || HB_REFERENCE_COUNT_IS_INVALID (obj->ref_count)) \ + if (HB_OBJECT_IS_INERT (obj)) \ return obj; \ assert (HB_REFERENCE_COUNT_HAS_REFERENCE (obj->ref_count)); \ _hb_reference_count_inc (obj->ref_count); \ return obj; \ } HB_STMT_END -#define HB_REFERENCE_COUNT_DO_DESTROY(obj) \ +#define HB_OBJECT_DO_DESTROY(obj) \ HB_STMT_START { \ - if (obj == NULL || HB_REFERENCE_COUNT_IS_INVALID (obj->ref_count)) \ + if (HB_OBJECT_IS_INERT (obj)) \ return; \ assert (HB_REFERENCE_COUNT_HAS_REFERENCE (obj->ref_count)); \ if (!_hb_reference_count_dec_and_test (obj->ref_count)) \