harfbuzz/src/hb-ot-layout-common-private.hh

765 lines
21 KiB
C++
Raw Normal View History

/*
2011-04-21 23:14:28 +02:00
* Copyright © 2007,2008,2009 Red Hat, Inc.
2012-04-24 04:26:13 +02:00
* Copyright © 2010,2012 Google, Inc.
*
2010-04-22 06:11:43 +02:00
* 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.
*
* Red Hat Author(s): Behdad Esfahbod
* Google Author(s): Behdad Esfahbod
*/
#ifndef HB_OT_LAYOUT_COMMON_PRIVATE_HH
#define HB_OT_LAYOUT_COMMON_PRIVATE_HH
#include "hb-ot-layout-private.hh"
#include "hb-open-type-private.hh"
2012-04-24 04:41:09 +02:00
#include "hb-set-private.hh"
2012-07-29 00:03:20 +02:00
#define NOT_COVERED ((unsigned int) -1)
2009-08-15 00:42:42 +02:00
#define MAX_NESTING_LEVEL 8
2010-07-23 21:11:18 +02:00
2009-08-15 00:42:42 +02:00
/*
*
* OpenType Layout Common Table Formats
*
*/
/*
* Script, ScriptList, LangSys, Feature, FeatureList, Lookup, LookupList
*/
template <typename Type>
2009-05-20 05:58:54 +02:00
struct Record
{
inline int cmp (hb_tag_t a) const {
2010-09-29 18:10:24 +02:00
return tag.cmp (a);
2010-07-08 06:40:04 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c, void *base) {
TRACE_SANITIZE ();
return TRACE_RETURN (c->check_struct (this) && offset.sanitize (c, base));
2009-08-04 08:09:34 +02:00
}
Tag tag; /* 4-byte Tag identifier */
OffsetTo<Type>
offset; /* Offset from beginning of object holding
* the Record */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_STATIC (6);
};
template <typename Type>
2010-07-08 06:40:04 +02:00
struct RecordArrayOf : SortedArrayOf<Record<Type> > {
2009-05-20 05:58:54 +02:00
inline const Tag& get_tag (unsigned int i) const
{
2010-11-03 20:47:12 +01:00
/* We cheat slightly and don't define separate Null objects
* for Record types. Instead, we return the correct Null(Tag)
* here. */
if (unlikely (i >= this->len)) return Null(Tag);
return (*this)[i].tag;
}
inline unsigned int get_tags (unsigned int start_offset,
unsigned int *record_count /* IN/OUT */,
hb_tag_t *record_tags /* OUT */) const
{
if (record_count) {
2011-06-15 15:49:58 +02:00
const Record<Type> *arr = this->sub_array (start_offset, record_count);
2009-11-04 22:59:50 +01:00
unsigned int count = *record_count;
for (unsigned int i = 0; i < count; i++)
2011-06-15 15:49:58 +02:00
record_tags[i] = arr[i].tag;
}
return this->len;
}
inline bool find_index (hb_tag_t tag, unsigned int *index) const
{
2010-07-08 06:40:04 +02:00
int i = this->search (tag);
if (i != -1) {
if (index) *index = i;
return true;
2010-07-08 06:40:04 +02:00
} else {
if (index) *index = Index::NOT_FOUND_INDEX;
return false;
}
}
};
template <typename Type>
struct RecordListOf : RecordArrayOf<Type>
{
inline const Type& operator [] (unsigned int i) const
2009-11-03 01:17:36 +01:00
{ return this+RecordArrayOf<Type>::operator [](i).offset; }
2009-08-04 08:09:34 +02:00
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (RecordArrayOf<Type>::sanitize (c, this));
2009-08-04 08:09:34 +02:00
}
};
2010-07-08 06:40:04 +02:00
struct RangeRecord
{
inline int cmp (hb_codepoint_t g) const {
hb_codepoint_t a = start, b = end;
return g < a ? -1 : g <= b ? 0 : +1 ;
}
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (c->check_struct (this));
2010-07-08 06:40:04 +02:00
}
2012-04-24 04:23:17 +02:00
inline bool intersects (const hb_set_t *glyphs) const {
return glyphs->intersects (start, end);
}
2012-06-09 08:02:46 +02:00
inline void add_coverage (hb_set_t *glyphs) const {
glyphs->add_range (start, end);
}
2010-07-08 06:40:04 +02:00
GlyphID start; /* First GlyphID in the range */
GlyphID end; /* Last GlyphID in the range */
USHORT value; /* Value */
public:
DEFINE_SIZE_STATIC (6);
};
DEFINE_NULL_DATA (RangeRecord, "\000\001");
2010-05-11 04:22:22 +02:00
struct IndexArray : ArrayOf<Index>
{
inline unsigned int get_indexes (unsigned int start_offset,
unsigned int *_count /* IN/OUT */,
unsigned int *_indexes /* OUT */) const
{
if (_count) {
2011-06-15 15:49:58 +02:00
const USHORT *arr = this->sub_array (start_offset, _count);
2009-11-04 22:59:50 +01:00
unsigned int count = *_count;
for (unsigned int i = 0; i < count; i++)
2011-06-15 15:49:58 +02:00
_indexes[i] = arr[i];
}
return this->len;
}
};
struct Script;
struct LangSys;
struct Feature;
2009-05-20 05:58:54 +02:00
struct LangSys
{
inline unsigned int get_feature_count (void) const
{ return featureIndex.len; }
inline hb_tag_t get_feature_index (unsigned int i) const
{ return featureIndex[i]; }
inline unsigned int get_feature_indexes (unsigned int start_offset,
unsigned int *feature_count /* IN/OUT */,
unsigned int *feature_indexes /* OUT */) const
{ return featureIndex.get_indexes (start_offset, feature_count, feature_indexes); }
2009-05-25 09:10:06 +02:00
inline bool has_required_feature (void) const { return reqFeatureIndex != 0xffff; }
2010-05-11 04:22:54 +02:00
inline unsigned int get_required_feature_index (void) const
2009-05-20 05:58:54 +02:00
{
if (reqFeatureIndex == 0xffff)
2010-05-11 04:22:22 +02:00
return Index::NOT_FOUND_INDEX;
return reqFeatureIndex;;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (c->check_struct (this) && featureIndex.sanitize (c));
2009-08-04 08:09:34 +02:00
}
Offset lookupOrder; /* = Null (reserved for an offset to a
* reordering table) */
USHORT reqFeatureIndex;/* Index of a feature required for this
* language system--if no required features
* = 0xFFFF */
IndexArray featureIndex; /* Array of indices into the FeatureList */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (6, featureIndex);
};
DEFINE_NULL_DATA (LangSys, "\0\0\xFF\xFF");
2009-05-20 05:58:54 +02:00
struct Script
{
inline unsigned int get_lang_sys_count (void) const
{ return langSys.len; }
inline const Tag& get_lang_sys_tag (unsigned int i) const
{ return langSys.get_tag (i); }
inline unsigned int get_lang_sys_tags (unsigned int start_offset,
unsigned int *lang_sys_count /* IN/OUT */,
hb_tag_t *lang_sys_tags /* OUT */) const
{ return langSys.get_tags (start_offset, lang_sys_count, lang_sys_tags); }
2009-05-20 05:58:54 +02:00
inline const LangSys& get_lang_sys (unsigned int i) const
{
2010-05-11 04:22:22 +02:00
if (i == Index::NOT_FOUND_INDEX) return get_default_lang_sys ();
return this+langSys[i].offset;
}
inline bool find_lang_sys_index (hb_tag_t tag, unsigned int *index) const
{ return langSys.find_index (tag, index); }
2009-05-25 09:10:06 +02:00
inline bool has_default_lang_sys (void) const { return defaultLangSys != 0; }
2009-05-20 05:58:54 +02:00
inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (defaultLangSys.sanitize (c, this) && langSys.sanitize (c, this));
2009-08-04 08:09:34 +02:00
}
protected:
OffsetTo<LangSys>
defaultLangSys; /* Offset to DefaultLangSys table--from
* beginning of Script table--may be Null */
2009-08-04 08:09:34 +02:00
RecordArrayOf<LangSys>
langSys; /* Array of LangSysRecords--listed
* alphabetically by LangSysTag */
public:
DEFINE_SIZE_ARRAY (4, langSys);
};
typedef RecordListOf<Script> ScriptList;
2009-05-20 05:58:54 +02:00
struct Feature
{
inline unsigned int get_lookup_count (void) const
{ return lookupIndex.len; }
inline hb_tag_t get_lookup_index (unsigned int i) const
{ return lookupIndex[i]; }
inline unsigned int get_lookup_indexes (unsigned int start_index,
unsigned int *lookup_count /* IN/OUT */,
unsigned int *lookup_tags /* OUT */) const
{ return lookupIndex.get_indexes (start_index, lookup_count, lookup_tags); }
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (c->check_struct (this) && lookupIndex.sanitize (c));
2009-08-04 08:09:34 +02:00
}
Offset featureParams; /* Offset to Feature Parameters table (if one
* has been defined for the feature), relative
* to the beginning of the Feature Table; = Null
* if not required */
IndexArray lookupIndex; /* Array of LookupList indices */
public:
DEFINE_SIZE_ARRAY (4, lookupIndex);
};
typedef RecordListOf<Feature> FeatureList;
2009-05-20 05:58:54 +02:00
struct LookupFlag : USHORT
{
enum Flags {
2009-05-19 00:44:54 +02:00
RightToLeft = 0x0001u,
IgnoreBaseGlyphs = 0x0002u,
IgnoreLigatures = 0x0004u,
IgnoreMarks = 0x0008u,
IgnoreFlags = 0x000Eu,
2009-05-26 19:04:59 +02:00
UseMarkFilteringSet = 0x0010u,
Reserved = 0x00E0u,
2009-08-18 22:41:59 +02:00
MarkAttachmentType = 0xFF00u
2009-05-19 00:44:54 +02:00
};
public:
DEFINE_SIZE_STATIC (2);
};
2009-05-20 05:58:54 +02:00
struct Lookup
{
inline unsigned int get_subtable_count (void) const { return subTable.len; }
inline unsigned int get_type (void) const { return lookupType; }
/* lookup_props is a 32-bit integer where the lower 16-bit is LookupFlag and
* higher 16-bit is mark-filtering-set if the lookup uses one.
* Not to be confused with glyph_props which is very similar. */
inline uint32_t get_props (void) const
2009-05-26 19:04:59 +02:00
{
unsigned int flag = lookupFlag;
if (unlikely (flag & LookupFlag::UseMarkFilteringSet))
2009-05-26 19:04:59 +02:00
{
const USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
2009-05-27 01:48:16 +02:00
flag += (markFilteringSet << 16);
2009-05-26 19:04:59 +02:00
}
return flag;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-04-22 22:51:42 +02:00
/* Real sanitize of the subtables is done by GSUB/GPOS/... */
if (!(c->check_struct (this) && subTable.sanitize (c))) return TRACE_RETURN (false);
2012-07-28 23:25:20 +02:00
if (!subTable.len) TRACE_RETURN (false);
if (unlikely (lookupFlag & LookupFlag::UseMarkFilteringSet))
2009-08-04 08:09:34 +02:00
{
USHORT &markFilteringSet = StructAfter<USHORT> (subTable);
if (!markFilteringSet.sanitize (c)) return TRACE_RETURN (false);
2009-08-04 08:09:34 +02:00
}
return TRACE_RETURN (true);
2009-08-04 08:09:34 +02:00
}
2009-05-26 19:04:59 +02:00
USHORT lookupType; /* Different enumerations for GSUB and GPOS */
USHORT lookupFlag; /* Lookup qualifiers */
2010-04-22 22:51:42 +02:00
ArrayOf<Offset>
2009-05-26 19:04:59 +02:00
subTable; /* Array of SubTables */
USHORT markFilteringSetX[VAR]; /* Index (base 0) into GDEF mark glyph sets
2009-05-26 19:04:59 +02:00
* structure. This field is only present if bit
* UseMarkFilteringSet of lookup flags is set. */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY2 (6, subTable, markFilteringSetX);
};
typedef OffsetListOf<Lookup> LookupList;
/*
* Coverage Table
*/
2009-05-20 05:58:54 +02:00
struct CoverageFormat1
{
friend struct Coverage;
private:
2009-05-20 05:58:54 +02:00
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
2010-07-08 06:40:04 +02:00
int i = glyphArray.search (glyph_id);
2012-07-29 00:03:20 +02:00
ASSERT_STATIC (((unsigned int) -1) == NOT_COVERED);
return i;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (glyphArray.sanitize (c));
2009-08-04 06:58:28 +02:00
}
2012-04-24 04:23:17 +02:00
inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
return glyphs->has (glyphArray[index]);
}
2012-06-09 08:02:46 +02:00
inline void add_coverage (hb_set_t *glyphs) const {
unsigned int count = glyphArray.len;
for (unsigned int i = 0; i < count; i++)
glyphs->add (glyphArray[i]);
}
2012-04-23 19:02:14 +02:00
struct Iter {
inline void init (const struct CoverageFormat1 &c_) { c = &c_; i = 0; };
inline bool more (void) { return i < c->glyphArray.len; }
inline void next (void) { i++; }
inline uint16_t get_glyph (void) { return c->glyphArray[i]; }
inline uint16_t get_coverage (void) { return i; }
2012-04-23 19:02:14 +02:00
private:
const struct CoverageFormat1 *c;
unsigned int i;
};
protected:
USHORT coverageFormat; /* Format identifier--format = 1 */
2010-07-08 06:40:04 +02:00
SortedArrayOf<GlyphID>
glyphArray; /* Array of GlyphIDs--in numerical order */
public:
DEFINE_SIZE_ARRAY (4, glyphArray);
};
2009-05-20 05:58:54 +02:00
struct CoverageFormat2
{
friend struct Coverage;
private:
2009-05-20 05:58:54 +02:00
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
2010-07-08 06:40:04 +02:00
int i = rangeRecord.search (glyph_id);
if (i != -1) {
const RangeRecord &range = rangeRecord[i];
return (unsigned int) range.value + (glyph_id - range.start);
}
return NOT_COVERED;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (rangeRecord.sanitize (c));
2009-08-04 06:58:28 +02:00
}
2012-04-24 04:23:17 +02:00
inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
unsigned int i;
unsigned int count = rangeRecord.len;
for (i = 0; i < count; i++) {
const RangeRecord &range = rangeRecord[i];
if (range.value <= index &&
2012-05-13 16:20:10 +02:00
index < (unsigned int) range.value + (range.end - range.start) &&
range.intersects (glyphs))
return true;
else if (index < range.value)
return false;
}
return false;
}
2012-06-09 08:02:46 +02:00
inline void add_coverage (hb_set_t *glyphs) const {
unsigned int count = rangeRecord.len;
for (unsigned int i = 0; i < count; i++)
rangeRecord[i].add_coverage (glyphs);
}
2012-04-23 19:02:14 +02:00
struct Iter {
inline void init (const CoverageFormat2 &c_) {
c = &c_;
coverage = 0;
i = 0;
j = c->rangeRecord.len ? c_.rangeRecord[0].start : 0;
}
inline bool more (void) { return i < c->rangeRecord.len; }
inline void next (void) {
coverage++;
2012-04-23 19:02:14 +02:00
if (j == c->rangeRecord[i].end) {
i++;
2012-04-23 20:21:33 +02:00
if (more ())
j = c->rangeRecord[i].start;
return;
2012-04-23 19:02:14 +02:00
}
2012-04-23 20:21:33 +02:00
j++;
}
inline uint16_t get_glyph (void) { return j; }
inline uint16_t get_coverage (void) { return coverage; }
2012-04-23 19:02:14 +02:00
private:
const struct CoverageFormat2 *c;
unsigned int i, j, coverage;
2012-04-23 19:02:14 +02:00
};
protected:
USHORT coverageFormat; /* Format identifier--format = 2 */
2010-07-08 06:40:04 +02:00
SortedArrayOf<RangeRecord>
rangeRecord; /* Array of glyph ranges--ordered by
* Start GlyphID. rangeCount entries
* long */
public:
DEFINE_SIZE_ARRAY (4, rangeRecord);
};
2009-05-20 05:58:54 +02:00
struct Coverage
{
2010-04-21 05:50:45 +02:00
inline unsigned int operator () (hb_codepoint_t glyph_id) const { return get_coverage (glyph_id); }
2009-08-04 06:58:28 +02:00
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
2009-05-20 05:58:54 +02:00
{
switch (u.format) {
2010-05-11 01:45:41 +02:00
case 1: return u.format1.get_coverage(glyph_id);
case 2: return u.format2.get_coverage(glyph_id);
default:return NOT_COVERED;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
if (!u.format.sanitize (c)) return TRACE_RETURN (false);
2009-08-04 06:58:28 +02:00
switch (u.format) {
case 1: return TRACE_RETURN (u.format1.sanitize (c));
case 2: return TRACE_RETURN (u.format2.sanitize (c));
default:return TRACE_RETURN (true);
2009-08-04 06:58:28 +02:00
}
}
2012-04-24 04:23:17 +02:00
inline bool intersects (const hb_set_t *glyphs) const {
/* TODO speed this up */
Coverage::Iter iter;
for (iter.init (*this); iter.more (); iter.next ()) {
if (glyphs->has (iter.get_glyph ()))
return true;
}
return false;
}
2012-04-24 04:23:17 +02:00
inline bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const {
switch (u.format) {
case 1: return u.format1.intersects_coverage (glyphs, index);
case 2: return u.format2.intersects_coverage (glyphs, index);
default:return false;
}
}
2012-06-09 08:02:46 +02:00
inline void add_coverage (hb_set_t *glyphs) const {
switch (u.format) {
case 1: u.format1.add_coverage (glyphs); break;
case 2: u.format2.add_coverage (glyphs); break;
default: break;
}
}
2012-04-23 19:02:14 +02:00
struct Iter {
Iter (void) : format (0) {};
inline void init (const Coverage &c_) {
2012-04-23 19:02:14 +02:00
format = c_.u.format;
switch (format) {
case 1: return u.format1.init (c_.u.format1);
case 2: return u.format2.init (c_.u.format2);
default:return;
}
}
inline bool more (void) {
2012-04-23 19:02:14 +02:00
switch (format) {
case 1: return u.format1.more ();
case 2: return u.format2.more ();
default:return true;
}
}
inline void next (void) {
2012-04-23 20:21:33 +02:00
switch (format) {
case 1: u.format1.next (); break;
case 2: u.format2.next (); break;
default: break;
}
}
inline uint16_t get_glyph (void) {
switch (format) {
case 1: return u.format1.get_glyph ();
case 2: return u.format2.get_glyph ();
default:return true;
}
}
inline uint16_t get_coverage (void) {
2012-04-23 19:02:14 +02:00
switch (format) {
case 1: return u.format1.get_coverage ();
case 2: return u.format2.get_coverage ();
2012-04-23 19:02:14 +02:00
default:return true;
}
}
private:
unsigned int format;
2012-04-23 19:02:14 +02:00
union {
CoverageFormat1::Iter format1;
CoverageFormat2::Iter format2;
} u;
};
protected:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
CoverageFormat1 format1;
CoverageFormat2 format2;
} u;
2010-05-11 00:08:46 +02:00
public:
2010-05-11 00:47:48 +02:00
DEFINE_SIZE_UNION (2, format);
};
/*
* Class Definition Table
*/
2009-05-20 05:58:54 +02:00
struct ClassDefFormat1
{
friend struct ClassDef;
private:
inline unsigned int get_class (hb_codepoint_t glyph_id) const
2009-05-20 05:58:54 +02:00
{
2012-06-09 06:26:32 +02:00
if (unlikely ((unsigned int) (glyph_id - startGlyph) < classValue.len))
return classValue[glyph_id - startGlyph];
return 0;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (c->check_struct (this) && classValue.sanitize (c));
2009-08-04 06:58:28 +02:00
}
2012-04-24 04:23:17 +02:00
inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
unsigned int count = classValue.len;
for (unsigned int i = 0; i < count; i++)
if (classValue[i] == klass && glyphs->has (startGlyph + i))
return true;
return false;
}
protected:
USHORT classFormat; /* Format identifier--format = 1 */
GlyphID startGlyph; /* First GlyphID of the classValueArray */
ArrayOf<USHORT>
classValue; /* Array of Class Values--one per GlyphID */
public:
DEFINE_SIZE_ARRAY (6, classValue);
};
2009-05-20 05:58:54 +02:00
struct ClassDefFormat2
{
friend struct ClassDef;
private:
inline unsigned int get_class (hb_codepoint_t glyph_id) const
2009-05-20 05:58:54 +02:00
{
2010-07-08 06:40:04 +02:00
int i = rangeRecord.search (glyph_id);
if (i != -1)
return rangeRecord[i].value;
return 0;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (rangeRecord.sanitize (c));
2009-08-04 06:58:28 +02:00
}
2012-04-24 04:23:17 +02:00
inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
unsigned int count = rangeRecord.len;
for (unsigned int i = 0; i < count; i++)
if (rangeRecord[i].value == klass && rangeRecord[i].intersects (glyphs))
return true;
return false;
}
protected:
USHORT classFormat; /* Format identifier--format = 2 */
2010-07-08 06:40:04 +02:00
SortedArrayOf<RangeRecord>
rangeRecord; /* Array of glyph ranges--ordered by
* Start GlyphID */
public:
DEFINE_SIZE_ARRAY (4, rangeRecord);
};
2009-05-20 05:58:54 +02:00
struct ClassDef
{
inline unsigned int operator () (hb_codepoint_t glyph_id) const { return get_class (glyph_id); }
2009-08-04 06:58:28 +02:00
inline unsigned int get_class (hb_codepoint_t glyph_id) const
2009-05-20 05:58:54 +02:00
{
switch (u.format) {
2010-05-11 01:45:41 +02:00
case 1: return u.format1.get_class(glyph_id);
case 2: return u.format2.get_class(glyph_id);
default:return 0;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
if (!u.format.sanitize (c)) return TRACE_RETURN (false);
2009-08-04 06:58:28 +02:00
switch (u.format) {
case 1: return TRACE_RETURN (u.format1.sanitize (c));
case 2: return TRACE_RETURN (u.format2.sanitize (c));
default:return TRACE_RETURN (true);
2009-08-04 06:58:28 +02:00
}
}
2012-04-24 04:23:17 +02:00
inline bool intersects_class (const hb_set_t *glyphs, unsigned int klass) const {
switch (u.format) {
case 1: return u.format1.intersects_class (glyphs, klass);
case 2: return u.format2.intersects_class (glyphs, klass);
default:return false;
}
}
protected:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
ClassDefFormat1 format1;
ClassDefFormat2 format2;
} u;
2010-05-11 00:08:46 +02:00
public:
2010-05-11 00:47:48 +02:00
DEFINE_SIZE_UNION (2, format);
};
/*
* Device Tables
*/
2009-05-20 05:58:54 +02:00
struct Device
{
2010-05-20 18:44:52 +02:00
inline hb_position_t get_x_delta (hb_font_t *font) const
{ return get_delta (font->x_ppem, font->x_scale); }
2010-05-20 18:44:52 +02:00
inline hb_position_t get_y_delta (hb_font_t *font) const
{ return get_delta (font->y_ppem, font->y_scale); }
2010-05-20 18:44:52 +02:00
inline int get_delta (unsigned int ppem, int scale) const
{
if (!ppem) return 0;
int pixels = get_delta_pixels (ppem);
if (!pixels) return 0;
return pixels * (int64_t) scale / ppem;
}
inline int get_delta_pixels (unsigned int ppem_size) const
2009-05-20 05:58:54 +02:00
{
unsigned int f = deltaFormat;
if (unlikely (f < 1 || f > 3))
return 0;
if (ppem_size < startSize || ppem_size > endSize)
return 0;
unsigned int s = ppem_size - startSize;
unsigned int byte = deltaValue[s >> (4 - f)];
2009-05-27 01:48:16 +02:00
unsigned int bits = (byte >> (16 - (((s & ((1 << (4 - f)) - 1)) + 1) << f)));
unsigned int mask = (0xFFFF >> (16 - (1 << f)));
int delta = bits & mask;
2009-08-04 19:57:41 +02:00
if ((unsigned int) delta >= ((mask + 1) >> 1))
delta -= mask + 1;
return delta;
}
2010-10-02 00:58:50 +02:00
inline unsigned int get_size (void) const
2009-08-04 18:26:26 +02:00
{
unsigned int f = deltaFormat;
2010-05-11 00:20:54 +02:00
if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
2009-08-04 18:26:26 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
return TRACE_RETURN (c->check_struct (this) && c->check_range (this, this->get_size ()));
2009-08-04 18:26:26 +02:00
}
protected:
2010-04-22 06:23:14 +02:00
USHORT startSize; /* Smallest size to correct--in ppem */
USHORT endSize; /* Largest size to correct--in ppem */
2010-04-26 16:07:35 +02:00
USHORT deltaFormat; /* Format of DeltaValue array data: 1, 2, or 3
* 1 Signed 2-bit value, 8 values per uint16
* 2 Signed 4-bit value, 4 values per uint16
* 3 Signed 8-bit value, 2 values per uint16
*/
USHORT deltaValue[VAR]; /* Array of compressed data */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (6, deltaValue);
};
2010-07-23 21:11:18 +02:00
#endif /* HB_OT_LAYOUT_COMMON_PRIVATE_HH */