Index: third_party/harfbuzz-ng/src/hb-ot-layout-gpos-table.hh |
diff --git a/third_party/harfbuzz-ng/src/hb-ot-layout-gpos-private.hh b/third_party/harfbuzz-ng/src/hb-ot-layout-gpos-table.hh |
similarity index 78% |
rename from third_party/harfbuzz-ng/src/hb-ot-layout-gpos-private.hh |
rename to third_party/harfbuzz-ng/src/hb-ot-layout-gpos-table.hh |
index 11bb28699231511637b8e7d776226a5a11ede3d2..412850ba3506e7f1ba7ece0fb08966def4ca7be7 100644 |
--- a/third_party/harfbuzz-ng/src/hb-ot-layout-gpos-private.hh |
+++ b/third_party/harfbuzz-ng/src/hb-ot-layout-gpos-table.hh |
@@ -1,6 +1,6 @@ |
/* |
- * Copyright (C) 2007,2008,2009,2010 Red Hat, Inc. |
- * Copyright (C) 2010 Google, Inc. |
+ * Copyright © 2007,2008,2009,2010 Red Hat, Inc. |
+ * Copyright © 2010 Google, Inc. |
* |
* This is part of HarfBuzz, a text shaping library. |
* |
@@ -26,15 +26,14 @@ |
* Google Author(s): Behdad Esfahbod |
*/ |
-#ifndef HB_OT_LAYOUT_GPOS_PRIVATE_HH |
-#define HB_OT_LAYOUT_GPOS_PRIVATE_HH |
+#ifndef HB_OT_LAYOUT_GPOS_TABLE_HH |
+#define HB_OT_LAYOUT_GPOS_TABLE_HH |
#include "hb-ot-layout-gsubgpos-private.hh" |
-HB_BEGIN_DECLS |
-/* buffer var allocations */ |
+/* buffer **position** 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 */ |
@@ -94,41 +93,48 @@ struct ValueFormat : USHORT |
inline unsigned int get_size (void) const |
{ return get_len () * Value::static_size; } |
- void apply_value (hb_ot_layout_context_t *layout, |
- const void *base, |
- const Value *values, |
- hb_glyph_position_t &glyph_pos) const |
+ void apply_value (hb_font_t *font, |
+ hb_direction_t direction, |
+ const void *base, |
+ const Value *values, |
+ hb_glyph_position_t &glyph_pos) const |
{ |
unsigned int x_ppem, y_ppem; |
unsigned int format = *this; |
+ hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (direction); |
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++)); |
+ if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++)); |
+ if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++)); |
+ if (format & xAdvance) { |
+ if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values++)); else values++; |
+ } |
+ /* y_advance values grow downward but font-space grows upward, hence negation */ |
+ if (format & yAdvance) { |
+ if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values++)); else values++; |
+ } |
if (!has_device ()) return; |
- x_ppem = layout->font->x_ppem; |
- y_ppem = layout->font->y_ppem; |
+ x_ppem = font->x_ppem; |
+ y_ppem = font->y_ppem; |
if (!x_ppem && !y_ppem) return; |
/* pixel -> fractional pixel */ |
if (format & xPlaDevice) { |
- if (x_ppem) glyph_pos.x_offset += (base + get_device (values++)).get_x_delta (layout); else values++; |
+ if (x_ppem) glyph_pos.x_offset += (base + get_device (values++)).get_x_delta (font); else values++; |
} |
if (format & yPlaDevice) { |
- if (y_ppem) glyph_pos.y_offset += (base + get_device (values++)).get_y_delta (layout); else values++; |
+ if (y_ppem) glyph_pos.y_offset += (base + get_device (values++)).get_y_delta (font); else values++; |
} |
if (format & xAdvDevice) { |
- if (x_ppem) glyph_pos.x_advance += (base + get_device (values++)).get_x_delta (layout); else values++; |
+ if (horizontal && x_ppem) glyph_pos.x_advance += (base + get_device (values++)).get_x_delta (font); else values++; |
} |
if (format & yAdvDevice) { |
- if (y_ppem) glyph_pos.y_advance += (base + get_device (values++)).get_y_delta (layout); else values++; |
+ /* y_advance values grow downward but font-space grows upward, hence negation */ |
+ if (!horizontal && y_ppem) glyph_pos.y_advance -= (base + get_device (values++)).get_y_delta (font); else values++; |
} |
} |
@@ -209,11 +215,11 @@ struct AnchorFormat1 |
friend struct Anchor; |
private: |
- inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id HB_UNUSED, |
+ inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED, |
hb_position_t *x, hb_position_t *y) const |
{ |
- *x = layout->scale_x (xCoordinate); |
- *y = layout->scale_y (yCoordinate); |
+ *x = font->em_scale_x (xCoordinate); |
+ *y = font->em_scale_y (yCoordinate); |
} |
inline bool sanitize (hb_sanitize_context_t *c) { |
@@ -234,18 +240,18 @@ struct AnchorFormat2 |
friend struct Anchor; |
private: |
- inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id, |
+ inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id, |
hb_position_t *x, hb_position_t *y) const |
{ |
- unsigned int x_ppem = layout->font->x_ppem; |
- unsigned int y_ppem = layout->font->y_ppem; |
+ unsigned int x_ppem = font->x_ppem; |
+ unsigned int y_ppem = font->y_ppem; |
hb_position_t cx, cy; |
hb_bool_t ret = false; |
if (x_ppem || y_ppem) |
- 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); |
+ ret = hb_font_get_glyph_contour_point_for_origin (font, glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy); |
+ *x = x_ppem && ret ? cx : font->em_scale_x (xCoordinate); |
+ *y = y_ppem && ret ? cy : font->em_scale_y (yCoordinate); |
} |
inline bool sanitize (hb_sanitize_context_t *c) { |
@@ -267,17 +273,16 @@ struct AnchorFormat3 |
friend struct Anchor; |
private: |
- inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id HB_UNUSED, |
+ inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED, |
hb_position_t *x, hb_position_t *y) const |
{ |
- *x = layout->scale_x (xCoordinate); |
- *y = layout->scale_y (yCoordinate); |
- |
- /* pixel -> fractional pixel */ |
- if (layout->font->x_ppem) |
- *x += (this+xDeviceTable).get_x_delta (layout); |
- if (layout->font->y_ppem) |
- *y += (this+yDeviceTable).get_x_delta (layout); |
+ *x = font->em_scale_x (xCoordinate); |
+ *y = font->em_scale_y (yCoordinate); |
+ |
+ if (font->x_ppem) |
+ *x += (this+xDeviceTable).get_x_delta (font); |
+ if (font->y_ppem) |
+ *y += (this+yDeviceTable).get_x_delta (font); |
} |
inline bool sanitize (hb_sanitize_context_t *c) { |
@@ -305,15 +310,15 @@ struct AnchorFormat3 |
struct Anchor |
{ |
- inline void get_anchor (hb_ot_layout_context_t *layout, hb_codepoint_t glyph_id, |
+ inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id, |
hb_position_t *x, hb_position_t *y) const |
{ |
*x = *y = 0; |
switch (u.format) { |
- 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; |
- default: return; |
+ case 1: u.format1.get_anchor (font, glyph_id, x, y); return; |
+ case 2: u.format2.get_anchor (font, glyph_id, x, y); return; |
+ case 3: u.format3.get_anchor (font, glyph_id, x, y); return; |
+ default: return; |
} |
} |
@@ -403,15 +408,15 @@ struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage orde |
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); |
+ mark_anchor.get_anchor (c->font, c->buffer->info[c->buffer->idx].codepoint, &mark_x, &mark_y); |
+ glyph_anchor.get_anchor (c->font, c->buffer->info[glyph_pos].codepoint, &base_x, &base_y); |
- hb_glyph_position_t &o = c->buffer->pos[c->buffer->i]; |
+ hb_glyph_position_t &o = c->buffer->pos[c->buffer->idx]; |
o.x_offset = base_x - mark_x; |
o.y_offset = base_y - mark_y; |
- o.attach_lookback() = c->buffer->i - glyph_pos; |
+ o.attach_lookback() = c->buffer->idx - glyph_pos; |
- c->buffer->i++; |
+ c->buffer->idx++; |
return true; |
} |
@@ -432,13 +437,14 @@ struct SinglePosFormat1 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint); |
if (likely (index == NOT_COVERED)) |
return false; |
- valueFormat.apply_value (c->layout, this, values, c->buffer->pos[c->buffer->i]); |
+ valueFormat.apply_value (c->font, c->direction, this, |
+ values, c->buffer->pos[c->buffer->idx]); |
- c->buffer->i++; |
+ c->buffer->idx++; |
return true; |
} |
@@ -471,18 +477,18 @@ struct SinglePosFormat2 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint); |
if (likely (index == NOT_COVERED)) |
return false; |
if (likely (index >= valueCount)) |
return false; |
- valueFormat.apply_value (c->layout, this, |
+ valueFormat.apply_value (c->font, c->direction, this, |
&values[index * valueFormat.get_len ()], |
- c->buffer->pos[c->buffer->i]); |
+ c->buffer->pos[c->buffer->idx]); |
- c->buffer->i++; |
+ c->buffer->idx++; |
return true; |
} |
@@ -574,11 +580,13 @@ struct PairSet |
{ |
if (c->buffer->info[pos].codepoint == record->secondGlyph) |
{ |
- 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]); |
+ valueFormats[0].apply_value (c->font, c->direction, this, |
+ &record->values[0], c->buffer->pos[c->buffer->idx]); |
+ valueFormats[1].apply_value (c->font, c->direction, this, |
+ &record->values[len1], c->buffer->pos[pos]); |
if (len2) |
pos++; |
- c->buffer->i = pos; |
+ c->buffer->idx = pos; |
return true; |
} |
record = &StructAtOffset<PairValueRecord> (record, record_size); |
@@ -621,23 +629,18 @@ struct PairPosFormat1 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length); |
- if (unlikely (c->buffer->i + 2 > end)) |
+ hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, 1); |
+ if (skippy_iter.has_no_chance ()) |
return false; |
- unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint); |
if (likely (index == NOT_COVERED)) |
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++; |
- } |
+ if (!skippy_iter.next ()) |
+ return false; |
- return (this+pairSet[index]).apply (c, &valueFormat1, j); |
+ return (this+pairSet[index]).apply (c, &valueFormat1, skippy_iter.idx); |
} |
inline bool sanitize (hb_sanitize_context_t *c) { |
@@ -683,38 +686,35 @@ struct PairPosFormat2 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length); |
- if (unlikely (c->buffer->i + 2 > end)) |
+ hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, 1); |
+ if (skippy_iter.has_no_chance ()) |
return false; |
- unsigned int index = (this+coverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int index = (this+coverage) (c->buffer->info[c->buffer->idx].codepoint); |
if (likely (index == NOT_COVERED)) |
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++; |
- } |
+ if (!skippy_iter.next ()) |
+ return false; |
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); |
+ unsigned int klass1 = (this+classDef1) (c->buffer->info[c->buffer->idx].codepoint); |
+ unsigned int klass2 = (this+classDef2) (c->buffer->info[skippy_iter.idx].codepoint); |
if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) |
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]); |
+ valueFormat1.apply_value (c->font, c->direction, this, |
+ v, c->buffer->pos[c->buffer->idx]); |
+ valueFormat2.apply_value (c->font, c->direction, this, |
+ v + len1, c->buffer->pos[skippy_iter.idx]); |
+ c->buffer->idx = skippy_iter.idx; |
if (len2) |
- j++; |
- c->buffer->i = j; |
+ c->buffer->idx++; |
return true; |
} |
@@ -836,69 +836,82 @@ struct CursivePosFormat1 |
if (c->property & HB_OT_LAYOUT_GLYPH_CLASS_MARK) |
return false; |
- unsigned int end = MIN (c->buffer->len, c->buffer->i + c->context_length); |
- if (unlikely (c->buffer->i + 2 > end)) |
+ hb_apply_context_t::mark_skipping_forward_iterator_t skippy_iter (c, c->buffer->idx, 1); |
+ if (skippy_iter.has_no_chance ()) |
return false; |
- const EntryExitRecord &this_record = entryExitRecord[(this+coverage) (c->buffer->info[c->buffer->i].codepoint)]; |
+ const EntryExitRecord &this_record = entryExitRecord[(this+coverage) (c->buffer->info[c->buffer->idx].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++; |
- } |
+ if (!skippy_iter.next ()) |
+ return false; |
- const EntryExitRecord &next_record = entryExitRecord[(this+coverage) (c->buffer->info[j].codepoint)]; |
+ const EntryExitRecord &next_record = entryExitRecord[(this+coverage) (c->buffer->info[skippy_iter.idx].codepoint)]; |
if (!next_record.entryAnchor) |
return false; |
- unsigned int i = c->buffer->i; |
+ unsigned int i = c->buffer->idx; |
+ unsigned int j = skippy_iter.idx; |
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); |
- |
- hb_direction_t direction = c->buffer->props.direction; |
- |
- /* 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)) |
- { |
- 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; |
- } |
- 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; |
+ (this+this_record.exitAnchor).get_anchor (c->font, c->buffer->info[i].codepoint, &exit_x, &exit_y); |
+ (this+next_record.entryAnchor).get_anchor (c->font, c->buffer->info[j].codepoint, &entry_x, &entry_y); |
+ |
+ hb_glyph_position_t *pos = c->buffer->pos; |
+ |
+ hb_position_t d; |
+ /* Main-direction adjustment */ |
+ switch (c->direction) { |
+ case HB_DIRECTION_LTR: |
+ pos[i].x_advance = exit_x + pos[i].x_offset; |
+ |
+ d = entry_x + pos[j].x_offset; |
+ pos[j].x_advance -= d; |
+ pos[j].x_offset -= d; |
+ break; |
+ case HB_DIRECTION_RTL: |
+ d = exit_x + pos[i].x_offset; |
+ pos[i].x_advance -= d; |
+ pos[i].x_offset -= d; |
+ |
+ pos[j].x_advance = entry_x + pos[j].x_offset; |
+ break; |
+ case HB_DIRECTION_TTB: |
+ pos[i].y_advance = exit_y + pos[i].y_offset; |
+ |
+ d = entry_y + pos[j].y_offset; |
+ pos[j].y_advance -= d; |
+ pos[j].y_offset -= d; |
+ break; |
+ case HB_DIRECTION_BTT: |
+ d = exit_y + pos[i].y_offset; |
+ pos[i].y_advance -= d; |
+ pos[i].y_offset -= d; |
+ |
+ pos[j].y_advance = entry_y; |
+ break; |
+ case HB_DIRECTION_INVALID: |
+ default: |
+ break; |
} |
- if (c->lookup_props & LookupFlag::RightToLeft) |
- { |
- 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; |
+ /* Cross-direction adjustment */ |
+ if (c->lookup_props & LookupFlag::RightToLeft) { |
+ pos[i].cursive_chain() = j - i; |
+ if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction))) |
+ pos[i].y_offset = entry_y - exit_y; |
else |
- c->buffer->pos[i].x_offset = entry_x - exit_x; |
- } |
- 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; |
+ pos[i].x_offset = entry_x - exit_x; |
+ } else { |
+ pos[j].cursive_chain() = i - j; |
+ if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction))) |
+ pos[j].y_offset = exit_y - entry_y; |
else |
- c->buffer->pos[j].x_offset = exit_x - entry_x; |
+ pos[j].x_offset = exit_x - entry_x; |
} |
- c->buffer->i = j; |
+ c->buffer->idx = j; |
return true; |
} |
@@ -964,29 +977,25 @@ struct MarkBasePosFormat1 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->idx].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)) |
- return false; |
- j--; |
- } while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], LookupFlag::IgnoreMarks, &property)); |
+ hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->idx, 1); |
+ if (!skippy_iter.prev (&property, LookupFlag::IgnoreMarks)) |
+ return false; |
/* The following assertion is too strong, so we've disabled it. */ |
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH)) |
{/*return false;*/} |
- unsigned int base_index = (this+baseCoverage) (c->buffer->info[j].codepoint); |
+ unsigned int base_index = (this+baseCoverage) (c->buffer->info[skippy_iter.idx].codepoint); |
if (base_index == NOT_COVERED) |
return false; |
- return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, j); |
+ return (this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx); |
} |
inline bool sanitize (hb_sanitize_context_t *c) { |
@@ -1066,24 +1075,21 @@ struct MarkLigPosFormat1 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int mark_index = (this+markCoverage) (c->buffer->info[c->buffer->idx].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)) |
- return false; |
- j--; |
- } while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], LookupFlag::IgnoreMarks, &property)); |
+ hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->idx, 1); |
+ if (!skippy_iter.prev (&property, LookupFlag::IgnoreMarks)) |
+ return false; |
/* The following assertion is too strong, so we've disabled it. */ |
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE)) |
{/*return false;*/} |
+ unsigned int j = skippy_iter.idx; |
unsigned int lig_index = (this+ligatureCoverage) (c->buffer->info[j].codepoint); |
if (lig_index == NOT_COVERED) |
return false; |
@@ -1100,9 +1106,9 @@ struct MarkLigPosFormat1 |
* 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. */ |
- 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()) |
+ if (c->buffer->info[j].lig_id() && c->buffer->info[j].lig_id() == c->buffer->info[c->buffer->idx].lig_id() && c->buffer->info[c->buffer->idx].lig_comp()) |
{ |
- comp_index = c->buffer->info[c->buffer->i].lig_comp() - 1; |
+ comp_index = c->buffer->info[c->buffer->idx].lig_comp() - 1; |
if (comp_index >= comp_count) |
comp_index = comp_count - 1; |
} |
@@ -1185,28 +1191,26 @@ struct MarkMarkPosFormat1 |
inline bool apply (hb_apply_context_t *c) const |
{ |
TRACE_APPLY (); |
- unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->i].codepoint); |
+ unsigned int mark1_index = (this+mark1Coverage) (c->buffer->info[c->buffer->idx].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)) |
- return false; |
- j--; |
- } while (_hb_ot_layout_skip_mark (c->layout->face, &c->buffer->info[j], c->lookup_props, &property)); |
+ hb_apply_context_t::mark_skipping_backward_iterator_t skippy_iter (c, c->buffer->idx, 1); |
+ if (!skippy_iter.prev (&property)) |
+ return false; |
if (!(property & HB_OT_LAYOUT_GLYPH_CLASS_MARK)) |
return false; |
+ unsigned int j = skippy_iter.idx; |
+ |
/* 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. */ |
- 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())) |
+ if ((c->buffer->info[j].lig_comp() != c->buffer->info[c->buffer->idx].lig_comp()) || |
+ (c->buffer->info[j].lig_comp() && c->buffer->info[j].lig_id() != c->buffer->info[c->buffer->idx].lig_id())) |
return false; |
unsigned int mark2_index = (this+mark2Coverage) (c->buffer->info[j].codepoint); |
@@ -1277,9 +1281,7 @@ struct MarkMarkPos |
}; |
-HB_BEGIN_DECLS |
static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index); |
-HB_END_DECLS |
struct ContextPos : Context |
{ |
@@ -1402,7 +1404,7 @@ struct PosLookup : Lookup |
inline const PosLookupSubTable& get_subtable (unsigned int i) const |
{ return this+CastR<OffsetArrayOf<PosLookupSubTable> > (subTable)[i]; } |
- inline bool apply_once (hb_ot_layout_context_t *layout, |
+ inline bool apply_once (hb_font_t *font, |
hb_buffer_t *buffer, |
hb_mask_t lookup_mask, |
unsigned int context_length, |
@@ -1411,14 +1413,16 @@ struct PosLookup : Lookup |
unsigned int lookup_type = get_type (); |
hb_apply_context_t c[1] = {{0}}; |
- c->layout = layout; |
+ c->font = font; |
+ c->face = font->face; |
c->buffer = buffer; |
+ c->direction = buffer->props.direction; |
c->lookup_mask = lookup_mask; |
c->context_length = context_length; |
c->nesting_level_left = nesting_level_left; |
c->lookup_props = get_props (); |
- if (!_hb_ot_layout_check_glyph_property (c->layout->face, &c->buffer->info[c->buffer->i], c->lookup_props, &c->property)) |
+ if (!_hb_ot_layout_check_glyph_property (c->face, &c->buffer->info[c->buffer->idx], c->lookup_props, &c->property)) |
return false; |
for (unsigned int i = 0; i < get_subtable_count (); i++) |
@@ -1428,7 +1432,7 @@ struct PosLookup : Lookup |
return false; |
} |
- inline bool apply_string (hb_ot_layout_context_t *layout, |
+ inline bool apply_string (hb_font_t *font, |
hb_buffer_t *buffer, |
hb_mask_t mask) const |
{ |
@@ -1437,14 +1441,14 @@ struct PosLookup : Lookup |
if (unlikely (!buffer->len)) |
return false; |
- buffer->i = 0; |
- while (buffer->i < buffer->len) |
+ buffer->idx = 0; |
+ while (buffer->idx < buffer->len) |
{ |
- if ((buffer->info[buffer->i].mask & mask) && |
- apply_once (layout, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL)) |
+ if ((buffer->info[buffer->idx].mask & mask) && |
+ apply_once (font, buffer, mask, NO_CONTEXT, MAX_NESTING_LEVEL)) |
ret = true; |
else |
- buffer->i++; |
+ buffer->idx++; |
} |
return ret; |
@@ -1461,7 +1465,7 @@ struct PosLookup : Lookup |
typedef OffsetListOf<PosLookup> PosLookupList; |
/* |
- * GPOS |
+ * GPOS -- The Glyph Positioning Table |
*/ |
struct GPOS : GSUBGPOS |
@@ -1471,12 +1475,13 @@ struct GPOS : GSUBGPOS |
inline const PosLookup& get_lookup (unsigned int i) const |
{ return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); } |
- inline bool position_lookup (hb_ot_layout_context_t *layout, |
+ inline bool position_lookup (hb_font_t *font, |
hb_buffer_t *buffer, |
unsigned int lookup_index, |
hb_mask_t mask) const |
- { return get_lookup (lookup_index).apply_string (layout, buffer, mask); } |
+ { return get_lookup (lookup_index).apply_string (font, buffer, mask); } |
+ static inline void position_start (hb_buffer_t *buffer); |
static inline void position_finish (hb_buffer_t *buffer); |
inline bool sanitize (hb_sanitize_context_t *c) { |
@@ -1489,61 +1494,79 @@ struct GPOS : GSUBGPOS |
DEFINE_SIZE_STATIC (10); |
}; |
-void |
-GPOS::position_finish (hb_buffer_t *buffer) |
+ |
+static void |
+fix_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction) |
{ |
- unsigned int i, j; |
- unsigned int len = hb_buffer_get_length (buffer); |
- hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer); |
- hb_direction_t direction = buffer->props.direction; |
+ unsigned int j = pos[i].cursive_chain(); |
+ if (likely (!j)) |
+ return; |
- /* 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; |
+ j += i; |
+ |
+ pos[i].cursive_chain() = 0; |
+ |
+ fix_cursive_minor_offset (pos, j, direction); |
+ |
+ if (HB_DIRECTION_IS_HORIZONTAL (direction)) |
+ pos[i].y_offset += pos[j].y_offset; |
+ else |
+ pos[i].x_offset += pos[j].x_offset; |
+} |
+ |
+static void |
+fix_mark_attachment (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction) |
+{ |
+ if (likely (!(pos[i].attach_lookback()))) |
+ return; |
+ |
+ unsigned int j = i - pos[i].attach_lookback(); |
+ |
+ pos[i].x_advance = 0; |
+ pos[i].y_advance = 0; |
+ pos[i].x_offset += pos[j].x_offset; |
+ pos[i].y_offset += pos[j].y_offset; |
+ |
+ if (HB_DIRECTION_IS_FORWARD (direction)) |
+ for (unsigned int k = j; k < i; k++) { |
+ pos[i].x_offset -= pos[k].x_advance; |
+ pos[i].y_offset -= pos[k].y_advance; |
} |
- } |
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; |
+ for (unsigned int k = j + 1; k < i + 1; k++) { |
+ pos[i].x_offset += pos[k].x_advance; |
+ pos[i].y_offset += pos[k].y_advance; |
} |
- } |
+} |
+ |
+void |
+GPOS::position_start (hb_buffer_t *buffer) |
+{ |
+ buffer->clear_positions (); |
+ |
+ unsigned int count = buffer->len; |
+ for (unsigned int i = 0; i < count; i++) |
+ buffer->pos[i].attach_lookback() = buffer->pos[i].cursive_chain() = 0; |
+} |
+ |
+void |
+GPOS::position_finish (hb_buffer_t *buffer) |
+{ |
+ unsigned int len; |
+ hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len); |
+ hb_direction_t direction = buffer->props.direction; |
+ /* Handle cursive connections */ |
+ for (unsigned int i = 0; i < len; i++) |
+ fix_cursive_minor_offset (pos, i, direction); |
/* Handle attachments */ |
- for (i = 0; i < len; i++) |
- if (pos[i].attach_lookback()) |
- { |
- unsigned int back = i - pos[i].attach_lookback(); |
- 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; |
- } |
- } |
+ for (unsigned int i = 0; i < len; i++) |
+ fix_mark_attachment (pos, i, direction); |
+ |
+ HB_BUFFER_DEALLOCATE_VAR (buffer, lig_comp); |
+ HB_BUFFER_DEALLOCATE_VAR (buffer, lig_id); |
+ HB_BUFFER_DEALLOCATE_VAR (buffer, props_cache); |
} |
@@ -1566,7 +1589,7 @@ inline bool ExtensionPos::sanitize (hb_sanitize_context_t *c) |
static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_index) |
{ |
- const GPOS &gpos = *(c->layout->face->ot_layout->gpos); |
+ const GPOS &gpos = *(c->face->ot_layout->gpos); |
const PosLookup &l = gpos.get_lookup (lookup_index); |
if (unlikely (c->nesting_level_left == 0)) |
@@ -1575,7 +1598,7 @@ static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_i |
if (unlikely (c->context_length < 1)) |
return false; |
- return l.apply_once (c->layout, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1); |
+ return l.apply_once (c->font, c->buffer, c->lookup_mask, c->context_length, c->nesting_level_left - 1); |
} |
@@ -1583,6 +1606,5 @@ static inline bool position_lookup (hb_apply_context_t *c, unsigned int lookup_i |
#undef cursive_chain |
-HB_END_DECLS |
-#endif /* HB_OT_LAYOUT_GPOS_PRIVATE_HH */ |
+#endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */ |