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

1589 lines
45 KiB
C++
Raw Normal View History

2009-05-18 23:09:33 +02:00
/*
2010-05-06 18:55:14 +02:00
* Copyright (C) 2007,2008,2009,2010 Red Hat, Inc.
* Copyright (C) 2010 Google, Inc.
2009-05-18 23:09:33 +02:00
*
2010-04-22 06:11:43 +02:00
* This is part of HarfBuzz, a text shaping library.
2009-05-18 23:09:33 +02:00
*
* 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
2009-05-18 23:09:33 +02:00
*/
#ifndef HB_OT_LAYOUT_GPOS_PRIVATE_HH
#define HB_OT_LAYOUT_GPOS_PRIVATE_HH
2009-05-18 23:09:33 +02:00
#include "hb-ot-layout-gsubgpos-private.hh"
2009-05-18 23:09:33 +02:00
2010-07-23 21:11:18 +02:00
HB_BEGIN_DECLS
2010-05-05 07:13:09 +02:00
2010-10-28 05:09:10 +02:00
/* buffer var allocations */
#define attach_lookback() var.u16[0] /* number of glyphs to go back to attach this glyph to its base */
#define cursive_chain() var.i16[1] /* character to which this connects, may be positive or negative */
2009-05-18 23:09:33 +02:00
/* Shared Tables: ValueRecord, Anchor Table, and MarkArray */
2010-05-06 19:06:15 +02:00
typedef USHORT Value;
typedef Value ValueRecord[VAR];
2009-05-18 23:09:33 +02:00
2009-05-20 05:42:30 +02:00
struct ValueFormat : USHORT
{
enum
{
xPlacement = 0x0001, /* Includes horizontal adjustment for placement */
yPlacement = 0x0002, /* Includes vertical adjustment for placement */
xAdvance = 0x0004, /* Includes horizontal adjustment for advance */
yAdvance = 0x0008, /* Includes vertical adjustment for advance */
xPlaDevice = 0x0010, /* Includes horizontal Device table for placement */
yPlaDevice = 0x0020, /* Includes vertical Device table for placement */
xAdvDevice = 0x0040, /* Includes horizontal Device table for advance */
yAdvDevice = 0x0080, /* Includes vertical Device table for advance */
ignored = 0x0F00, /* Was used in TrueType Open for MM fonts */
reserved = 0xF000, /* For future use */
devices = 0x00F0 /* Mask for having any Device table */
2010-04-21 08:02:57 +02:00
};
2010-04-21 08:02:57 +02:00
/* All fields are options. Only those available advance the value pointer. */
#if 0
SHORT xPlacement; /* Horizontal adjustment for
* placement--in design units */
SHORT yPlacement; /* Vertical adjustment for
* placement--in design units */
SHORT xAdvance; /* Horizontal adjustment for
* advance--in design units (only used
* for horizontal writing) */
SHORT yAdvance; /* Vertical adjustment for advance--in
* design units (only used for vertical
* writing) */
Offset xPlaDevice; /* Offset to Device table for
* horizontal placement--measured from
* beginning of PosTable (may be NULL) */
Offset yPlaDevice; /* Offset to Device table for vertical
* placement--measured from beginning
* of PosTable (may be NULL) */
Offset xAdvDevice; /* Offset to Device table for
* horizontal advance--measured from
* beginning of PosTable (may be NULL) */
Offset yAdvDevice; /* Offset to Device table for vertical
* advance--measured from beginning of
* PosTable (may be NULL) */
#endif
2010-10-02 00:58:50 +02:00
inline unsigned int get_len (void) const
2010-04-21 08:02:57 +02:00
{ return _hb_popcount32 ((unsigned int) *this); }
2010-10-02 00:58:50 +02:00
inline unsigned int get_size (void) const
{ return get_len () * Value::static_size; }
2010-04-21 08:02:57 +02:00
void apply_value (hb_ot_layout_context_t *layout,
const void *base,
const Value *values,
hb_glyph_position_t &glyph_pos) const
2010-04-21 08:02:57 +02:00
{
unsigned int x_ppem, y_ppem;
unsigned int format = *this;
if (!format) return;
/* design units -> fractional pixel */
if (format & xPlacement) glyph_pos.x_offset += layout->scale_x (get_short (values++));
if (format & yPlacement) glyph_pos.y_offset += layout->scale_y (get_short (values++));
if (format & xAdvance) glyph_pos.x_advance += layout->scale_x (get_short (values++));
if (format & yAdvance) glyph_pos.y_advance += layout->scale_y (get_short (values++));
2010-04-29 20:31:56 +02:00
if (!has_device ()) return;
2010-05-05 07:01:05 +02:00
x_ppem = layout->font->x_ppem;
y_ppem = layout->font->y_ppem;
2010-04-29 20:31:56 +02:00
if (!x_ppem && !y_ppem) return;
/* pixel -> fractional pixel */
if (format & xPlaDevice) {
2010-05-20 18:44:52 +02:00
if (x_ppem) glyph_pos.x_offset += (base + get_device (values++)).get_x_delta (layout); else values++;
}
if (format & yPlaDevice) {
2010-05-20 18:44:52 +02:00
if (y_ppem) glyph_pos.y_offset += (base + get_device (values++)).get_y_delta (layout); else values++;
}
if (format & xAdvDevice) {
2010-05-20 18:44:52 +02:00
if (x_ppem) glyph_pos.x_advance += (base + get_device (values++)).get_x_delta (layout); else values++;
}
if (format & yAdvDevice) {
2010-05-20 18:44:52 +02:00
if (y_ppem) glyph_pos.y_advance += (base + get_device (values++)).get_y_delta (layout); else values++;
}
}
2010-04-21 08:02:57 +02:00
private:
2010-05-13 20:18:49 +02:00
inline bool sanitize_value_devices (hb_sanitize_context_t *c, void *base, Value *values) {
2010-04-21 08:02:57 +02:00
unsigned int format = *this;
if (format & xPlacement) values++;
if (format & yPlacement) values++;
if (format & xAdvance) values++;
if (format & yAdvance) values++;
2010-05-13 20:18:49 +02:00
if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
2010-04-21 08:02:57 +02:00
return true;
}
2010-05-06 19:06:15 +02:00
static inline OffsetTo<Device>& get_device (Value* value)
{ return *CastP<OffsetTo<Device> > (value); }
static inline const OffsetTo<Device>& get_device (const Value* value)
{ return *CastP<OffsetTo<Device> > (value); }
static inline const SHORT& get_short (const Value* value)
{ return *CastP<SHORT> (value); }
2010-04-21 08:02:57 +02:00
public:
2010-10-02 00:58:50 +02:00
inline bool has_device (void) const {
2010-04-21 08:02:57 +02:00
unsigned int format = *this;
return (format & devices) != 0;
}
2010-05-13 20:18:49 +02:00
inline bool sanitize_value (hb_sanitize_context_t *c, void *base, Value *values) {
2010-04-21 08:02:57 +02:00
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_range (values, get_size ())
&& (!has_device () || sanitize_value_devices (c, base, values));
2010-04-21 08:02:57 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize_values (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count) {
2010-04-21 08:02:57 +02:00
TRACE_SANITIZE ();
unsigned int len = get_len ();
2010-05-13 20:18:49 +02:00
if (!c->check_array (values, get_size (), count)) return false;
2010-04-21 08:02:57 +02:00
if (!has_device ()) return true;
for (unsigned int i = 0; i < count; i++) {
2010-05-13 20:18:49 +02:00
if (!sanitize_value_devices (c, base, values))
2010-04-21 08:02:57 +02:00
return false;
values += len;
}
return true;
}
/* Just sanitize referenced Device tables. Doesn't check the values themselves. */
2010-05-13 20:18:49 +02:00
inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, void *base, Value *values, unsigned int count, unsigned int stride) {
2010-04-21 08:02:57 +02:00
TRACE_SANITIZE ();
if (!has_device ()) return true;
for (unsigned int i = 0; i < count; i++) {
2010-05-13 20:18:49 +02:00
if (!sanitize_value_devices (c, base, values))
2010-04-21 08:02:57 +02:00
return false;
values += stride;
}
return true;
}
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct AnchorFormat1
{
2009-05-18 23:09:33 +02:00
friend struct Anchor;
private:
2010-05-05 07:01:05 +02:00
inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id HB_UNUSED,
2009-05-20 04:16:04 +02:00
hb_position_t *x, hb_position_t *y) const
{
*x = layout->scale_x (xCoordinate);
*y = layout->scale_y (yCoordinate);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
SHORT xCoordinate; /* Horizontal value--in design units */
SHORT yCoordinate; /* Vertical value--in design units */
public:
DEFINE_SIZE_STATIC (6);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct AnchorFormat2
{
2009-05-18 23:09:33 +02:00
friend struct Anchor;
private:
2010-05-05 07:01:05 +02:00
inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id,
2009-05-20 04:16:04 +02:00
hb_position_t *x, hb_position_t *y) const
{
2010-05-05 07:01:05 +02:00
unsigned int x_ppem = layout->font->x_ppem;
unsigned int y_ppem = layout->font->y_ppem;
2010-04-29 09:59:06 +02:00
hb_position_t cx, cy;
2010-11-03 20:40:07 +01:00
hb_bool_t ret = false;
2010-04-29 09:59:06 +02:00
if (x_ppem || y_ppem)
2010-05-05 07:01:05 +02:00
ret = hb_font_get_contour_point (layout->font, layout->face, anchorPoint, glyph_id, &cx, &cy);
*x = x_ppem && ret ? cx : layout->scale_x (xCoordinate);
*y = y_ppem && ret ? cy : layout->scale_y (yCoordinate);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 2 */
SHORT xCoordinate; /* Horizontal value--in design units */
SHORT yCoordinate; /* Vertical value--in design units */
USHORT anchorPoint; /* Index to glyph contour point */
public:
DEFINE_SIZE_STATIC (8);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct AnchorFormat3
{
2009-05-18 23:09:33 +02:00
friend struct Anchor;
private:
2010-05-05 07:01:05 +02:00
inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id HB_UNUSED,
2009-05-20 04:16:04 +02:00
hb_position_t *x, hb_position_t *y) const
{
*x = layout->scale_x (xCoordinate);
*y = layout->scale_y (yCoordinate);
/* pixel -> fractional pixel */
2010-05-05 07:01:05 +02:00
if (layout->font->x_ppem)
2010-05-20 18:44:52 +02:00
*x += (this+xDeviceTable).get_x_delta (layout);
2010-05-05 07:01:05 +02:00
if (layout->font->y_ppem)
2010-05-20 18:44:52 +02:00
*y += (this+yDeviceTable).get_x_delta (layout);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& xDeviceTable.sanitize (c, this)
&& yDeviceTable.sanitize (c, this);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 3 */
SHORT xCoordinate; /* Horizontal value--in design units */
SHORT yCoordinate; /* Vertical value--in design units */
OffsetTo<Device>
xDeviceTable; /* Offset to Device table for X
* coordinate-- from beginning of
* Anchor table (may be NULL) */
OffsetTo<Device>
yDeviceTable; /* Offset to Device table for Y
* coordinate-- from beginning of
* Anchor table (may be NULL) */
public:
DEFINE_SIZE_STATIC (10);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct Anchor
{
2010-05-05 07:01:05 +02:00
inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id,
2009-05-20 04:16:04 +02:00
hb_position_t *x, hb_position_t *y) const
{
2009-05-18 23:09:33 +02:00
*x = *y = 0;
switch (u.format) {
2010-05-11 01:45:41 +02:00
case 1: u.format1.get_anchor (layout, glyph_id, x, y); return;
case 2: u.format2.get_anchor (layout, glyph_id, x, y); return;
case 3: u.format3.get_anchor (layout, glyph_id, x, y); return;
2010-05-05 07:01:05 +02:00
default: return;
2009-05-18 23:09:33 +02:00
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
case 2: return u.format2.sanitize (c);
case 3: return u.format3.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
AnchorFormat1 format1;
AnchorFormat2 format2;
AnchorFormat3 format3;
2009-05-18 23:09:33 +02:00
} u;
2010-05-11 00:08:46 +02:00
public:
2010-05-11 00:47:48 +02:00
DEFINE_SIZE_UNION (2, format);
2009-05-18 23:09:33 +02:00
};
2009-08-15 00:14:03 +02:00
struct AnchorMatrix
{
inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols) const {
if (unlikely (row >= rows || col >= cols)) return Null(Anchor);
2009-08-15 00:14:03 +02:00
return this+matrix[row * cols + col];
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!c->check_struct (this)) return false;
if (unlikely (rows > 0 && cols >= ((unsigned int) -1) / rows)) return false;
2009-08-15 00:14:03 +02:00
unsigned int count = rows * cols;
2010-05-13 20:18:49 +02:00
if (!c->check_array (matrix, matrix[0].static_size, count)) return false;
2009-08-15 00:14:03 +02:00
for (unsigned int i = 0; i < count; i++)
2010-05-13 20:18:49 +02:00
if (!matrix[i].sanitize (c, this)) return false;
2009-08-15 00:14:03 +02:00
return true;
}
USHORT rows; /* Number of rows */
private:
OffsetTo<Anchor>
matrix[VAR]; /* Matrix of offsets to Anchor tables--
2009-08-15 00:14:03 +02:00
* from beginning of AnchorMatrix table */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (2, matrix);
2009-08-15 00:14:03 +02:00
};
2009-05-20 05:42:30 +02:00
struct MarkRecord
{
2009-05-21 10:58:24 +02:00
friend struct MarkArray;
2009-05-18 23:09:33 +02:00
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c, void *base) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& markAnchor.sanitize (c, base);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT klass; /* Class defined for this mark */
OffsetTo<Anchor>
markAnchor; /* Offset to Anchor table--from
* beginning of MarkArray table */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_STATIC (4);
2009-05-18 23:09:33 +02:00
};
2010-05-10 23:28:16 +02:00
struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage order */
2009-05-20 05:42:30 +02:00
{
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c,
unsigned int mark_index, unsigned int glyph_index,
const AnchorMatrix &anchors, unsigned int class_count,
unsigned int glyph_pos) const
{
TRACE_APPLY ();
2010-05-10 23:28:16 +02:00
const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);
unsigned int mark_class = record.klass;
const Anchor& mark_anchor = this + record.markAnchor;
const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count);
hb_position_t mark_x, mark_y, base_x, base_y;
mark_anchor.get_anchor (c->layout, c->buffer->info[c->buffer->i].codepoint, &mark_x, &mark_y);
glyph_anchor.get_anchor (c->layout, c->buffer->info[glyph_pos].codepoint, &base_x, &base_y);
hb_glyph_position_t &o = c->buffer->pos[c->buffer->i];
2010-10-28 05:09:10 +02:00
o.x_offset = base_x - mark_x;
o.y_offset = base_y - mark_y;
o.attach_lookback() = c->buffer->i - glyph_pos;
c->buffer->i++;
return true;
}
2009-05-18 23:09:33 +02:00
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return ArrayOf<MarkRecord>::sanitize (c, this);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
};
/* Lookups */
2009-05-20 05:42:30 +02:00
struct SinglePosFormat1
{
2009-05-18 23:09:33 +02:00
friend struct SinglePos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 04:16:04 +02:00
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (index == NOT_COVERED))
return false;
valueFormat.apply_value (c->layout, this, values, c->buffer->pos[c->buffer->i]);
c->buffer->i++;
return true;
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& coverage.sanitize (c, this)
&& valueFormat.sanitize_value (c, this, values);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat; /* Defines the types of data in the
2009-05-18 23:09:33 +02:00
* ValueRecord */
ValueRecord values; /* Defines positioning
* value(s)--applied to all glyphs in
* the Coverage table */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (6, values);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct SinglePosFormat2
{
2009-05-18 23:09:33 +02:00
friend struct SinglePos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 04:16:04 +02:00
{
TRACE_APPLY ();
unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (index == NOT_COVERED))
return false;
if (likely (index >= valueCount))
return false;
2010-05-13 20:18:49 +02:00
valueFormat.apply_value (c->layout, this,
&values[index * valueFormat.get_len ()],
c->buffer->pos[c->buffer->i]);
c->buffer->i++;
return true;
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& coverage.sanitize (c, this)
&& valueFormat.sanitize_values (c, this, values, valueCount);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 2 */
OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat; /* Defines the types of data in the
2009-05-18 23:09:33 +02:00
* ValueRecord */
USHORT valueCount; /* Number of ValueRecords */
ValueRecord values; /* Array of ValueRecords--positioning
* values applied to glyphs */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (8, values);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct SinglePos
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 04:16:04 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.apply (c);
case 2: return u.format2.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
case 2: return u.format2.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
SinglePosFormat1 format1;
SinglePosFormat2 format2;
2009-05-18 23:09:33 +02:00
} u;
};
2009-05-20 05:42:30 +02:00
struct PairValueRecord
{
2010-05-11 06:23:50 +02:00
friend struct PairSet;
2009-05-18 23:09:33 +02:00
private:
GlyphID secondGlyph; /* GlyphID of second glyph in the
* pair--first glyph is listed in the
* Coverage table */
ValueRecord values; /* Positioning data for the first glyph
* followed by for second glyph */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (2, values);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct PairSet
{
2009-05-20 04:16:04 +02:00
friend struct PairPosFormat1;
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c,
2010-05-11 06:23:50 +02:00
const ValueFormat *valueFormats,
unsigned int pos) const
{
TRACE_APPLY ();
unsigned int len1 = valueFormats[0].get_len ();
unsigned int len2 = valueFormats[1].get_len ();
unsigned int record_size = USHORT::static_size * (1 + len1 + len2);
unsigned int count = len;
const PairValueRecord *record = CastP<PairValueRecord> (array);
for (unsigned int i = 0; i < count; i++)
{
if (c->buffer->info[pos].codepoint == record->secondGlyph)
2010-05-11 06:23:50 +02:00
{
valueFormats[0].apply_value (c->layout, this, &record->values[0], c->buffer->pos[c->buffer->i]);
valueFormats[1].apply_value (c->layout, this, &record->values[len1], c->buffer->pos[pos]);
2010-05-11 06:23:50 +02:00
if (len2)
pos++;
c->buffer->i = pos;
2010-05-11 06:23:50 +02:00
return true;
}
record = &StructAtOffset<PairValueRecord> (record, record_size);
}
return false;
}
struct sanitize_closure_t {
void *base;
ValueFormat *valueFormats;
unsigned int len1; /* valueFormats[0].get_len() */
unsigned int stride; /* 1 + len1 + len2 */
};
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!(c->check_struct (this)
&& c->check_array (array, USHORT::static_size * closure->stride, len))) return false;
2010-05-11 06:23:50 +02:00
unsigned int count = len;
PairValueRecord *record = CastP<PairValueRecord> (array);
2010-05-13 20:18:49 +02:00
return closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride)
&& closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride);
2009-08-04 19:30:49 +02:00
}
2009-05-20 04:16:04 +02:00
private:
USHORT len; /* Number of PairValueRecords */
USHORT array[VAR]; /* Array of PairValueRecords--ordered
2009-05-20 04:16:04 +02:00
* by GlyphID of the second glyph */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (2, array);
2009-05-20 04:16:04 +02:00
};
2009-05-18 23:09:33 +02:00
2009-05-20 05:42:30 +02:00
struct PairPosFormat1
{
2009-05-18 23:09:33 +02:00
friend struct PairPos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 04:16:04 +02:00
{
TRACE_APPLY ();
unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
if (unlikely (c->buffer->i + 2 > end))
2009-05-20 04:16:04 +02:00
return false;
unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (index == NOT_COVERED))
2009-05-20 04:16:04 +02:00
return false;
unsigned int j = c->buffer->i + 1;
while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
2009-05-20 05:42:30 +02:00
{
if (unlikely (j == end))
2009-05-20 04:16:04 +02:00
return false;
j++;
}
2010-05-13 20:18:49 +02:00
return (this+pairSet[index]).apply (c, &valueFormat1, j);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
unsigned int len1 = valueFormat1.get_len ();
unsigned int len2 = valueFormat2.get_len ();
2010-05-11 06:23:50 +02:00
PairSet::sanitize_closure_t closure = {
this,
&valueFormat1,
len1,
1 + len1 + len2
};
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& coverage.sanitize (c, this)
&& pairSet.sanitize (c, this, &closure);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat1; /* Defines the types of data in
2009-05-18 23:09:33 +02:00
* ValueRecord1--for the first glyph
* in the pair--may be zero (0) */
ValueFormat valueFormat2; /* Defines the types of data in
2009-05-18 23:09:33 +02:00
* ValueRecord2--for the second glyph
* in the pair--may be zero (0) */
OffsetArrayOf<PairSet>
pairSet; /* Array of PairSet tables
* ordered by Coverage Index */
public:
DEFINE_SIZE_ARRAY (10, pairSet);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct PairPosFormat2
{
2009-05-18 23:09:33 +02:00
friend struct PairPos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 04:30:09 +02:00
{
TRACE_APPLY ();
unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
if (unlikely (c->buffer->i + 2 > end))
2009-05-20 04:30:09 +02:00
return false;
unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (index == NOT_COVERED))
2009-05-20 04:30:09 +02:00
return false;
unsigned int j = c->buffer->i + 1;
while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
2009-05-20 05:42:30 +02:00
{
if (unlikely (j == end))
2009-05-20 04:30:09 +02:00
return false;
j++;
}
unsigned int len1 = valueFormat1.get_len ();
unsigned int len2 = valueFormat2.get_len ();
unsigned int record_len = len1 + len2;
unsigned int klass1 = (this+classDef1) (c->buffer->info[c->buffer->i].codepoint);
unsigned int klass2 = (this+classDef2) (c->buffer->info[j].codepoint);
if (unlikely (klass1 >= class1Count || klass2 >= class2Count))
2009-05-20 04:30:09 +02:00
return false;
const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
valueFormat1.apply_value (c->layout, this, v, c->buffer->pos[c->buffer->i]);
valueFormat2.apply_value (c->layout, this, v + len1, c->buffer->pos[j]);
2009-05-20 04:30:09 +02:00
if (len2)
j++;
c->buffer->i = j;
2009-05-20 04:30:09 +02:00
return true;
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!(c->check_struct (this)
&& coverage.sanitize (c, this)
&& classDef1.sanitize (c, this)
&& classDef2.sanitize (c, this))) return false;
unsigned int len1 = valueFormat1.get_len ();
unsigned int len2 = valueFormat2.get_len ();
unsigned int stride = len1 + len2;
unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
2010-05-13 20:18:49 +02:00
return c->check_array (values, record_size, count) &&
valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride);
2009-08-04 19:30:49 +02:00
}
2009-05-20 04:30:09 +02:00
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 2 */
OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat1; /* ValueRecord definition--for the
2009-05-18 23:09:33 +02:00
* first glyph of the pair--may be zero
* (0) */
ValueFormat valueFormat2; /* ValueRecord definition--for the
2009-05-18 23:09:33 +02:00
* second glyph of the pair--may be
* zero (0) */
OffsetTo<ClassDef>
classDef1; /* Offset to ClassDef table--from
* beginning of PairPos subtable--for
* the first glyph of the pair */
OffsetTo<ClassDef>
classDef2; /* Offset to ClassDef table--from
* beginning of PairPos subtable--for
* the second glyph of the pair */
USHORT class1Count; /* Number of classes in ClassDef1
* table--includes Class0 */
USHORT class2Count; /* Number of classes in ClassDef2
* table--includes Class0 */
ValueRecord values; /* Matrix of value pairs:
* class1-major, class2-minor,
* Each entry has value1 and value2 */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_ARRAY (16, values);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct PairPos
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.apply (c);
case 2: return u.format2.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
case 2: return u.format2.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
PairPosFormat1 format1;
PairPosFormat2 format2;
2009-05-18 23:09:33 +02:00
} u;
};
2009-05-20 05:42:30 +02:00
struct EntryExitRecord
{
2010-05-10 22:38:32 +02:00
friend struct CursivePosFormat1;
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c, void *base) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return entryAnchor.sanitize (c, base)
&& exitAnchor.sanitize (c, base);
2009-08-04 19:30:49 +02:00
}
2010-05-10 22:38:32 +02:00
private:
2009-05-18 23:09:33 +02:00
OffsetTo<Anchor>
entryAnchor; /* Offset to EntryAnchor table--from
* beginning of CursivePos
* subtable--may be NULL */
OffsetTo<Anchor>
exitAnchor; /* Offset to ExitAnchor table--from
* beginning of CursivePos
* subtable--may be NULL */
2010-05-10 22:38:32 +02:00
public:
DEFINE_SIZE_STATIC (4);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct CursivePosFormat1
{
2009-05-18 23:09:33 +02:00
friend struct CursivePos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:25:41 +02:00
{
TRACE_APPLY ();
2009-05-20 10:16:35 +02:00
/* We don't handle mark glyphs here. */
if (c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK)
2009-05-20 10:16:35 +02:00
return false;
unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length);
if (unlikely (c->buffer->i + 2 > end))
2009-05-20 10:16:35 +02:00
return false;
const EntryExitRecord &this_record = entryExitRecord[(this+coverage) (c->buffer->info[c->buffer->i].codepoint)];
if (!this_record.exitAnchor)
return false;
unsigned int j = c->buffer->i + 1;
while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, NULL))
{
if (unlikely (j == end))
return false;
j++;
}
const EntryExitRecord &next_record = entryExitRecord[(this+coverage) (c->buffer->info[j].codepoint)];
if (!next_record.entryAnchor)
return false;
2009-05-20 05:25:41 +02:00
unsigned int i = c->buffer->i;
2009-05-20 05:25:41 +02:00
hb_position_t entry_x, entry_y, exit_x, exit_y;
(this+this_record.exitAnchor).get_anchor (c->layout, c->buffer->info[i].codepoint, &exit_x, &exit_y);
(this+next_record.entryAnchor).get_anchor (c->layout, c->buffer->info[j].codepoint, &entry_x, &entry_y);
2009-05-20 05:25:41 +02:00
hb_direction_t direction = c->buffer->props.direction;
2009-05-27 06:17:37 +02:00
/* Align the exit anchor of the left/top glyph with the entry anchor of the right/bottom glyph
* by adjusting advance of the left/top glyph. */
if (HB_DIRECTION_IS_BACKWARD (direction))
2009-05-20 05:25:41 +02:00
{
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
c->buffer->pos[j].x_advance = c->buffer->pos[j].x_offset + entry_x - exit_x;
else
c->buffer->pos[j].y_advance = c->buffer->pos[j].y_offset + entry_y - exit_y;
2009-05-20 05:25:41 +02:00
}
else
{
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
c->buffer->pos[i].x_advance = c->buffer->pos[i].x_offset + exit_x - entry_x;
else
c->buffer->pos[i].y_advance = c->buffer->pos[i].y_offset + exit_y - entry_y;
2009-05-20 05:25:41 +02:00
}
if (c->lookup_props & LookupFlag::RightToLeft)
2009-05-20 05:25:41 +02:00
{
c->buffer->pos[i].cursive_chain() = j - i;
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
c->buffer->pos[i].y_offset = entry_y - exit_y;
else
c->buffer->pos[i].x_offset = entry_x - exit_x;
2009-05-20 05:25:41 +02:00
}
else
{
c->buffer->pos[j].cursive_chain() = i - j;
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
c->buffer->pos[j].y_offset = exit_y - entry_y;
else
c->buffer->pos[j].x_offset = exit_x - entry_x;
2009-05-20 05:25:41 +02:00
}
c->buffer->i = j;
2009-05-20 05:25:41 +02:00
return true;
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return coverage.sanitize (c, this)
&& entryExitRecord.sanitize (c, this);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ArrayOf<EntryExitRecord>
entryExitRecord; /* Array of EntryExit records--in
* Coverage Index order */
public:
DEFINE_SIZE_ARRAY (6, entryExitRecord);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct CursivePos
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
CursivePosFormat1 format1;
2009-05-18 23:09:33 +02:00
} u;
};
2009-08-15 00:14:03 +02:00
typedef AnchorMatrix BaseArray; /* base-major--
* in order of BaseCoverage Index--,
* mark-minor--
2009-05-21 10:47:05 +02:00
* ordered by class--zero-based. */
2009-05-18 23:09:33 +02:00
2009-05-20 05:42:30 +02:00
struct MarkBasePosFormat1
{
2009-05-18 23:09:33 +02:00
friend struct MarkBasePos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (mark_index == NOT_COVERED))
2009-05-21 12:32:01 +02:00
return false;
/* now we search backwards for a non-mark glyph */
unsigned int property;
unsigned int j = c->buffer->i;
do
2009-05-21 12:32:01 +02:00
{
if (unlikely (!j))
2009-05-26 23:58:37 +02:00
return false;
2009-08-15 01:37:18 +02:00
j--;
} while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], LookupFlag::IgnoreMarks, &property));
/* The following assertion is too strong, so we've disabled it. */
2010-11-03 16:50:21 +01:00
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH))
{/*return false;*/}
2009-05-21 12:32:01 +02:00
unsigned int base_index = (this+baseCoverage) (c->buffer->info[j].codepoint);
if (base_index == NOT_COVERED)
2009-05-21 12:32:01 +02:00
return false;
2010-05-13 20:18:49 +02:00
return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, j);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& markCoverage.sanitize (c, this)
&& baseCoverage.sanitize (c, this)
&& markArray.sanitize (c, this)
&& baseArray.sanitize (c, this, (unsigned int) classCount);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
2009-05-21 10:47:05 +02:00
OffsetTo<Coverage>
markCoverage; /* Offset to MarkCoverage table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkBasePos subtable */
2009-05-21 10:47:05 +02:00
OffsetTo<Coverage>
baseCoverage; /* Offset to BaseCoverage table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkBasePos subtable */
USHORT classCount; /* Number of classes defined for marks */
2009-05-21 10:47:05 +02:00
OffsetTo<MarkArray>
markArray; /* Offset to MarkArray table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkBasePos subtable */
2009-05-21 10:47:05 +02:00
OffsetTo<BaseArray>
baseArray; /* Offset to BaseArray table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkBasePos subtable */
public:
DEFINE_SIZE_STATIC (12);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct MarkBasePos
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
MarkBasePosFormat1 format1;
2009-05-18 23:09:33 +02:00
} u;
};
2009-08-15 00:14:03 +02:00
typedef AnchorMatrix LigatureAttach; /* component-major--
* in order of writing direction--,
* mark-minor--
* ordered by class--zero-based. */
2009-05-18 23:09:33 +02:00
2009-08-15 00:32:56 +02:00
typedef OffsetListOf<LigatureAttach> LigatureArray;
/* Array of LigatureAttach
2009-05-18 23:09:33 +02:00
* tables ordered by
* LigatureCoverage Index */
2009-05-20 05:42:30 +02:00
struct MarkLigPosFormat1
{
2009-05-18 23:09:33 +02:00
friend struct MarkLigPos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (mark_index == NOT_COVERED))
return false;
/* now we search backwards for a non-mark glyph */
unsigned int property;
unsigned int j = c->buffer->i;
do
{
if (unlikely (!j))
2009-05-26 23:58:37 +02:00
return false;
2009-08-15 01:37:18 +02:00
j--;
} while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], LookupFlag::IgnoreMarks, &property));
/* The following assertion is too strong, so we've disabled it. */
2010-11-03 16:50:21 +01:00
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE))
{/*return false;*/}
unsigned int lig_index = (this+ligatureCoverage) (c->buffer->info[j].codepoint);
if (lig_index == NOT_COVERED)
return false;
const LigatureArray& lig_array = this+ligatureArray;
2009-08-15 00:32:56 +02:00
const LigatureAttach& lig_attach = lig_array[lig_index];
2009-08-15 00:14:03 +02:00
/* Find component to attach to */
2009-08-15 01:37:18 +02:00
unsigned int comp_count = lig_attach.rows;
if (unlikely (!comp_count))
return false;
unsigned int comp_index;
/* We must now check whether the ligature ID of the current mark glyph
* is identical to the ligature ID of the found ligature. If yes, we
* can directly use the component index. If not, we attach the mark
* glyph to the last component of the ligature. */
2010-10-28 05:18:51 +02:00
if (c->buffer->info[j].lig_id() && c->buffer->info[j].lig_id() == c->buffer->info[c->buffer->i].lig_id() && c->buffer->info[c->buffer->i].lig_comp())
{
2010-10-28 05:18:51 +02:00
comp_index = c->buffer->info[c->buffer->i].lig_comp() - 1;
2009-08-15 01:37:18 +02:00
if (comp_index >= comp_count)
comp_index = comp_count - 1;
}
else
2009-08-15 01:37:18 +02:00
comp_index = comp_count - 1;
2010-05-13 20:18:49 +02:00
return (this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& markCoverage.sanitize (c, this)
&& ligatureCoverage.sanitize (c, this)
&& markArray.sanitize (c, this)
&& ligatureArray.sanitize (c, this, (unsigned int) classCount);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
OffsetTo<Coverage>
markCoverage; /* Offset to Mark Coverage table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkLigPos subtable */
OffsetTo<Coverage>
ligatureCoverage; /* Offset to Ligature Coverage
2009-05-18 23:09:33 +02:00
* table--from beginning of MarkLigPos
* subtable */
USHORT classCount; /* Number of defined mark classes */
OffsetTo<MarkArray>
markArray; /* Offset to MarkArray table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkLigPos subtable */
OffsetTo<LigatureArray>
ligatureArray; /* Offset to LigatureArray table--from
2009-05-18 23:09:33 +02:00
* beginning of MarkLigPos subtable */
public:
DEFINE_SIZE_STATIC (12);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct MarkLigPos
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
MarkLigPosFormat1 format1;
2009-05-18 23:09:33 +02:00
} u;
};
2009-08-15 00:14:03 +02:00
typedef AnchorMatrix Mark2Array; /* mark2-major--
* in order of Mark2Coverage Index--,
* mark1-minor--
* ordered by class--zero-based. */
2009-05-18 23:09:33 +02:00
2009-05-20 05:42:30 +02:00
struct MarkMarkPosFormat1
{
2009-05-18 23:09:33 +02:00
friend struct MarkMarkPos;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->i].codepoint);
if (likely (mark1_index == NOT_COVERED))
return false;
/* now we search backwards for a suitable mark glyph until a non-mark glyph */
unsigned int property;
unsigned int j = c->buffer->i;
do
{
if (unlikely (!j))
2009-05-26 23:58:37 +02:00
return false;
2009-08-15 01:37:18 +02:00
j--;
} while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, &property));
2009-05-26 23:58:37 +02:00
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK))
return false;
/* Two marks match only if they belong to the same base, or same component
* of the same ligature. That is, the component numbers must match, and
* if those are non-zero, the ligid number should also match. */
2010-10-28 05:18:51 +02:00
if ((c->buffer->info[j].lig_comp() != c->buffer->info[c->buffer->i].lig_comp()) ||
(c->buffer->info[j].lig_comp() && c->buffer->info[j].lig_id() != c->buffer->info[c->buffer->i].lig_id()))
return false;
unsigned int mark2_index = (this+mark2Coverage) (c->buffer->info[j].codepoint);
if (mark2_index == NOT_COVERED)
return false;
2010-05-13 20:18:49 +02:00
return (this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j);
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
return c->check_struct (this)
&& mark1Coverage.sanitize (c, this)
&& mark2Coverage.sanitize (c, this)
&& mark1Array.sanitize (c, this)
&& mark2Array.sanitize (c, this, (unsigned int) classCount);
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
private:
USHORT format; /* Format identifier--format = 1 */
OffsetTo<Coverage>
mark1Coverage; /* Offset to Combining Mark1 Coverage
2009-05-18 23:09:33 +02:00
* table--from beginning of MarkMarkPos
* subtable */
OffsetTo<Coverage>
mark2Coverage; /* Offset to Combining Mark2 Coverage
2009-05-18 23:09:33 +02:00
* table--from beginning of MarkMarkPos
* subtable */
USHORT classCount; /* Number of defined mark classes */
OffsetTo<MarkArray>
mark1Array; /* Offset to Mark1Array table--from
* beginning of MarkMarkPos subtable */
OffsetTo<Mark2Array>
mark2Array; /* Offset to Mark2Array table--from
* beginning of MarkMarkPos subtable */
public:
DEFINE_SIZE_STATIC (12);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct MarkMarkPos
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (!u.format.sanitize (c)) return false;
2009-08-04 19:30:49 +02:00
switch (u.format) {
2010-05-13 20:18:49 +02:00
case 1: return u.format1.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT format; /* Format identifier */
2010-05-11 01:45:41 +02:00
MarkMarkPosFormat1 format1;
2009-05-18 23:09:33 +02:00
} u;
};
2010-07-23 21:11:18 +02:00
HB_BEGIN_DECLS
2010-05-13 20:18:49 +02:00
static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index);
2010-07-23 21:11:18 +02:00
HB_END_DECLS
2009-05-18 23:09:33 +02:00
2009-05-20 05:42:30 +02:00
struct ContextPos : Context
{
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-08-28 23:14:33 +02:00
{
TRACE_APPLY ();
2010-05-13 20:18:49 +02:00
return Context::apply (c, position_lookup);
2009-08-28 23:14:33 +02:00
}
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct ChainContextPos : ChainContext
{
friend struct PosLookupSubTable;
private:
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const
2009-08-28 23:14:33 +02:00
{
TRACE_APPLY ();
2010-05-13 20:18:49 +02:00
return ChainContext::apply (c, position_lookup);
2009-08-28 23:14:33 +02:00
}
2009-05-18 23:09:33 +02:00
};
struct ExtensionPos : Extension
2009-05-20 05:42:30 +02:00
{
2009-05-18 23:09:33 +02:00
friend struct PosLookupSubTable;
private:
2009-08-04 19:30:49 +02:00
inline const struct PosLookupSubTable& get_subtable (void) const
2010-04-22 22:51:42 +02:00
{
unsigned int offset = get_offset ();
if (unlikely (!offset)) return Null(PosLookupSubTable);
return StructAtOffset<PosLookupSubTable> (this, offset);
2010-04-22 22:51:42 +02:00
}
2009-08-04 19:30:49 +02:00
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c) const;
2009-08-04 19:30:49 +02:00
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c);
2009-05-18 23:09:33 +02:00
};
2009-05-18 23:09:33 +02:00
/*
* PosLookup
*/
2009-05-20 05:42:30 +02:00
struct PosLookupSubTable
{
2009-05-18 23:09:33 +02:00
friend struct PosLookup;
enum {
Single = 1,
Pair = 2,
Cursive = 3,
MarkBase = 4,
MarkLig = 5,
MarkMark = 6,
Context = 7,
ChainContext = 8,
2009-08-18 22:41:59 +02:00
Extension = 9
};
2010-05-13 20:18:49 +02:00
inline bool apply (hb_apply_context_t *c, unsigned int lookup_type) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2009-05-18 23:09:33 +02:00
switch (lookup_type) {
2010-05-13 20:18:49 +02:00
case Single: return u.single.apply (c);
case Pair: return u.pair.apply (c);
case Cursive: return u.cursive.apply (c);
case MarkBase: return u.markBase.apply (c);
case MarkLig: return u.markLig.apply (c);
case MarkMark: return u.markMark.apply (c);
case Context: return u.c.apply (c);
case ChainContext: return u.chainContext.apply (c);
case Extension: return u.extension.apply (c);
2009-05-18 23:09:33 +02:00
default:return false;
}
}
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) {
TRACE_SANITIZE ();
switch (lookup_type) {
2010-05-13 20:18:49 +02:00
case Single: return u.single.sanitize (c);
case Pair: return u.pair.sanitize (c);
case Cursive: return u.cursive.sanitize (c);
case MarkBase: return u.markBase.sanitize (c);
case MarkLig: return u.markLig.sanitize (c);
case MarkMark: return u.markMark.sanitize (c);
case Context: return u.c.sanitize (c);
case ChainContext: return u.chainContext.sanitize (c);
case Extension: return u.extension.sanitize (c);
2009-08-04 19:30:49 +02:00
default:return true;
}
}
2009-05-18 23:09:33 +02:00
private:
union {
USHORT sub_format;
2010-05-11 01:45:41 +02:00
SinglePos single;
PairPos pair;
CursivePos cursive;
MarkBasePos markBase;
MarkLigPos markLig;
MarkMarkPos markMark;
2010-05-13 20:18:49 +02:00
ContextPos c;
2010-05-11 01:45:41 +02:00
ChainContextPos chainContext;
ExtensionPos extension;
2009-05-18 23:09:33 +02:00
} u;
2010-05-11 00:08:46 +02:00
public:
DEFINE_SIZE_UNION (2, sub_format);
2009-05-18 23:09:33 +02:00
};
2009-05-20 05:42:30 +02:00
struct PosLookup : Lookup
{
inline const PosLookupSubTable& get_subtable (unsigned int i) const
{ return this+CastR<OffsetArrayOf<PosLookupSubTable> > (subTable)[i]; }
2009-05-18 23:09:33 +02:00
2010-05-05 07:01:05 +02:00
inline bool apply_once (hb_ot_layout_context_t *layout,
hb_buffer_t *buffer,
hb_mask_t lookup_mask,
unsigned int context_length,
unsigned int nesting_level_left) const
2009-05-20 05:42:30 +02:00
{
2009-05-18 23:09:33 +02:00
unsigned int lookup_type = get_type ();
2010-05-13 20:18:49 +02:00
hb_apply_context_t c[1] = {{0}};
2010-05-13 20:18:49 +02:00
c->layout = layout;
c->buffer = buffer;
c->lookup_mask = lookup_mask;
2010-05-13 20:18:49 +02:00
c->context_length = context_length;
c->nesting_level_left = nesting_level_left;
c->lookup_props = get_props ();
2009-05-22 23:58:09 +02:00
if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_props, &c->property))
2009-05-22 23:58:09 +02:00
return false;
2009-05-18 23:09:33 +02:00
for (unsigned int i = 0; i < get_subtable_count (); i++)
2010-05-13 20:18:49 +02:00
if (get_subtable (i).apply (c, lookup_type))
2009-05-18 23:09:33 +02:00
return true;
return false;
}
2010-05-05 07:01:05 +02:00
inline bool apply_string (hb_ot_layout_context_t *layout,
hb_buffer_t *buffer,
hb_mask_t mask) const
2009-05-20 05:42:30 +02:00
{
2009-05-18 23:09:33 +02:00
bool ret = false;
if (unlikely (!buffer->len))
2009-05-18 23:09:33 +02:00
return false;
buffer->i = 0;
while (buffer->i < buffer->len)
2009-05-20 05:42:30 +02:00
{
if ((buffer->info[buffer->i].mask & mask) &&
apply_once (layout, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL))
ret = true;
2009-05-20 05:42:30 +02:00
else
buffer->i++;
2009-05-18 23:09:33 +02:00
}
return ret;
}
2009-08-04 19:30:49 +02:00
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (unlikely (!Lookup::sanitize (c))) return false;
OffsetArrayOf<PosLookupSubTable> &list = CastR<OffsetArrayOf<PosLookupSubTable> > (subTable);
2010-05-13 20:18:49 +02:00
return list.sanitize (c, this, get_type ());
2009-08-04 19:30:49 +02:00
}
2009-05-18 23:09:33 +02:00
};
2009-08-04 19:30:49 +02:00
typedef OffsetListOf<PosLookup> PosLookupList;
2009-05-18 23:09:33 +02:00
/*
* GPOS
*/
2009-05-20 05:42:30 +02:00
struct GPOS : GSUBGPOS
{
2009-08-05 02:27:05 +02:00
static const hb_tag_t Tag = HB_OT_TAG_GPOS;
2009-05-18 23:09:33 +02:00
2009-05-20 05:42:30 +02:00
inline const PosLookup& get_lookup (unsigned int i) const
{ return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
2009-05-18 23:09:33 +02:00
2010-05-05 07:01:05 +02:00
inline bool position_lookup (hb_ot_layout_context_t *layout,
hb_buffer_t *buffer,
unsigned int lookup_index,
hb_mask_t mask) const
2010-05-05 07:01:05 +02:00
{ return get_lookup (lookup_index).apply_string (layout, buffer, mask); }
2009-05-18 23:09:33 +02:00
2010-10-28 04:48:31 +02:00
static inline void position_finish (hb_buffer_t *buffer);
2010-05-13 20:18:49 +02:00
inline bool sanitize (hb_sanitize_context_t *c) {
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (unlikely (!GSUBGPOS::sanitize (c))) return false;
OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
2010-05-13 20:18:49 +02:00
return list.sanitize (c, this);
2009-08-04 19:30:49 +02:00
}
public:
DEFINE_SIZE_STATIC (10);
2009-05-18 23:09:33 +02:00
};
2010-10-28 04:48:31 +02:00
void
GPOS::position_finish (hb_buffer_t *buffer)
{
unsigned int i, j;
unsigned int len;
hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
2010-10-28 04:48:31 +02:00
hb_direction_t direction = buffer->props.direction;
/* Handle cursive connections:
* First handle all chain-back connections, then handle all chain-forward connections. */
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
{
for (j = 0; j < len; j++) {
if (pos[j].cursive_chain() < 0)
pos[j].y_offset += pos[j + pos[j].cursive_chain()].y_offset;
}
for (i = len; i > 0; i--) {
j = i - 1;
if (pos[j].cursive_chain() > 0)
pos[j].y_offset += pos[j + pos[j].cursive_chain()].y_offset;
}
}
else
{
for (j = 0; j < len; j++) {
if (pos[j].cursive_chain() < 0)
pos[j].x_offset += pos[j + pos[j].cursive_chain()].x_offset;
}
for (i = len; i > 0; i--) {
j = i - 1;
if (pos[j].cursive_chain() > 0)
pos[j].x_offset += pos[j + pos[j].cursive_chain()].x_offset;
}
}
/* Handle attachments */
for (i = 0; i < len; i++)
2010-10-28 05:09:10 +02:00
if (pos[i].attach_lookback())
2010-10-28 04:48:31 +02:00
{
2010-10-28 05:09:10 +02:00
unsigned int back = i - pos[i].attach_lookback();
2010-10-28 04:48:31 +02:00
pos[i].x_offset += pos[back].x_offset;
pos[i].y_offset += pos[back].y_offset;
if (HB_DIRECTION_IS_BACKWARD (buffer->props.direction))
for (j = back + 1; j < i + 1; j++) {
pos[i].x_offset += pos[j].x_advance;
pos[i].y_offset += pos[j].y_advance;
}
else
for (j = back; j < i; j++) {
pos[i].x_offset -= pos[j].x_advance;
pos[i].y_offset -= pos[j].y_advance;
}
}
}
2009-05-18 23:09:33 +02:00
/* Out-of-class implementation for methods recursing */
2010-05-13 20:18:49 +02:00
inline bool ExtensionPos::apply (hb_apply_context_t *c) const
2009-05-20 05:42:30 +02:00
{
TRACE_APPLY ();
2010-05-13 20:18:49 +02:00
return get_subtable ().apply (c, get_type ());
2009-08-04 19:30:49 +02:00
}
2010-05-13 20:18:49 +02:00
inline bool ExtensionPos::sanitize (hb_sanitize_context_t *c)
2009-08-04 19:30:49 +02:00
{
TRACE_SANITIZE ();
2010-05-13 20:18:49 +02:00
if (unlikely (!Extension::sanitize (c))) return false;
2010-04-22 22:51:42 +02:00
unsigned int offset = get_offset ();
if (unlikely (!offset)) return true;
2010-05-13 20:18:49 +02:00
return StructAtOffset<PosLookupSubTable> (this, offset).sanitize (c, get_type ());
2009-05-18 23:09:33 +02:00
}
2010-05-13 20:18:49 +02:00
static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index)
2009-05-20 05:42:30 +02:00
{
const GPOS &gpos = *(c->layout->face->ot_layout->gpos);
2009-05-18 23:09:33 +02:00
const PosLookup &l = gpos.get_lookup (lookup_index);
2010-05-13 20:18:49 +02:00
if (unlikely (c->nesting_level_left == 0))
2009-05-18 23:09:33 +02:00
return false;
2010-05-13 20:18:49 +02:00
if (unlikely (c->context_length < 1))
2009-05-18 23:09:33 +02:00
return false;
return l.apply_once (c->layout, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1);
2009-05-18 23:09:33 +02:00
}
2010-10-28 05:09:10 +02:00
#undef attach_lookback
#undef cursive_chain
2010-07-23 21:11:18 +02:00
HB_END_DECLS
#endif /* HB_OT_LAYOUT_GPOS_PRIVATE_HH */