/*
* 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 (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 (c->check_struct (
this));
}
ActionSubrecordHeader
header;
F16DOT16 lowerLimit;
/* If the distance factor is less than this value,
* then the ligature is decomposed. */
F16DOT16 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. */
Array16Of<HBUINT16>
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;
HBGlyphID16 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 (c->check_struct (
this));
}
protected:
ActionSubrecordHeader
header;
F16DOT16 substThreshold;
/* Distance growth factor (in ems) at which
* this glyph is replaced and the growth factor
* recalculated. */
HBGlyphID16 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. */
HBGlyphID16 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 (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. */
F16DOT16 minimumLimit;
/* The lowest value for the ductility axis that
* still yields an acceptable appearance. Normally
* this will be 1.0. */
F16DOT16 noStretchValue;
/* This is the default value that corresponds to
* no change in appearance. Normally, this will
* be 1.0. */
F16DOT16 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 (c->check_struct (
this));
}
protected:
ActionSubrecordHeader
header;
HBUINT16 flags;
/* Currently unused; set to 0. */
HBGlyphID16 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);
hb_barrier ();
switch (u.header.actionType)
{
case 0: hb_barrier (); return_trace (u.decompositionAction.sanitize (c));
case 1: hb_barrier (); return_trace (u.unconditionalAddGlyphAction.sanitize (c));
case 2: hb_barrier (); return_trace (u.conditionalAddGlyphAction.sanitize (c));
// case 3: hb_barrier (); return_trace (u.stretchGlyphAction.sanitize (c));
case 4: hb_barrier (); return_trace (u.decompositionAction.sanitize (c));
case 5: hb_barrier (); 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);
hb_barrier ();
unsigned int offset = min_size;
for (
unsigned int i =
0; i < count; i++)
{
const ActionSubrecord& subrecord = StructAtOffset<ActionSubrecord> (
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:
F16DOT16 beforeGrowLimit;
/* The ratio by which the advance width of the
* glyph is permitted to grow on the left or top side. */
F16DOT16 beforeShrinkLimit;
/* The ratio by which the advance width of the
* glyph is permitted to shrink on the left or top side. */
F16DOT16 afterGrowLimit;
/* The ratio by which the advance width of the glyph
* is permitted to shrink on the left or top side. */
F16DOT16 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 (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::Array32Of<WidthDeltaPair> 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<ObsoleteTypes>
morphHeader;
/* Metamorphosis-style subtable header. */
StateTable<ObsoleteTypes, EntryData>
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:
Offset16To<JustificationCategory>
justClassTable;
/* Offset to the justification category state table. */
Offset16To<WidthDeltaCluster>
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. */
Offset16To<PostcompensationActionChain>
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<Offset16To<WidthDeltaCluster>>
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
{
static constexpr hb_tag_t tableTag = HB_AAT_TAG_just;
bool sanitize (hb_sanitize_context_t *c)
const
{
TRACE_SANITIZE (
this);
return_trace (likely (c->check_struct (
this) &&
hb_barrier () &&
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). */
Offset16To<JustificationHeader>
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. */
Offset16To<JustificationHeader>
vertData;
/* ditto, vertical */
public:
DEFINE_SIZE_STATIC (
10);
};
}
/* namespace AAT */
#endif /* HB_AAT_LAYOUT_JUST_TABLE_HH */
