1 /*
2 * Copyright © 2007,2008,2009,2010 Red Hat, Inc.
3 * Copyright © 2010,2012,2013 Google, Inc.
4 *
5 * This is part of HarfBuzz, a text shaping library.
6 *
7 * Permission is hereby granted, without written agreement and without
8 * license or royalty fees, to use, copy, modify, and distribute this
9 * software and its documentation for any purpose, provided that the
10 * above copyright notice and the following two paragraphs appear in
11 * all copies of this software.
12 *
13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
17 * DAMAGE.
18 *
19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
24 *
25 * Red Hat Author(s): Behdad Esfahbod
26 * Google Author(s): Behdad Esfahbod
27 */
28
29 #ifndef HB_OT_LAYOUT_GPOS_TABLE_HH
30 #define HB_OT_LAYOUT_GPOS_TABLE_HH
31
32 #include "hb-ot-layout-gsubgpos-private.hh"
33
34
35 namespace OT {
36
37
38 /* buffer **position** var allocations */
39 #define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */
40 #define attach_type() var.u8[2] /* attachment type */
41 /* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */
42
43 enum attach_type_t {
44 ATTACH_TYPE_NONE = 0X00,
45
46 /* Each attachment should be either a mark or a cursive; can't be both. */
47 ATTACH_TYPE_MARK = 0X01,
48 ATTACH_TYPE_CURSIVE = 0X02,
49 };
50
51
52 /* Shared Tables: ValueRecord, Anchor Table, and MarkArray */
53
54 typedef USHORT Value;
55
56 typedef Value ValueRecord[VAR];
57
58 struct ValueFormat : USHORT
59 {
60 enum Flags {
61 xPlacement = 0x0001u, /* Includes horizontal adjustment for placement */
62 yPlacement = 0x0002u, /* Includes vertical adjustment for placement */
63 xAdvance = 0x0004u, /* Includes horizontal adjustment for advance */
64 yAdvance = 0x0008u, /* Includes vertical adjustment for advance */
65 xPlaDevice = 0x0010u, /* Includes horizontal Device table for placement */
66 yPlaDevice = 0x0020u, /* Includes vertical Device table for placement */
67 xAdvDevice = 0x0040u, /* Includes horizontal Device table for advance */
68 yAdvDevice = 0x0080u, /* Includes vertical Device table for advance */
69 ignored = 0x0F00u, /* Was used in TrueType Open for MM fonts */
70 reserved = 0xF000u, /* For future use */
71
72 devices = 0x00F0u /* Mask for having any Device table */
73 };
74
75 /* All fields are options. Only those available advance the value pointer. */
76 #if 0
77 SHORT xPlacement; /* Horizontal adjustment for
78 * placement--in design units */
79 SHORT yPlacement; /* Vertical adjustment for
80 * placement--in design units */
81 SHORT xAdvance; /* Horizontal adjustment for
82 * advance--in design units (only used
83 * for horizontal writing) */
84 SHORT yAdvance; /* Vertical adjustment for advance--in
85 * design units (only used for vertical
86 * writing) */
87 Offset xPlaDevice; /* Offset to Device table for
88 * horizontal placement--measured from
89 * beginning of PosTable (may be NULL) */
90 Offset yPlaDevice; /* Offset to Device table for vertical
91 * placement--measured from beginning
92 * of PosTable (may be NULL) */
93 Offset xAdvDevice; /* Offset to Device table for
94 * horizontal advance--measured from
95 * beginning of PosTable (may be NULL) */
96 Offset yAdvDevice; /* Offset to Device table for vertical
97 * advance--measured from beginning of
98 * PosTable (may be NULL) */
99 #endif
100
101 inline unsigned int get_len (void) const
102 { return _hb_popcount32 ((unsigned int) *this); }
103 inline unsigned int get_size (void) const
104 { return get_len () * Value::static_size; }
105
106 void apply_value (hb_font_t *font,
107 hb_direction_t direction,
108 const void *base,
109 const Value *values,
110 hb_glyph_position_t &glyph_pos) const
111 {
112 unsigned int x_ppem, y_ppem;
113 unsigned int format = *this;
114 hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (direction);
115
116 if (!format) return;
117
118 if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++));
119 if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++));
120 if (format & xAdvance) {
121 if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values));
122 values++;
123 }
124 /* y_advance values grow downward but font-space grows upward, hence negation */
125 if (format & yAdvance) {
126 if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values));
127 values++;
128 }
129
130 if (!has_device ()) return;
131
132 x_ppem = font->x_ppem;
133 y_ppem = font->y_ppem;
134
135 if (!x_ppem && !y_ppem) return;
136
137 /* pixel -> fractional pixel */
138 if (format & xPlaDevice) {
139 if (x_ppem) glyph_pos.x_offset += (base + get_device (values)).get_x_delta (font);
140 values++;
141 }
142 if (format & yPlaDevice) {
143 if (y_ppem) glyph_pos.y_offset += (base + get_device (values)).get_y_delta (font);
144 values++;
145 }
146 if (format & xAdvDevice) {
147 if (horizontal && x_ppem) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font);
148 values++;
149 }
150 if (format & yAdvDevice) {
151 /* y_advance values grow downward but font-space grows upward, hence negation */
152 if (!horizontal && y_ppem) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font);
153 values++;
154 }
155 }
156
157 private:
158 inline bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const
159 {
160 unsigned int format = *this;
161
162 if (format & xPlacement) values++;
163 if (format & yPlacement) values++;
164 if (format & xAdvance) values++;
165 if (format & yAdvance) values++;
166
167 if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
168 if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
169 if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
170 if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
171
172 return true;
173 }
174
175 static inline OffsetTo<Device>& get_device (Value* value)
176 { return *CastP<OffsetTo<Device> > (value); }
177 static inline const OffsetTo<Device>& get_device (const Value* value)
178 { return *CastP<OffsetTo<Device> > (value); }
179
180 static inline const SHORT& get_short (const Value* value)
181 { return *CastP<SHORT> (value); }
182
183 public:
184
185 inline bool has_device (void) const {
186 unsigned int format = *this;
187 return (format & devices) != 0;
188 }
189
190 inline bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const
191 {
192 TRACE_SANITIZE (this);
193 return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));
194 }
195
196 inline bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const
197 {
198 TRACE_SANITIZE (this);
199 unsigned int len = get_len ();
200
201 if (!c->check_array (values, get_size (), count)) return_trace (false);
202
203 if (!has_device ()) return_trace (true);
204
205 for (unsigned int i = 0; i < count; i++) {
206 if (!sanitize_value_devices (c, base, values))
207 return_trace (false);
208 values += len;
209 }
210
211 return_trace (true);
212 }
213
214 /* Just sanitize referenced Device tables. Doesn't check the values themselves. */
215 inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const
216 {
217 TRACE_SANITIZE (this);
218
219 if (!has_device ()) return_trace (true);
220
221 for (unsigned int i = 0; i < count; i++) {
222 if (!sanitize_value_devices (c, base, values))
223 return_trace (false);
224 values += stride;
225 }
226
227 return_trace (true);
228 }
229 };
230
231
232 struct AnchorFormat1
233 {
234 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
235 hb_position_t *x, hb_position_t *y) const
236 {
237 *x = font->em_scale_x (xCoordinate);
238 *y = font->em_scale_y (yCoordinate);
239 }
240
241 inline bool sanitize (hb_sanitize_context_t *c) const
242 {
243 TRACE_SANITIZE (this);
244 return_trace (c->check_struct (this));
245 }
246
247 protected:
248 USHORT format; /* Format identifier--format = 1 */
249 SHORT xCoordinate; /* Horizontal value--in design units */
250 SHORT yCoordinate; /* Vertical value--in design units */
251 public:
252 DEFINE_SIZE_STATIC (6);
253 };
254
255 struct AnchorFormat2
256 {
257 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
258 hb_position_t *x, hb_position_t *y) const
259 {
260 unsigned int x_ppem = font->x_ppem;
261 unsigned int y_ppem = font->y_ppem;
262 hb_position_t cx, cy;
263 hb_bool_t ret;
264
265 ret = (x_ppem || y_ppem) &&
266 font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
267 *x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);
268 *y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);
269 }
270
271 inline bool sanitize (hb_sanitize_context_t *c) const
272 {
273 TRACE_SANITIZE (this);
274 return_trace (c->check_struct (this));
275 }
276
277 protected:
278 USHORT format; /* Format identifier--format = 2 */
279 SHORT xCoordinate; /* Horizontal value--in design units */
280 SHORT yCoordinate; /* Vertical value--in design units */
281 USHORT anchorPoint; /* Index to glyph contour point */
282 public:
283 DEFINE_SIZE_STATIC (8);
284 };
285
286 struct AnchorFormat3
287 {
288 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
289 hb_position_t *x, hb_position_t *y) const
290 {
291 *x = font->em_scale_x (xCoordinate);
292 *y = font->em_scale_y (yCoordinate);
293
294 if (font->x_ppem)
295 *x += (this+xDeviceTable).get_x_delta (font);
296 if (font->y_ppem)
297 *y += (this+yDeviceTable).get_x_delta (font);
298 }
299
300 inline bool sanitize (hb_sanitize_context_t *c) const
301 {
302 TRACE_SANITIZE (this);
303 return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));
304 }
305
306 protected:
307 USHORT format; /* Format identifier--format = 3 */
308 SHORT xCoordinate; /* Horizontal value--in design units */
309 SHORT yCoordinate; /* Vertical value--in design units */
310 OffsetTo<Device>
311 xDeviceTable; /* Offset to Device table for X
312 * coordinate-- from beginning of
313 * Anchor table (may be NULL) */
314 OffsetTo<Device>
315 yDeviceTable; /* Offset to Device table for Y
316 * coordinate-- from beginning of
317 * Anchor table (may be NULL) */
318 public:
319 DEFINE_SIZE_STATIC (10);
320 };
321
322 struct Anchor
323 {
324 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
325 hb_position_t *x, hb_position_t *y) const
326 {
327 *x = *y = 0;
328 switch (u.format) {
329 case 1: u.format1.get_anchor (font, glyph_id, x, y); return;
330 case 2: u.format2.get_anchor (font, glyph_id, x, y); return;
331 case 3: u.format3.get_anchor (font, glyph_id, x, y); return;
332 default: return;
333 }
334 }
335
336 inline bool sanitize (hb_sanitize_context_t *c) const
337 {
338 TRACE_SANITIZE (this);
339 if (!u.format.sanitize (c)) return_trace (false);
340 switch (u.format) {
341 case 1: return_trace (u.format1.sanitize (c));
342 case 2: return_trace (u.format2.sanitize (c));
343 case 3: return_trace (u.format3.sanitize (c));
344 default:return_trace (true);
345 }
346 }
347
348 protected:
349 union {
350 USHORT format; /* Format identifier */
351 AnchorFormat1 format1;
352 AnchorFormat2 format2;
353 AnchorFormat3 format3;
354 } u;
355 public:
356 DEFINE_SIZE_UNION (2, format);
357 };
358
359
360 struct AnchorMatrix
361 {
362 inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols, bool *found) const {
363 *found = false;
364 if (unlikely (row >= rows || col >= cols)) return Null(Anchor);
365 *found = !matrixZ[row * cols + col].is_null ();
366 return this+matrixZ[row * cols + col];
367 }
368
369 inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const
370 {
371 TRACE_SANITIZE (this);
372 if (!c->check_struct (this)) return_trace (false);
373 if (unlikely (rows > 0 && cols >= ((unsigned int) -1) / rows)) return_trace (false);
374 unsigned int count = rows * cols;
375 if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return_trace (false);
376 for (unsigned int i = 0; i < count; i++)
377 if (!matrixZ[i].sanitize (c, this)) return_trace (false);
378 return_trace (true);
379 }
380
381 USHORT rows; /* Number of rows */
382 protected:
383 OffsetTo<Anchor>
384 matrixZ[VAR]; /* Matrix of offsets to Anchor tables--
385 * from beginning of AnchorMatrix table */
386 public:
387 DEFINE_SIZE_ARRAY (2, matrixZ);
388 };
389
390
391 struct MarkRecord
392 {
393 friend struct MarkArray;
394
395 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
396 {
397 TRACE_SANITIZE (this);
398 return_trace (c->check_struct (this) && markAnchor.sanitize (c, base));
399 }
400
401 protected:
402 USHORT klass; /* Class defined for this mark */
403 OffsetTo<Anchor>
404 markAnchor; /* Offset to Anchor table--from
405 * beginning of MarkArray table */
406 public:
407 DEFINE_SIZE_STATIC (4);
408 };
409
410 struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage order */
411 {
412 inline bool apply (hb_apply_context_t *c,
413 unsigned int mark_index, unsigned int glyph_index,
414 const AnchorMatrix &anchors, unsigned int class_count,
415 unsigned int glyph_pos) const
416 {
417 TRACE_APPLY (this);
418 hb_buffer_t *buffer = c->buffer;
419 const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);
420 unsigned int mark_class = record.klass;
421
422 const Anchor& mark_anchor = this + record.markAnchor;
423 bool found;
424 const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);
425 /* If this subtable doesn't have an anchor for this base and this class,
426 * return false such that the subsequent subtables have a chance at it. */
427 if (unlikely (!found)) return_trace (false);
428
429 hb_position_t mark_x, mark_y, base_x, base_y;
430
431 mark_anchor.get_anchor (c->font, buffer->cur().codepoint, &mark_x, &mark_y);
432 glyph_anchor.get_anchor (c->font, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
433
434 hb_glyph_position_t &o = buffer->cur_pos();
435 o.x_offset = base_x - mark_x;
436 o.y_offset = base_y - mark_y;
437 o.attach_type() = ATTACH_TYPE_MARK;
438 o.attach_chain() = (int) glyph_pos - (int) buffer->idx;
439 buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
440
441 buffer->idx++;
442 return_trace (true);
443 }
444
445 inline bool sanitize (hb_sanitize_context_t *c) const
446 {
447 TRACE_SANITIZE (this);
448 return_trace (ArrayOf<MarkRecord>::sanitize (c, this));
449 }
450 };
451
452
453 /* Lookups */
454
455 struct SinglePosFormat1
456 {
457 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
458 {
459 TRACE_COLLECT_GLYPHS (this);
460 (this+coverage).add_coverage (c->input);
461 }
462
463 inline const Coverage &get_coverage (void) const
464 {
465 return this+coverage;
466 }
467
468 inline bool apply (hb_apply_context_t *c) const
469 {
470 TRACE_APPLY (this);
471 hb_buffer_t *buffer = c->buffer;
472 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
473 if (likely (index == NOT_COVERED)) return_trace (false);
474
475 valueFormat.apply_value (c->font, c->direction, this,
476 values, buffer->cur_pos());
477
478 buffer->idx++;
479 return_trace (true);
480 }
481
482 inline bool sanitize (hb_sanitize_context_t *c) const
483 {
484 TRACE_SANITIZE (this);
485 return_trace (c->check_struct (this) &&
486 coverage.sanitize (c, this) &&
487 valueFormat.sanitize_value (c, this, values));
488 }
489
490 protected:
491 USHORT format; /* Format identifier--format = 1 */
492 OffsetTo<Coverage>
493 coverage; /* Offset to Coverage table--from
494 * beginning of subtable */
495 ValueFormat valueFormat; /* Defines the types of data in the
496 * ValueRecord */
497 ValueRecord values; /* Defines positioning
498 * value(s)--applied to all glyphs in
499 * the Coverage table */
500 public:
501 DEFINE_SIZE_ARRAY (6, values);
502 };
503
504 struct SinglePosFormat2
505 {
506 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
507 {
508 TRACE_COLLECT_GLYPHS (this);
509 (this+coverage).add_coverage (c->input);
510 }
511
512 inline const Coverage &get_coverage (void) const
513 {
514 return this+coverage;
515 }
516
517 inline bool apply (hb_apply_context_t *c) const
518 {
519 TRACE_APPLY (this);
520 hb_buffer_t *buffer = c->buffer;
521 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
522 if (likely (index == NOT_COVERED)) return_trace (false);
523
524 if (likely (index >= valueCount)) return_trace (false);
525
526 valueFormat.apply_value (c->font, c->direction, this,
527 &values[index * valueFormat.get_len ()],
528 buffer->cur_pos());
529
530 buffer->idx++;
531 return_trace (true);
532 }
533
534 inline bool sanitize (hb_sanitize_context_t *c) const
535 {
536 TRACE_SANITIZE (this);
537 return_trace (c->check_struct (this) &&
538 coverage.sanitize (c, this) &&
539 valueFormat.sanitize_values (c, this, values, valueCount));
540 }
541
542 protected:
543 USHORT format; /* Format identifier--format = 2 */
544 OffsetTo<Coverage>
545 coverage; /* Offset to Coverage table--from
546 * beginning of subtable */
547 ValueFormat valueFormat; /* Defines the types of data in the
548 * ValueRecord */
549 USHORT valueCount; /* Number of ValueRecords */
550 ValueRecord values; /* Array of ValueRecords--positioning
551 * values applied to glyphs */
552 public:
553 DEFINE_SIZE_ARRAY (8, values);
554 };
555
556 struct SinglePos
557 {
558 template <typename context_t>
559 inline typename context_t::return_t dispatch (context_t *c) const
560 {
561 TRACE_DISPATCH (this, u.format);
562 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
563 switch (u.format) {
564 case 1: return_trace (c->dispatch (u.format1));
565 case 2: return_trace (c->dispatch (u.format2));
566 default:return_trace (c->default_return_value ());
567 }
568 }
569
570 protected:
571 union {
572 USHORT format; /* Format identifier */
573 SinglePosFormat1 format1;
574 SinglePosFormat2 format2;
575 } u;
576 };
577
578
579 struct PairValueRecord
580 {
581 friend struct PairSet;
582
583 protected:
584 GlyphID secondGlyph; /* GlyphID of second glyph in the
585 * pair--first glyph is listed in the
586 * Coverage table */
587 ValueRecord values; /* Positioning data for the first glyph
588 * followed by for second glyph */
589 public:
590 DEFINE_SIZE_ARRAY (2, values);
591 };
592
593 struct PairSet
594 {
595 friend struct PairPosFormat1;
596
597 inline void collect_glyphs (hb_collect_glyphs_context_t *c,
598 const ValueFormat *valueFormats) const
599 {
600 TRACE_COLLECT_GLYPHS (this);
601 unsigned int len1 = valueFormats[0].get_len ();
602 unsigned int len2 = valueFormats[1].get_len ();
603 unsigned int record_size = USHORT::static_size * (1 + len1 + len2);
604
605 const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);
606 unsigned int count = len;
607 for (unsigned int i = 0; i < count; i++)
608 {
609 c->input->add (record->secondGlyph);
610 record = &StructAtOffset<PairValueRecord> (record, record_size);
611 }
612 }
613
614 inline bool apply (hb_apply_context_t *c,
615 const ValueFormat *valueFormats,
616 unsigned int pos) const
617 {
618 TRACE_APPLY (this);
619 hb_buffer_t *buffer = c->buffer;
620 unsigned int len1 = valueFormats[0].get_len ();
621 unsigned int len2 = valueFormats[1].get_len ();
622 unsigned int record_size = USHORT::static_size * (1 + len1 + len2);
623
624 const PairValueRecord *record_array = CastP<PairValueRecord> (arrayZ);
625 unsigned int count = len;
626
627 /* Hand-coded bsearch. */
628 if (unlikely (!count))
629 return_trace (false);
630 hb_codepoint_t x = buffer->info[pos].codepoint;
631 int min = 0, max = (int) count - 1;
632 while (min <= max)
633 {
634 int mid = (min + max) / 2;
635 const PairValueRecord *record = &StructAtOffset<PairValueRecord> (record_array, record_size * mid);
636 hb_codepoint_t mid_x = record->secondGlyph;
637 if (x < mid_x)
638 max = mid - 1;
639 else if (x > mid_x)
640 min = mid + 1;
641 else
642 {
643 valueFormats[0].apply_value (c->font, c->direction, this,
644 &record->values[0], buffer->cur_pos());
645 valueFormats[1].apply_value (c->font, c->direction, this,
646 &record->values[len1], buffer->pos[pos]);
647 if (len2)
648 pos++;
649 buffer->idx = pos;
650 return_trace (true);
651 }
652 }
653
654 return_trace (false);
655 }
656
657 struct sanitize_closure_t {
658 const void *base;
659 const ValueFormat *valueFormats;
660 unsigned int len1; /* valueFormats[0].get_len() */
661 unsigned int stride; /* 1 + len1 + len2 */
662 };
663
664 inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const
665 {
666 TRACE_SANITIZE (this);
667 if (!(c->check_struct (this)
668 && c->check_array (arrayZ, USHORT::static_size * closure->stride, len))) return_trace (false);
669
670 unsigned int count = len;
671 const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);
672 return_trace (closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride) &&
673 closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride));
674 }
675
676 protected:
677 USHORT len; /* Number of PairValueRecords */
678 USHORT arrayZ[VAR]; /* Array of PairValueRecords--ordered
679 * by GlyphID of the second glyph */
680 public:
681 DEFINE_SIZE_ARRAY (2, arrayZ);
682 };
683
684 struct PairPosFormat1
685 {
686 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
687 {
688 TRACE_COLLECT_GLYPHS (this);
689 (this+coverage).add_coverage (c->input);
690 unsigned int count = pairSet.len;
691 for (unsigned int i = 0; i < count; i++)
692 (this+pairSet[i]).collect_glyphs (c, &valueFormat1);
693 }
694
695 inline const Coverage &get_coverage (void) const
696 {
697 return this+coverage;
698 }
699
700 inline bool apply (hb_apply_context_t *c) const
701 {
702 TRACE_APPLY (this);
703 hb_buffer_t *buffer = c->buffer;
704 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
705 if (likely (index == NOT_COVERED)) return_trace (false);
706
707 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
708 skippy_iter.reset (buffer->idx, 1);
709 if (!skippy_iter.next ()) return_trace (false);
710
711 return_trace ((this+pairSet[index]).apply (c, &valueFormat1, skippy_iter.idx));
712 }
713
714 inline bool sanitize (hb_sanitize_context_t *c) const
715 {
716 TRACE_SANITIZE (this);
717
718 if (!c->check_struct (this)) return_trace (false);
719
720 unsigned int len1 = valueFormat1.get_len ();
721 unsigned int len2 = valueFormat2.get_len ();
722 PairSet::sanitize_closure_t closure = {
723 this,
724 &valueFormat1,
725 len1,
726 1 + len1 + len2
727 };
728
729 return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));
730 }
731
732 protected:
733 USHORT format; /* Format identifier--format = 1 */
734 OffsetTo<Coverage>
735 coverage; /* Offset to Coverage table--from
736 * beginning of subtable */
737 ValueFormat valueFormat1; /* Defines the types of data in
738 * ValueRecord1--for the first glyph
739 * in the pair--may be zero (0) */
740 ValueFormat valueFormat2; /* Defines the types of data in
741 * ValueRecord2--for the second glyph
742 * in the pair--may be zero (0) */
743 OffsetArrayOf<PairSet>
744 pairSet; /* Array of PairSet tables
745 * ordered by Coverage Index */
746 public:
747 DEFINE_SIZE_ARRAY (10, pairSet);
748 };
749
750 struct PairPosFormat2
751 {
752 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
753 {
754 TRACE_COLLECT_GLYPHS (this);
755 (this+coverage).add_coverage (c->input);
756
757 unsigned int count1 = class1Count;
758 const ClassDef &klass1 = this+classDef1;
759 for (unsigned int i = 0; i < count1; i++)
760 klass1.add_class (c->input, i);
761
762 unsigned int count2 = class2Count;
763 const ClassDef &klass2 = this+classDef2;
764 for (unsigned int i = 0; i < count2; i++)
765 klass2.add_class (c->input, i);
766 }
767
768 inline const Coverage &get_coverage (void) const
769 {
770 return this+coverage;
771 }
772
773 inline bool apply (hb_apply_context_t *c) const
774 {
775 TRACE_APPLY (this);
776 hb_buffer_t *buffer = c->buffer;
777 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
778 if (likely (index == NOT_COVERED)) return_trace (false);
779
780 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
781 skippy_iter.reset (buffer->idx, 1);
782 if (!skippy_iter.next ()) return_trace (false);
783
784 unsigned int len1 = valueFormat1.get_len ();
785 unsigned int len2 = valueFormat2.get_len ();
786 unsigned int record_len = len1 + len2;
787
788 unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);
789 unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
790 if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false);
791
792 const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
793 valueFormat1.apply_value (c->font, c->direction, this,
794 v, buffer->cur_pos());
795 valueFormat2.apply_value (c->font, c->direction, this,
796 v + len1, buffer->pos[skippy_iter.idx]);
797
798 buffer->idx = skippy_iter.idx;
799 if (len2)
800 buffer->idx++;
801
802 return_trace (true);
803 }
804
805 inline bool sanitize (hb_sanitize_context_t *c) const
806 {
807 TRACE_SANITIZE (this);
808 if (!(c->check_struct (this)
809 && coverage.sanitize (c, this)
810 && classDef1.sanitize (c, this)
811 && classDef2.sanitize (c, this))) return_trace (false);
812
813 unsigned int len1 = valueFormat1.get_len ();
814 unsigned int len2 = valueFormat2.get_len ();
815 unsigned int stride = len1 + len2;
816 unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
817 unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
818 return_trace (c->check_array (values, record_size, count) &&
819 valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
820 valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride));
821 }
822
823 protected:
824 USHORT format; /* Format identifier--format = 2 */
825 OffsetTo<Coverage>
826 coverage; /* Offset to Coverage table--from
827 * beginning of subtable */
828 ValueFormat valueFormat1; /* ValueRecord definition--for the
829 * first glyph of the pair--may be zero
830 * (0) */
831 ValueFormat valueFormat2; /* ValueRecord definition--for the
832 * second glyph of the pair--may be
833 * zero (0) */
834 OffsetTo<ClassDef>
835 classDef1; /* Offset to ClassDef table--from
836 * beginning of PairPos subtable--for
837 * the first glyph of the pair */
838 OffsetTo<ClassDef>
839 classDef2; /* Offset to ClassDef table--from
840 * beginning of PairPos subtable--for
841 * the second glyph of the pair */
842 USHORT class1Count; /* Number of classes in ClassDef1
843 * table--includes Class0 */
844 USHORT class2Count; /* Number of classes in ClassDef2
845 * table--includes Class0 */
846 ValueRecord values; /* Matrix of value pairs:
847 * class1-major, class2-minor,
848 * Each entry has value1 and value2 */
849 public:
850 DEFINE_SIZE_ARRAY (16, values);
851 };
852
853 struct PairPos
854 {
855 template <typename context_t>
856 inline typename context_t::return_t dispatch (context_t *c) const
857 {
858 TRACE_DISPATCH (this, u.format);
859 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
860 switch (u.format) {
861 case 1: return_trace (c->dispatch (u.format1));
862 case 2: return_trace (c->dispatch (u.format2));
863 default:return_trace (c->default_return_value ());
864 }
865 }
866
867 protected:
868 union {
869 USHORT format; /* Format identifier */
870 PairPosFormat1 format1;
871 PairPosFormat2 format2;
872 } u;
873 };
874
875
876 struct EntryExitRecord
877 {
878 friend struct CursivePosFormat1;
879
880 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
881 {
882 TRACE_SANITIZE (this);
883 return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));
884 }
885
886 protected:
887 OffsetTo<Anchor>
888 entryAnchor; /* Offset to EntryAnchor table--from
889 * beginning of CursivePos
890 * subtable--may be NULL */
891 OffsetTo<Anchor>
892 exitAnchor; /* Offset to ExitAnchor table--from
893 * beginning of CursivePos
894 * subtable--may be NULL */
895 public:
896 DEFINE_SIZE_STATIC (4);
897 };
898
899 static void
900 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent);
901
902 struct CursivePosFormat1
903 {
904 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
905 {
906 TRACE_COLLECT_GLYPHS (this);
907 (this+coverage).add_coverage (c->input);
908 }
909
910 inline const Coverage &get_coverage (void) const
911 {
912 return this+coverage;
913 }
914
915 inline bool apply (hb_apply_context_t *c) const
916 {
917 TRACE_APPLY (this);
918 hb_buffer_t *buffer = c->buffer;
919
920 const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage (buffer->cur().codepoint)];
921 if (!this_record.exitAnchor) return_trace (false);
922
923 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
924 skippy_iter.reset (buffer->idx, 1);
925 if (!skippy_iter.next ()) return_trace (false);
926
927 const EntryExitRecord &next_record = entryExitRecord[(this+coverage).get_coverage (buffer->info[skippy_iter.idx].codepoint)];
928 if (!next_record.entryAnchor) return_trace (false);
929
930 unsigned int i = buffer->idx;
931 unsigned int j = skippy_iter.idx;
932
933 hb_position_t entry_x, entry_y, exit_x, exit_y;
934 (this+this_record.exitAnchor).get_anchor (c->font, buffer->info[i].codepoint, &exit_x, &exit_y);
935 (this+next_record.entryAnchor).get_anchor (c->font, buffer->info[j].codepoint, &entry_x, &entry_y);
936
937 hb_glyph_position_t *pos = buffer->pos;
938
939 hb_position_t d;
940 /* Main-direction adjustment */
941 switch (c->direction) {
942 case HB_DIRECTION_LTR:
943 pos[i].x_advance = exit_x + pos[i].x_offset;
944
945 d = entry_x + pos[j].x_offset;
946 pos[j].x_advance -= d;
947 pos[j].x_offset -= d;
948 break;
949 case HB_DIRECTION_RTL:
950 d = exit_x + pos[i].x_offset;
951 pos[i].x_advance -= d;
952 pos[i].x_offset -= d;
953
954 pos[j].x_advance = entry_x + pos[j].x_offset;
955 break;
956 case HB_DIRECTION_TTB:
957 pos[i].y_advance = exit_y + pos[i].y_offset;
958
959 d = entry_y + pos[j].y_offset;
960 pos[j].y_advance -= d;
961 pos[j].y_offset -= d;
962 break;
963 case HB_DIRECTION_BTT:
964 d = exit_y + pos[i].y_offset;
965 pos[i].y_advance -= d;
966 pos[i].y_offset -= d;
967
968 pos[j].y_advance = entry_y;
969 break;
970 case HB_DIRECTION_INVALID:
971 default:
972 break;
973 }
974
975 /* Cross-direction adjustment */
976
977 /* We attach child to parent (think graph theory and rooted trees whereas
978 * the root stays on baseline and each node aligns itself against its
979 * parent.
980 *
981 * Optimize things for the case of RightToLeft, as that's most common in
982 * Arabinc. */
983 unsigned int child = i;
984 unsigned int parent = j;
985 hb_position_t x_offset = entry_x - exit_x;
986 hb_position_t y_offset = entry_y - exit_y;
987 if (!(c->lookup_props & LookupFlag::RightToLeft))
988 {
989 unsigned int k = child;
990 child = parent;
991 parent = k;
992 x_offset = -x_offset;
993 y_offset = -y_offset;
994 }
995
996 /* If child was already connected to someone else, walk through its old
997 * chain and reverse the link direction, such that the whole tree of its
998 * previous connection now attaches to new parent. Watch out for case
999 * where new parent is on the path from old chain...
1000 */
1001 reverse_cursive_minor_offset (pos, child, c->direction, parent);
1002
1003 pos[child].attach_type() = ATTACH_TYPE_CURSIVE;
1004 pos[child].attach_chain() = (int) parent - (int) child;
1005 buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
1006 if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
1007 pos[child].y_offset = y_offset;
1008 else
1009 pos[child].x_offset = x_offset;
1010
1011 buffer->idx = j;
1012 return_trace (true);
1013 }
1014
1015 inline bool sanitize (hb_sanitize_context_t *c) const
1016 {
1017 TRACE_SANITIZE (this);
1018 return_trace (coverage.sanitize (c, this) && entryExitRecord.sanitize (c, this));
1019 }
1020
1021 protected:
1022 USHORT format; /* Format identifier--format = 1 */
1023 OffsetTo<Coverage>
1024 coverage; /* Offset to Coverage table--from
1025 * beginning of subtable */
1026 ArrayOf<EntryExitRecord>
1027 entryExitRecord; /* Array of EntryExit records--in
1028 * Coverage Index order */
1029 public:
1030 DEFINE_SIZE_ARRAY (6, entryExitRecord);
1031 };
1032
1033 struct CursivePos
1034 {
1035 template <typename context_t>
1036 inline typename context_t::return_t dispatch (context_t *c) const
1037 {
1038 TRACE_DISPATCH (this, u.format);
1039 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1040 switch (u.format) {
1041 case 1: return_trace (c->dispatch (u.format1));
1042 default:return_trace (c->default_return_value ());
1043 }
1044 }
1045
1046 protected:
1047 union {
1048 USHORT format; /* Format identifier */
1049 CursivePosFormat1 format1;
1050 } u;
1051 };
1052
1053
1054 typedef AnchorMatrix BaseArray; /* base-major--
1055 * in order of BaseCoverage Index--,
1056 * mark-minor--
1057 * ordered by class--zero-based. */
1058
1059 struct MarkBasePosFormat1
1060 {
1061 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1062 {
1063 TRACE_COLLECT_GLYPHS (this);
1064 (this+markCoverage).add_coverage (c->input);
1065 (this+baseCoverage).add_coverage (c->input);
1066 }
1067
1068 inline const Coverage &get_coverage (void) const
1069 {
1070 return this+markCoverage;
1071 }
1072
1073 inline bool apply (hb_apply_context_t *c) const
1074 {
1075 TRACE_APPLY (this);
1076 hb_buffer_t *buffer = c->buffer;
1077 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
1078 if (likely (mark_index == NOT_COVERED)) return_trace (false);
1079
1080 /* Now we search backwards for a non-mark glyph */
1081 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1082 skippy_iter.reset (buffer->idx, 1);
1083 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1084 do {
1085 if (!skippy_iter.prev ()) return_trace (false);
1086 /* We only want to attach to the first of a MultipleSubst sequence. Reject others. */
1087 if (0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx])) break;
1088 skippy_iter.reject ();
1089 } while (1);
1090
1091 /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */
1092 //if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1093
1094 unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[skippy_iter.idx].codepoint);
1095 if (base_index == NOT_COVERED) return_trace (false);
1096
1097 return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx));
1098 }
1099
1100 inline bool sanitize (hb_sanitize_context_t *c) const
1101 {
1102 TRACE_SANITIZE (this);
1103 return_trace (c->check_struct (this) &&
1104 markCoverage.sanitize (c, this) &&
1105 baseCoverage.sanitize (c, this) &&
1106 markArray.sanitize (c, this) &&
1107 baseArray.sanitize (c, this, (unsigned int) classCount));
1108 }
1109
1110 protected:
1111 USHORT format; /* Format identifier--format = 1 */
1112 OffsetTo<Coverage>
1113 markCoverage; /* Offset to MarkCoverage table--from
1114 * beginning of MarkBasePos subtable */
1115 OffsetTo<Coverage>
1116 baseCoverage; /* Offset to BaseCoverage table--from
1117 * beginning of MarkBasePos subtable */
1118 USHORT classCount; /* Number of classes defined for marks */
1119 OffsetTo<MarkArray>
1120 markArray; /* Offset to MarkArray table--from
1121 * beginning of MarkBasePos subtable */
1122 OffsetTo<BaseArray>
1123 baseArray; /* Offset to BaseArray table--from
1124 * beginning of MarkBasePos subtable */
1125 public:
1126 DEFINE_SIZE_STATIC (12);
1127 };
1128
1129 struct MarkBasePos
1130 {
1131 template <typename context_t>
1132 inline typename context_t::return_t dispatch (context_t *c) const
1133 {
1134 TRACE_DISPATCH (this, u.format);
1135 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1136 switch (u.format) {
1137 case 1: return_trace (c->dispatch (u.format1));
1138 default:return_trace (c->default_return_value ());
1139 }
1140 }
1141
1142 protected:
1143 union {
1144 USHORT format; /* Format identifier */
1145 MarkBasePosFormat1 format1;
1146 } u;
1147 };
1148
1149
1150 typedef AnchorMatrix LigatureAttach; /* component-major--
1151 * in order of writing direction--,
1152 * mark-minor--
1153 * ordered by class--zero-based. */
1154
1155 typedef OffsetListOf<LigatureAttach> LigatureArray;
1156 /* Array of LigatureAttach
1157 * tables ordered by
1158 * LigatureCoverage Index */
1159
1160 struct MarkLigPosFormat1
1161 {
1162 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1163 {
1164 TRACE_COLLECT_GLYPHS (this);
1165 (this+markCoverage).add_coverage (c->input);
1166 (this+ligatureCoverage).add_coverage (c->input);
1167 }
1168
1169 inline const Coverage &get_coverage (void) const
1170 {
1171 return this+markCoverage;
1172 }
1173
1174 inline bool apply (hb_apply_context_t *c) const
1175 {
1176 TRACE_APPLY (this);
1177 hb_buffer_t *buffer = c->buffer;
1178 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
1179 if (likely (mark_index == NOT_COVERED)) return_trace (false);
1180
1181 /* Now we search backwards for a non-mark glyph */
1182 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1183 skippy_iter.reset (buffer->idx, 1);
1184 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1185 if (!skippy_iter.prev ()) return_trace (false);
1186
1187 /* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */
1188 //if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1189
1190 unsigned int j = skippy_iter.idx;
1191 unsigned int lig_index = (this+ligatureCoverage).get_coverage (buffer->info[j].codepoint);
1192 if (lig_index == NOT_COVERED) return_trace (false);
1193
1194 const LigatureArray& lig_array = this+ligatureArray;
1195 const LigatureAttach& lig_attach = lig_array[lig_index];
1196
1197 /* Find component to attach to */
1198 unsigned int comp_count = lig_attach.rows;
1199 if (unlikely (!comp_count)) return_trace (false);
1200
1201 /* We must now check whether the ligature ID of the current mark glyph
1202 * is identical to the ligature ID of the found ligature. If yes, we
1203 * can directly use the component index. If not, we attach the mark
1204 * glyph to the last component of the ligature. */
1205 unsigned int comp_index;
1206 unsigned int lig_id = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1207 unsigned int mark_id = _hb_glyph_info_get_lig_id (&buffer->cur());
1208 unsigned int mark_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
1209 if (lig_id && lig_id == mark_id && mark_comp > 0)
1210 comp_index = MIN (comp_count, _hb_glyph_info_get_lig_comp (&buffer->cur())) - 1;
1211 else
1212 comp_index = comp_count - 1;
1213
1214 return_trace ((this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j));
1215 }
1216
1217 inline bool sanitize (hb_sanitize_context_t *c) const
1218 {
1219 TRACE_SANITIZE (this);
1220 return_trace (c->check_struct (this) &&
1221 markCoverage.sanitize (c, this) &&
1222 ligatureCoverage.sanitize (c, this) &&
1223 markArray.sanitize (c, this) &&
1224 ligatureArray.sanitize (c, this, (unsigned int) classCount));
1225 }
1226
1227 protected:
1228 USHORT format; /* Format identifier--format = 1 */
1229 OffsetTo<Coverage>
1230 markCoverage; /* Offset to Mark Coverage table--from
1231 * beginning of MarkLigPos subtable */
1232 OffsetTo<Coverage>
1233 ligatureCoverage; /* Offset to Ligature Coverage
1234 * table--from beginning of MarkLigPos
1235 * subtable */
1236 USHORT classCount; /* Number of defined mark classes */
1237 OffsetTo<MarkArray>
1238 markArray; /* Offset to MarkArray table--from
1239 * beginning of MarkLigPos subtable */
1240 OffsetTo<LigatureArray>
1241 ligatureArray; /* Offset to LigatureArray table--from
1242 * beginning of MarkLigPos subtable */
1243 public:
1244 DEFINE_SIZE_STATIC (12);
1245 };
1246
1247 struct MarkLigPos
1248 {
1249 template <typename context_t>
1250 inline typename context_t::return_t dispatch (context_t *c) const
1251 {
1252 TRACE_DISPATCH (this, u.format);
1253 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1254 switch (u.format) {
1255 case 1: return_trace (c->dispatch (u.format1));
1256 default:return_trace (c->default_return_value ());
1257 }
1258 }
1259
1260 protected:
1261 union {
1262 USHORT format; /* Format identifier */
1263 MarkLigPosFormat1 format1;
1264 } u;
1265 };
1266
1267
1268 typedef AnchorMatrix Mark2Array; /* mark2-major--
1269 * in order of Mark2Coverage Index--,
1270 * mark1-minor--
1271 * ordered by class--zero-based. */
1272
1273 struct MarkMarkPosFormat1
1274 {
1275 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1276 {
1277 TRACE_COLLECT_GLYPHS (this);
1278 (this+mark1Coverage).add_coverage (c->input);
1279 (this+mark2Coverage).add_coverage (c->input);
1280 }
1281
1282 inline const Coverage &get_coverage (void) const
1283 {
1284 return this+mark1Coverage;
1285 }
1286
1287 inline bool apply (hb_apply_context_t *c) const
1288 {
1289 TRACE_APPLY (this);
1290 hb_buffer_t *buffer = c->buffer;
1291 unsigned int mark1_index = (this+mark1Coverage).get_coverage (buffer->cur().codepoint);
1292 if (likely (mark1_index == NOT_COVERED)) return_trace (false);
1293
1294 /* now we search backwards for a suitable mark glyph until a non-mark glyph */
1295 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1296 skippy_iter.reset (buffer->idx, 1);
1297 skippy_iter.set_lookup_props (c->lookup_props & ~LookupFlag::IgnoreFlags);
1298 if (!skippy_iter.prev ()) return_trace (false);
1299
1300 if (!_hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1301
1302 unsigned int j = skippy_iter.idx;
1303
1304 unsigned int id1 = _hb_glyph_info_get_lig_id (&buffer->cur());
1305 unsigned int id2 = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1306 unsigned int comp1 = _hb_glyph_info_get_lig_comp (&buffer->cur());
1307 unsigned int comp2 = _hb_glyph_info_get_lig_comp (&buffer->info[j]);
1308
1309 if (likely (id1 == id2)) {
1310 if (id1 == 0) /* Marks belonging to the same base. */
1311 goto good;
1312 else if (comp1 == comp2) /* Marks belonging to the same ligature component. */
1313 goto good;
1314 } else {
1315 /* If ligature ids don't match, it may be the case that one of the marks
1316 * itself is a ligature. In which case match. */
1317 if ((id1 > 0 && !comp1) || (id2 > 0 && !comp2))
1318 goto good;
1319 }
1320
1321 /* Didn't match. */
1322 return_trace (false);
1323
1324 good:
1325 unsigned int mark2_index = (this+mark2Coverage).get_coverage (buffer->info[j].codepoint);
1326 if (mark2_index == NOT_COVERED) return_trace (false);
1327
1328 return_trace ((this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j));
1329 }
1330
1331 inline bool sanitize (hb_sanitize_context_t *c) const
1332 {
1333 TRACE_SANITIZE (this);
1334 return_trace (c->check_struct (this) &&
1335 mark1Coverage.sanitize (c, this) &&
1336 mark2Coverage.sanitize (c, this) &&
1337 mark1Array.sanitize (c, this) &&
1338 mark2Array.sanitize (c, this, (unsigned int) classCount));
1339 }
1340
1341 protected:
1342 USHORT format; /* Format identifier--format = 1 */
1343 OffsetTo<Coverage>
1344 mark1Coverage; /* Offset to Combining Mark1 Coverage
1345 * table--from beginning of MarkMarkPos
1346 * subtable */
1347 OffsetTo<Coverage>
1348 mark2Coverage; /* Offset to Combining Mark2 Coverage
1349 * table--from beginning of MarkMarkPos
1350 * subtable */
1351 USHORT classCount; /* Number of defined mark classes */
1352 OffsetTo<MarkArray>
1353 mark1Array; /* Offset to Mark1Array table--from
1354 * beginning of MarkMarkPos subtable */
1355 OffsetTo<Mark2Array>
1356 mark2Array; /* Offset to Mark2Array table--from
1357 * beginning of MarkMarkPos subtable */
1358 public:
1359 DEFINE_SIZE_STATIC (12);
1360 };
1361
1362 struct MarkMarkPos
1363 {
1364 template <typename context_t>
1365 inline typename context_t::return_t dispatch (context_t *c) const
1366 {
1367 TRACE_DISPATCH (this, u.format);
1368 if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1369 switch (u.format) {
1370 case 1: return_trace (c->dispatch (u.format1));
1371 default:return_trace (c->default_return_value ());
1372 }
1373 }
1374
1375 protected:
1376 union {
1377 USHORT format; /* Format identifier */
1378 MarkMarkPosFormat1 format1;
1379 } u;
1380 };
1381
1382
1383 struct ContextPos : Context {};
1384
1385 struct ChainContextPos : ChainContext {};
1386
1387 struct ExtensionPos : Extension<ExtensionPos>
1388 {
1389 typedef struct PosLookupSubTable LookupSubTable;
1390 };
1391
1392
1393
1394 /*
1395 * PosLookup
1396 */
1397
1398
1399 struct PosLookupSubTable
1400 {
1401 friend struct PosLookup;
1402
1403 enum Type {
1404 Single = 1,
1405 Pair = 2,
1406 Cursive = 3,
1407 MarkBase = 4,
1408 MarkLig = 5,
1409 MarkMark = 6,
1410 Context = 7,
1411 ChainContext = 8,
1412 Extension = 9
1413 };
1414
1415 template <typename context_t>
1416 inline typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type) const
1417 {
1418 TRACE_DISPATCH (this, lookup_type);
1419 if (unlikely (!c->may_dispatch (this, &u.sub_format))) return_trace (c->no_dispatch_return_value ());
1420 switch (lookup_type) {
1421 case Single: return_trace (u.single.dispatch (c));
1422 case Pair: return_trace (u.pair.dispatch (c));
1423 case Cursive: return_trace (u.cursive.dispatch (c));
1424 case MarkBase: return_trace (u.markBase.dispatch (c));
1425 case MarkLig: return_trace (u.markLig.dispatch (c));
1426 case MarkMark: return_trace (u.markMark.dispatch (c));
1427 case Context: return_trace (u.context.dispatch (c));
1428 case ChainContext: return_trace (u.chainContext.dispatch (c));
1429 case Extension: return_trace (u.extension.dispatch (c));
1430 default: return_trace (c->default_return_value ());
1431 }
1432 }
1433
1434 protected:
1435 union {
1436 USHORT sub_format;
1437 SinglePos single;
1438 PairPos pair;
1439 CursivePos cursive;
1440 MarkBasePos markBase;
1441 MarkLigPos markLig;
1442 MarkMarkPos markMark;
1443 ContextPos context;
1444 ChainContextPos chainContext;
1445 ExtensionPos extension;
1446 } u;
1447 public:
1448 DEFINE_SIZE_UNION (2, sub_format);
1449 };
1450
1451
1452 struct PosLookup : Lookup
1453 {
1454 inline const PosLookupSubTable& get_subtable (unsigned int i) const
1455 { return Lookup::get_subtable<PosLookupSubTable> (i); }
1456
1457 inline bool is_reverse (void) const
1458 {
1459 return false;
1460 }
1461
1462 inline bool apply (hb_apply_context_t *c) const
1463 {
1464 TRACE_APPLY (this);
1465 return_trace (dispatch (c));
1466 }
1467
1468 inline hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
1469 {
1470 TRACE_COLLECT_GLYPHS (this);
1471 return_trace (dispatch (c));
1472 }
1473
1474 template <typename set_t>
1475 inline void add_coverage (set_t *glyphs) const
1476 {
1477 hb_add_coverage_context_t<set_t> c (glyphs);
1478 dispatch (&c);
1479 }
1480
1481 static bool apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index);
1482
1483 template <typename context_t>
1484 static inline typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
1485
1486 template <typename context_t>
1487 inline typename context_t::return_t dispatch (context_t *c) const
1488 { return Lookup::dispatch<PosLookupSubTable> (c); }
1489
1490 inline bool sanitize (hb_sanitize_context_t *c) const
1491 {
1492 TRACE_SANITIZE (this);
1493 if (unlikely (!Lookup::sanitize (c))) return_trace (false);
1494 return_trace (dispatch (c));
1495 }
1496 };
1497
1498 typedef OffsetListOf<PosLookup> PosLookupList;
1499
1500 /*
1501 * GPOS -- The Glyph Positioning Table
1502 */
1503
1504 struct GPOS : GSUBGPOS
1505 {
1506 static const hb_tag_t tableTag = HB_OT_TAG_GPOS;
1507
1508 inline const PosLookup& get_lookup (unsigned int i) const
1509 { return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
1510
1511 static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);
1512 static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer);
1513 static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer);
1514
1515 inline bool sanitize (hb_sanitize_context_t *c) const
1516 {
1517 TRACE_SANITIZE (this);
1518 if (unlikely (!GSUBGPOS::sanitize (c))) return_trace (false);
1519 const OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
1520 return_trace (list.sanitize (c, this));
1521 }
1522 public:
1523 DEFINE_SIZE_STATIC (10);
1524 };
1525
1526
1527 static void
1528 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent)
1529 {
1530 int chain = pos[i].attach_chain(), type = pos[i].attach_type();
1531 if (likely (!chain || 0 == (type & ATTACH_TYPE_CURSIVE)))
1532 return;
1533
1534 pos[i].attach_chain() = 0;
1535
1536 unsigned int j = (int) i + chain;
1537
1538 /* Stop if we see new parent in the chain. */
1539 if (j == new_parent)
1540 return;
1541
1542 reverse_cursive_minor_offset (pos, j, direction, new_parent);
1543
1544 if (HB_DIRECTION_IS_HORIZONTAL (direction))
1545 pos[j].y_offset = -pos[i].y_offset;
1546 else
1547 pos[j].x_offset = -pos[i].x_offset;
1548
1549 pos[j].attach_chain() = -chain;
1550 pos[j].attach_type() = type;
1551 }
1552 static void
1553 propagate_attachment_offsets (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
1554 {
1555 /* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate
1556 * offset of glyph they are attached to. */
1557 int chain = pos[i].attach_chain(), type = pos[i].attach_type();
1558 if (likely (!chain))
1559 return;
1560
1561 unsigned int j = (int) i + chain;
1562
1563 pos[i].attach_chain() = 0;
1564
1565 propagate_attachment_offsets (pos, j, direction);
1566
1567 assert (!!(type & ATTACH_TYPE_MARK) ^ !!(type & ATTACH_TYPE_CURSIVE));
1568
1569 if (type & ATTACH_TYPE_CURSIVE)
1570 {
1571 if (HB_DIRECTION_IS_HORIZONTAL (direction))
1572 pos[i].y_offset += pos[j].y_offset;
1573 else
1574 pos[i].x_offset += pos[j].x_offset;
1575 }
1576 else /*if (type & ATTACH_TYPE_MARK)*/
1577 {
1578 pos[i].x_offset += pos[j].x_offset;
1579 pos[i].y_offset += pos[j].y_offset;
1580
1581 assert (j < i);
1582 if (HB_DIRECTION_IS_FORWARD (direction))
1583 for (unsigned int k = j; k < i; k++) {
1584 pos[i].x_offset -= pos[k].x_advance;
1585 pos[i].y_offset -= pos[k].y_advance;
1586 }
1587 else
1588 for (unsigned int k = j + 1; k < i + 1; k++) {
1589 pos[i].x_offset += pos[k].x_advance;
1590 pos[i].y_offset += pos[k].y_advance;
1591 }
1592 }
1593 }
1594
1595 void
1596 GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1597 {
1598 unsigned int count = buffer->len;
1599 for (unsigned int i = 0; i < count; i++)
1600 buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0;
1601 }
1602
1603 void
1604 GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1605 {
1606 //_hb_buffer_assert_gsubgpos_vars (buffer);
1607 }
1608
1609 void
1610 GPOS::position_finish_offsets (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1611 {
1612 _hb_buffer_assert_gsubgpos_vars (buffer);
1613
1614 unsigned int len;
1615 hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
1616 hb_direction_t direction = buffer->props.direction;
1617
1618 /* Handle attachments */
1619 if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT)
1620 for (unsigned int i = 0; i < len; i++)
1621 propagate_attachment_offsets (pos, i, direction);
1622 }
1623
1624
1625 /* Out-of-class implementation for methods recursing */
1626
1627 template <typename context_t>
1628 /*static*/ inline typename context_t::return_t PosLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index)
1629 {
1630 const GPOS &gpos = *(hb_ot_layout_from_face (c->face)->gpos);
1631 const PosLookup &l = gpos.get_lookup (lookup_index);
1632 return l.dispatch (c);
1633 }
1634
1635 /*static*/ inline bool PosLookup::apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index)
1636 {
1637 const GPOS &gpos = *(hb_ot_layout_from_face (c->face)->gpos);
1638 const PosLookup &l = gpos.get_lookup (lookup_index);
1639 unsigned int saved_lookup_props = c->lookup_props;
1640 unsigned int saved_lookup_index = c->lookup_index;
1641 c->set_lookup_index (lookup_index);
1642 c->set_lookup_props (l.get_props ());
1643 bool ret = l.dispatch (c);
1644 c->set_lookup_index (saved_lookup_index);
1645 c->set_lookup_props (saved_lookup_props);
1646 return ret;
1647 }
1648
1649
1650 #undef attach_chain
1651 #undef attach_type
1652
1653
1654 } /* namespace OT */
1655
1656
1657 #endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */