/* * Copyright © 2018 Ebrahim Byagowi * * 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 * 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. */ #ifndef HB_AAT_LAYOUT_JUST_TABLE_HH #define HB_AAT_LAYOUT_JUST_TABLE_HH #include "hb-aat-layout-common.hh" #include "hb-ot-layout.hh" #include "hb-open-type.hh" #include "hb-aat-layout-morx-table.hh" /* * just -- Justification * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6just.html */ #define HB_AAT_TAG_just HB_TAG('j','u','s','t') namespace AAT { using namespace OT; struct ActionSubrecordHeader { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this))); } HBUINT16 actionClass; /* The JustClass value associated with this * ActionSubrecord. */ HBUINT16 actionType; /* The type of postcompensation action. */ HBUINT16 actionLength; /* Length of this ActionSubrecord record, which * must be a multiple of 4. */ public: DEFINE_SIZE_STATIC (6); }; struct DecompositionAction { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this))); } ActionSubrecordHeader header; Fixed lowerLimit; /* If the distance factor is less than this value, * then the ligature is decomposed. */ Fixed upperLimit; /* If the distance factor is greater than this value, * then the ligature is decomposed. */ HBUINT16 order; /* Numerical order in which this ligature will * be decomposed; you may want infrequent ligatures * to decompose before more frequent ones. The ligatures * on the line of text will decompose in increasing * value of this field. */ ArrayOf decomposedglyphs; /* Number of 16-bit glyph indexes that follow; * the ligature will be decomposed into these glyphs. * * Array of decomposed glyphs. */ public: DEFINE_SIZE_ARRAY (18, decomposedglyphs); }; struct UnconditionalAddGlyphAction { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); } protected: ActionSubrecordHeader header; GlyphID addGlyph; /* Glyph that should be added if the distance factor * is growing. */ public: DEFINE_SIZE_STATIC (8); }; struct ConditionalAddGlyphAction { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this))); } protected: ActionSubrecordHeader header; Fixed substThreshold; /* Distance growth factor (in ems) at which * this glyph is replaced and the growth factor * recalculated. */ GlyphID addGlyph; /* Glyph to be added as kashida. If this value is * 0xFFFF, no extra glyph will be added. Note that * generally when a glyph is added, justification * will need to be redone. */ GlyphID substGlyph; /* Glyph to be substituted for this glyph if the * growth factor equals or exceeds the value of * substThreshold. */ public: DEFINE_SIZE_STATIC (14); }; struct DuctileGlyphAction { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this))); } protected: ActionSubrecordHeader header; HBUINT32 variationAxis; /* The 4-byte tag identifying the ductile axis. * This would normally be 0x64756374 ('duct'), * but you may use any axis the font contains. */ Fixed minimumLimit; /* The lowest value for the ductility axis tha * still yields an acceptable appearance. Normally * this will be 1.0. */ Fixed noStretchValue; /* This is the default value that corresponds to * no change in appearance. Normally, this will * be 1.0. */ Fixed maximumLimit; /* The highest value for the ductility axis that * still yields an acceptable appearance. */ public: DEFINE_SIZE_STATIC (22); }; struct RepeatedAddGlyphAction { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this))); } protected: ActionSubrecordHeader header; HBUINT16 flags; /* Currently unused; set to 0. */ GlyphID glyph; /* Glyph that should be added if the distance factor * is growing. */ public: DEFINE_SIZE_STATIC (10); }; struct ActionSubrecord { unsigned int get_length () const { return u.header.actionLength; } bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (unlikely (!c->check_struct (this))) return_trace (false); switch (u.header.actionType) { case 0: return_trace (u.decompositionAction.sanitize (c)); case 1: return_trace (u.unconditionalAddGlyphAction.sanitize (c)); case 2: return_trace (u.conditionalAddGlyphAction.sanitize (c)); // case 3: return_trace (u.stretchGlyphAction.sanitize (c)); case 4: return_trace (u.decompositionAction.sanitize (c)); case 5: return_trace (u.decompositionAction.sanitize (c)); default: return_trace (true); } } protected: union { ActionSubrecordHeader header; DecompositionAction decompositionAction; UnconditionalAddGlyphAction unconditionalAddGlyphAction; ConditionalAddGlyphAction conditionalAddGlyphAction; /* StretchGlyphAction stretchGlyphAction; -- Not supported by CoreText */ DuctileGlyphAction ductileGlyphAction; RepeatedAddGlyphAction repeatedAddGlyphAction; } u; /* Data. The format of this data depends on * the value of the actionType field. */ public: DEFINE_SIZE_UNION (6, header); }; struct PostcompensationActionChain { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (unlikely (!c->check_struct (this))) return_trace (false); unsigned int offset = min_size; for (unsigned int i = 0; i < count; i++) { const ActionSubrecord& subrecord = StructAtOffset (this, offset); if (unlikely (!subrecord.sanitize (c))) return_trace (false); offset += subrecord.get_length (); } return_trace (true); } protected: HBUINT32 count; public: DEFINE_SIZE_STATIC (4); }; struct JustWidthDeltaEntry { enum Flags { Reserved1 =0xE000,/* Reserved. You should set these bits to zero. */ UnlimiteGap =0x1000,/* The glyph can take unlimited gap. When this * glyph participates in the justification process, * it and any other glyphs on the line having this * bit set absorb all the remaining gap. */ Reserved2 =0x0FF0,/* Reserved. You should set these bits to zero. */ Priority =0x000F /* The justification priority of the glyph. */ }; enum Priority { Kashida = 0, /* Kashida priority. This is the highest priority * during justification. */ Whitespace = 1, /* Whitespace priority. Any whitespace glyphs (as * identified in the glyph properties table) will * get this priority. */ InterCharacter = 2, /* Inter-character priority. Give this to any * remaining glyphs. */ NullPriority = 3 /* Null priority. You should set this priority for * glyphs that only participate in justification * after the above priorities. Normally all glyphs * have one of the previous three values. If you * don't want a glyph to participate in justification, * and you don't want to set its factors to zero, * you may instead assign it to the null priority. */ }; protected: Fixed beforeGrowLimit;/* The ratio by which the advance width of the * glyph is permitted to grow on the left or top side. */ Fixed beforeShrinkLimit; /* The ratio by which the advance width of the * glyph is permitted to shrink on the left or top side. */ Fixed afterGrowLimit; /* The ratio by which the advance width of the glyph * is permitted to shrink on the left or top side. */ Fixed afterShrinkLimit; /* The ratio by which the advance width of the glyph * is at most permitted to shrink on the right or * bottom side. */ HBUINT16 growFlags; /* Flags controlling the grow case. */ HBUINT16 shrinkFlags; /* Flags controlling the shrink case. */ public: DEFINE_SIZE_STATIC (20); }; struct WidthDeltaPair { bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this))); } protected: HBUINT32 justClass; /* The justification category associated * with the wdRecord field. Only 7 bits of * this field are used. (The other bits are * used as padding to guarantee longword * alignment of the following record). */ JustWidthDeltaEntry wdRecord; /* The actual width delta record. */ public: DEFINE_SIZE_STATIC (24); }; typedef OT::LArrayOf WidthDeltaCluster; struct JustificationCategory { typedef void EntryData; enum Flags { SetMark =0x8000,/* If set, make the current glyph the marked * glyph. */ DontAdvance =0x4000,/* If set, don't advance to the next glyph before * going to the new state. */ MarkCategory =0x3F80,/* The justification category for the marked * glyph if nonzero. */ CurrentCategory =0x007F /* The justification category for the current * glyph if nonzero. */ }; bool sanitize (hb_sanitize_context_t *c, const void *base) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this) && morphHeader.sanitize (c) && stHeader.sanitize (c))); } protected: ChainSubtable morphHeader; /* Metamorphosis-style subtable header. */ StateTable stHeader; /* The justification insertion state table header */ public: DEFINE_SIZE_STATIC (30); }; struct JustificationHeader { bool sanitize (hb_sanitize_context_t *c, const void *base) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this) && justClassTable.sanitize (c, base, base) && wdcTable.sanitize (c, base) && pcTable.sanitize (c, base) && lookupTable.sanitize (c, base))); } protected: OffsetTo justClassTable; /* Offset to the justification category state table. */ OffsetTo wdcTable; /* Offset from start of justification table to start * of the subtable containing the width delta factors * for the glyphs in your font. * * The width delta clusters table. */ OffsetTo pcTable; /* Offset from start of justification table to start * of postcompensation subtable (set to zero if none). * * The postcompensation subtable, if present in the font. */ Lookup > lookupTable; /* Lookup table associating glyphs with width delta * clusters. See the description of Width Delta Clusters * table for details on how to interpret the lookup values. */ public: DEFINE_SIZE_MIN (8); }; struct just { enum { tableTag = HB_AAT_TAG_just }; bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (likely (c->check_struct (this) && version.major == 1 && horizData.sanitize (c, this, this) && vertData.sanitize (c, this, this))); } protected: FixedVersion<>version; /* Version of the justification table * (0x00010000u for version 1.0). */ HBUINT16 format; /* Format of the justification table (set to 0). */ OffsetTo horizData; /* Byte offset from the start of the justification table * to the header for tables that contain justification * information for horizontal text. * If you are not including this information, * store 0. */ OffsetTo vertData; /* ditto, vertical */ public: DEFINE_SIZE_STATIC (10); }; } /* namespace AAT */ #endif /* HB_AAT_LAYOUT_JUST_TABLE_HH */