X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Fhb-ot-layout-gdef-private.hh;h=08fd7578554f9e9ca385370d95c6f0e79798a0f3;hb=ffd4a436f7baccb68a0c3602f94ea0246e32844f;hp=b1b034ba1df4b969803c9085b2cc5576bdc8d004;hpb=b28815c1f6e46d38471cacbc31248ca6fda8c4d1;p=framework%2Fuifw%2Fharfbuzz.git diff --git a/src/hb-ot-layout-gdef-private.hh b/src/hb-ot-layout-gdef-private.hh index b1b034b..08fd757 100644 --- a/src/hb-ot-layout-gdef-private.hh +++ b/src/hb-ot-layout-gdef-private.hh @@ -1,7 +1,8 @@ /* - * Copyright (C) 2007,2008,2009 Red Hat, Inc. + * Copyright © 2007,2008,2009 Red Hat, Inc. + * Copyright © 2010,2011 Google, Inc. * - * This is part of HarfBuzz, an OpenType Layout engine library. + * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this @@ -22,6 +23,7 @@ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Red Hat Author(s): Behdad Esfahbod + * Google Author(s): Behdad Esfahbod */ #ifndef HB_OT_LAYOUT_GDEF_PRIVATE_HH @@ -29,18 +31,10 @@ #include "hb-ot-layout-common-private.hh" -#include "hb-font-private.h" +#include "hb-font-private.hh" +HB_BEGIN_DECLS -struct GlyphClassDef : ClassDef -{ - enum { - BaseGlyph = 0x0001u, - LigatureGlyph = 0x0002u, - MarkGlyph = 0x0003u, - ComponentGlyph = 0x0004u, - }; -}; /* * Attachment List Table @@ -48,34 +42,38 @@ struct GlyphClassDef : ClassDef typedef ArrayOf AttachPoint; /* Array of contour point indices--in * increasing numerical order */ -ASSERT_SIZE (AttachPoint, 2); struct AttachList { - inline bool get_attach_points (hb_codepoint_t glyph_id, - unsigned int *point_count /* IN/OUT */, - unsigned int *point_array /* OUT */) const + inline unsigned int get_attach_points (hb_codepoint_t glyph_id, + unsigned int start_offset, + unsigned int *point_count /* IN/OUT */, + unsigned int *point_array /* OUT */) const { unsigned int index = (this+coverage) (glyph_id); if (index == NOT_COVERED) { - *point_count = 0; - return false; + if (point_count) + *point_count = 0; + return 0; } - const AttachPoint &points = this+attachPoint[index]; - unsigned int count = MIN (points.len, *point_count); - for (unsigned int i = 0; i < count; i++) - point_array[i] = points[i]; + const AttachPoint &points = this+attachPoint[index]; - *point_count = points.len; + if (point_count) { + const USHORT *array = points.sub_array (start_offset, point_count); + unsigned int count = *point_count; + for (unsigned int i = 0; i < count; i++) + point_array[i] = array[i]; + } - return true; + return points.len; } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE_THIS2 (coverage, attachPoint); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return coverage.sanitize (c, this) + && attachPoint.sanitize (c, this); } private: @@ -85,8 +83,9 @@ struct AttachList OffsetArrayOf attachPoint; /* Array of AttachPoint tables * in Coverage Index order */ + public: + DEFINE_SIZE_ARRAY (4, attachPoint); }; -ASSERT_SIZE (AttachList, 4); /* * Ligature Caret Table @@ -97,58 +96,64 @@ struct CaretValueFormat1 friend struct CaretValue; private: - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const + inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id HB_UNUSED) const { - /* XXX vertical */ - return context->font->x_scale * coordinate / 0x10000; + return HB_DIRECTION_IS_HORIZONTAL (direction) ? font->em_scale_x (coordinate) : font->em_scale_y (coordinate); } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE_SELF (); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return c->check_struct (this); } private: USHORT caretValueFormat; /* Format identifier--format = 1 */ SHORT coordinate; /* X or Y value, in design units */ + public: + DEFINE_SIZE_STATIC (4); }; -ASSERT_SIZE (CaretValueFormat1, 4); struct CaretValueFormat2 { friend struct CaretValue; private: - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const + inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id) const { - return /* TODO contour point */ 0; + hb_position_t x, y; + if (hb_font_get_glyph_contour_point_for_origin (font, glyph_id, caretValuePoint, direction, &x, &y)) + return HB_DIRECTION_IS_HORIZONTAL (direction) ? x : y; + else + return 0; } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE_SELF (); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return c->check_struct (this); } private: USHORT caretValueFormat; /* Format identifier--format = 2 */ USHORT caretValuePoint; /* Contour point index on glyph */ + public: + DEFINE_SIZE_STATIC (4); }; -ASSERT_SIZE (CaretValueFormat2, 4); struct CaretValueFormat3 { friend struct CaretValue; - inline int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const + inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id HB_UNUSED) const { - /* XXX vertical */ - return context->font->x_scale * coordinate / 0x10000 + - ((this+deviceTable).get_delta (context->font->x_ppem) << 6); + return HB_DIRECTION_IS_HORIZONTAL (direction) ? + font->em_scale_x (coordinate) + (this+deviceTable).get_x_delta (font) : + font->em_scale_y (coordinate) + (this+deviceTable).get_y_delta (font); } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE_SELF () && SANITIZE_THIS (deviceTable); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return c->check_struct (this) + && deviceTable.sanitize (c, this); } private: @@ -158,29 +163,29 @@ struct CaretValueFormat3 deviceTable; /* Offset to Device table for X or Y * value--from beginning of CaretValue * table */ + public: + DEFINE_SIZE_STATIC (6); }; -ASSERT_SIZE (CaretValueFormat3, 6); struct CaretValue { - /* XXX we need access to a load-contour-point vfunc here */ - int get_caret_value (hb_ot_layout_context_t *context, hb_codepoint_t glyph_id) const + inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id) const { switch (u.format) { - case 1: return u.format1->get_caret_value (context, glyph_id); - case 2: return u.format2->get_caret_value (context, glyph_id); - case 3: return u.format3->get_caret_value (context, glyph_id); + case 1: return u.format1.get_caret_value (font, direction, glyph_id); + case 2: return u.format2.get_caret_value (font, direction, glyph_id); + case 3: return u.format3.get_caret_value (font, direction, glyph_id); default:return 0; } } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - if (!SANITIZE (u.format)) return false; + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); - case 2: return u.format2->sanitize (SANITIZE_ARG); - case 3: return u.format3->sanitize (SANITIZE_ARG); + case 1: return u.format1.sanitize (c); + case 2: return u.format2.sanitize (c); + case 3: return u.format3.sanitize (c); default:return true; } } @@ -188,62 +193,71 @@ struct CaretValue private: union { USHORT format; /* Format identifier */ - CaretValueFormat1 format1[]; - CaretValueFormat2 format2[]; - CaretValueFormat3 format3[]; + CaretValueFormat1 format1; + CaretValueFormat2 format2; + CaretValueFormat3 format3; } u; + public: + DEFINE_SIZE_UNION (2, format); }; -ASSERT_SIZE (CaretValue, 2); struct LigGlyph { - inline void get_lig_carets (hb_ot_layout_context_t *context, - hb_codepoint_t glyph_id, - unsigned int *caret_count /* IN/OUT */, - int *caret_array /* OUT */) const + inline unsigned int get_lig_carets (hb_font_t *font, + hb_direction_t direction, + hb_codepoint_t glyph_id, + unsigned int start_offset, + unsigned int *caret_count /* IN/OUT */, + hb_position_t *caret_array /* OUT */) const { + if (caret_count) { + const OffsetTo *array = carets.sub_array (start_offset, caret_count); + unsigned int count = *caret_count; + for (unsigned int i = 0; i < count; i++) + caret_array[i] = (this+array[i]).get_caret_value (font, direction, glyph_id); + } - unsigned int count = MIN (carets.len, *caret_count); - for (unsigned int i = 0; i < count; i++) - caret_array[i] = (this+carets[i]).get_caret_value (context, glyph_id); - - *caret_count = carets.len; + return carets.len; } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE (carets); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return carets.sanitize (c, this); } private: OffsetArrayOf - carets; /* Offset rrray of CaretValue tables + carets; /* Offset array of CaretValue tables * --from beginning of LigGlyph table * --in increasing coordinate order */ + public: + DEFINE_SIZE_ARRAY (2, carets); }; -ASSERT_SIZE (LigGlyph, 2); struct LigCaretList { - inline bool get_lig_carets (hb_ot_layout_context_t *context, - hb_codepoint_t glyph_id, - unsigned int *caret_count /* IN/OUT */, - int *caret_array /* OUT */) const + inline unsigned int get_lig_carets (hb_font_t *font, + hb_direction_t direction, + hb_codepoint_t glyph_id, + unsigned int start_offset, + unsigned int *caret_count /* IN/OUT */, + hb_position_t *caret_array /* OUT */) const { unsigned int index = (this+coverage) (glyph_id); if (index == NOT_COVERED) { - *caret_count = 0; - return false; + if (caret_count) + *caret_count = 0; + return 0; } const LigGlyph &lig_glyph = this+ligGlyph[index]; - lig_glyph.get_lig_carets (context, glyph_id, caret_count, caret_array); - return true; + return lig_glyph.get_lig_carets (font, direction, glyph_id, start_offset, caret_count, caret_array); } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE_THIS2 (coverage, ligGlyph); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return coverage.sanitize (c, this) + && ligGlyph.sanitize (c, this); } private: @@ -253,8 +267,9 @@ struct LigCaretList OffsetArrayOf ligGlyph; /* Array of LigGlyph tables * in Coverage Index order */ + public: + DEFINE_SIZE_ARRAY (4, ligGlyph); }; -ASSERT_SIZE (LigCaretList, 4); struct MarkGlyphSetsFormat1 @@ -262,9 +277,9 @@ struct MarkGlyphSetsFormat1 inline bool covers (unsigned int set_index, hb_codepoint_t glyph_id) const { return (this+coverage[set_index]).get_coverage (glyph_id) != NOT_COVERED; } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - return SANITIZE_THIS (coverage); + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return coverage.sanitize (c, this); } private: @@ -272,24 +287,25 @@ struct MarkGlyphSetsFormat1 LongOffsetArrayOf coverage; /* Array of long offsets to mark set * coverage tables */ + public: + DEFINE_SIZE_ARRAY (4, coverage); }; -ASSERT_SIZE (MarkGlyphSetsFormat1, 4); struct MarkGlyphSets { inline bool covers (unsigned int set_index, hb_codepoint_t glyph_id) const { switch (u.format) { - case 1: return u.format1->covers (set_index, glyph_id); + case 1: return u.format1.covers (set_index, glyph_id); default:return false; } } - inline bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - if (!SANITIZE (u.format)) return false; + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + if (!u.format.sanitize (c)) return false; switch (u.format) { - case 1: return u.format1->sanitize (SANITIZE_ARG); + case 1: return u.format1.sanitize (c); default:return true; } } @@ -297,10 +313,11 @@ struct MarkGlyphSets private: union { USHORT format; /* Format identifier */ - MarkGlyphSetsFormat1 format1[]; + MarkGlyphSetsFormat1 format1; } u; + public: + DEFINE_SIZE_UNION (2, format); }; -ASSERT_SIZE (MarkGlyphSets, 2); /* @@ -316,45 +333,68 @@ struct GDEF BaseGlyph = 1, LigatureGlyph = 2, MarkGlyph = 3, - ComponentGlyph = 4, + ComponentGlyph = 4 }; - STATIC_DEFINE_GET_FOR_DATA_CHECK_MAJOR_VERSION (GDEF, 1, 1); - - inline bool has_glyph_classes () const { return glyphClassDef != 0; } - inline hb_ot_layout_class_t get_glyph_class (hb_codepoint_t glyph) const + inline bool has_glyph_classes (void) const { return glyphClassDef != 0; } + inline unsigned int get_glyph_class (hb_codepoint_t glyph) const { return (this+glyphClassDef).get_class (glyph); } - inline bool has_mark_attachment_types () const { return markAttachClassDef != 0; } - inline hb_ot_layout_class_t get_mark_attachment_type (hb_codepoint_t glyph) const + inline bool has_mark_attachment_types (void) const { return markAttachClassDef != 0; } + inline unsigned int get_mark_attachment_type (hb_codepoint_t glyph) const { return (this+markAttachClassDef).get_class (glyph); } - inline bool has_attach_points () const { return attachList != 0; } - inline bool get_attach_points (hb_codepoint_t glyph_id, - unsigned int *point_count /* IN/OUT */, - unsigned int *point_array /* OUT */) const - { return (this+attachList).get_attach_points (glyph_id, point_count, point_array); } + inline bool has_attach_points (void) const { return attachList != 0; } + inline unsigned int get_attach_points (hb_codepoint_t glyph_id, + unsigned int start_offset, + unsigned int *point_count /* IN/OUT */, + unsigned int *point_array /* OUT */) const + { return (this+attachList).get_attach_points (glyph_id, start_offset, point_count, point_array); } + + inline bool has_lig_carets (void) const { return ligCaretList != 0; } + inline unsigned int get_lig_carets (hb_font_t *font, + hb_direction_t direction, + hb_codepoint_t glyph_id, + unsigned int start_offset, + unsigned int *caret_count /* IN/OUT */, + hb_position_t *caret_array /* OUT */) const + { return (this+ligCaretList).get_lig_carets (font, direction, glyph_id, start_offset, caret_count, caret_array); } + + inline bool has_mark_sets (void) const { return version.to_int () >= 0x00010002 && markGlyphSetsDef[0] != 0; } + inline bool mark_set_covers (unsigned int set_index, hb_codepoint_t glyph_id) const + { return version.to_int () >= 0x00010002 && (this+markGlyphSetsDef[0]).covers (set_index, glyph_id); } + + inline bool sanitize (hb_sanitize_context_t *c) { + TRACE_SANITIZE (); + return version.sanitize (c) && likely (version.major == 1) + && glyphClassDef.sanitize (c, this) + && attachList.sanitize (c, this) + && ligCaretList.sanitize (c, this) + && markAttachClassDef.sanitize (c, this) + && (version.to_int () < 0x00010002 || markGlyphSetsDef[0].sanitize (c, this)); + } - inline bool has_lig_carets () const { return ligCaretList != 0; } - inline bool get_lig_carets (hb_ot_layout_context_t *context, - hb_codepoint_t glyph_id, - unsigned int *caret_count /* IN/OUT */, - int *caret_array /* OUT */) const - { return (this+ligCaretList).get_lig_carets (context, glyph_id, caret_count, caret_array); } - inline bool has_mark_sets () const { return version >= 0x00010002 && markGlyphSetsDef[0] != 0; } - inline bool mark_set_covers (unsigned int set_index, hb_codepoint_t glyph_id) const - { return version >= 0x00010002 && (this+markGlyphSetsDef[0]).covers (set_index, glyph_id); } - - bool sanitize (SANITIZE_ARG_DEF) { - SANITIZE_DEBUG (); - if (!SANITIZE (version)) return false; - if (version.major != 1) return true; - return SANITIZE_THIS2 (glyphClassDef, attachList) && - SANITIZE_THIS2 (ligCaretList, markAttachClassDef) && - (version < 0x00010002 || SANITIZE_THIS (markGlyphSetsDef[0])); + /* glyph_props is a 16-bit integer where the lower 8-bit have bits representing + * glyph class and other bits, and high 8-bit gthe mark attachment type (if any). + * Not to be confused with lookup_props which is very similar. */ + inline unsigned int get_glyph_props (hb_codepoint_t glyph) const + { + unsigned int klass = get_glyph_class (glyph); + + switch (klass) { + default: + case UnclassifiedGlyph: return HB_OT_LAYOUT_GLYPH_CLASS_UNCLASSIFIED; + case BaseGlyph: return HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH; + case LigatureGlyph: return HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE; + case ComponentGlyph: return HB_OT_LAYOUT_GLYPH_CLASS_COMPONENT; + case MarkGlyph: + klass = get_mark_attachment_type (glyph); + return HB_OT_LAYOUT_GLYPH_CLASS_MARK | (klass << 8); + } } + private: FixedVersion version; /* Version of the GDEF table--currently * 0x00010002 */ @@ -375,12 +415,15 @@ struct GDEF * mark attachment type--from beginning * of GDEF header (may be Null) */ OffsetTo - markGlyphSetsDef[0]; /* Offset to the table of mark set + markGlyphSetsDef[VAR]; /* Offset to the table of mark set * definitions--from beginning of GDEF * header (may be NULL). Introduced * in version 00010002. */ + public: + DEFINE_SIZE_ARRAY (12, markGlyphSetsDef); }; -ASSERT_SIZE (GDEF, 12); +HB_END_DECLS + #endif /* HB_OT_LAYOUT_GDEF_PRIVATE_HH */