1 /*
2 * Copyright © 2016 Igalia S.L.
3 *
4 * This is part of HarfBuzz, a text shaping library.
5 *
6 * Permission is hereby granted, without written agreement and without
7 * license or royalty fees, to use, copy, modify, and distribute this
8 * software and its documentation for any purpose, provided that the
9 * above copyright notice and the following two paragraphs appear in
10 * all copies of this software.
11 *
12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16 * DAMAGE.
17 *
18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23 *
24 * Igalia Author(s): Frédéric Wang
25 */
26
27 #ifndef HB_OT_MATH_TABLE_HH
28 #define HB_OT_MATH_TABLE_HH
29
30 #include "hb-open-type.hh"
31 #include "hb-ot-layout-common.hh"
32 #include "hb-ot-math.h"
33
34 namespace OT {
35
36
37 struct MathValueRecord
38 {
39 hb_position_t get_x_value (hb_font_t *font, const void *base) const
40 { return font->em_scale_x (value) + (base+deviceTable).get_x_delta (font); }
41 hb_position_t get_y_value (hb_font_t *font, const void *base) const
42 { return font->em_scale_y (value) + (base+deviceTable).get_y_delta (font); }
43
44 bool sanitize (hb_sanitize_context_t *c, const void *base) const
45 {
46 TRACE_SANITIZE (this);
47 return_trace (c->check_struct (this) && deviceTable.sanitize (c, base));
48 }
49
50 protected:
51 HBINT16 value; /* The X or Y value in design units */
52 OffsetTo<Device> deviceTable; /* Offset to the device table - from the
53 * beginning of parent table. May be NULL.
54 * Suggested format for device table is 1. */
55
56 public:
57 DEFINE_SIZE_STATIC (4);
58 };
59
60 struct MathConstants
61 {
62 bool sanitize_math_value_records (hb_sanitize_context_t *c) const
63 {
64 TRACE_SANITIZE (this);
65
66 unsigned int count = ARRAY_LENGTH (mathValueRecords);
67 for (unsigned int i = 0; i < count; i++)
68 if (!mathValueRecords[i].sanitize (c, this))
69 return_trace (false);
70
71 return_trace (true);
72 }
73
74 bool sanitize (hb_sanitize_context_t *c) const
75 {
76 TRACE_SANITIZE (this);
77 return_trace (c->check_struct (this) && sanitize_math_value_records (c));
78 }
79
80 hb_position_t get_value (hb_ot_math_constant_t constant,
81 hb_font_t *font) const
82 {
83 switch (constant) {
84
85 case HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN:
86 case HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN:
87 return percentScaleDown[constant - HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN];
88
89 case HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT:
90 case HB_OT_MATH_CONSTANT_DISPLAY_OPERATOR_MIN_HEIGHT:
91 return font->em_scale_y (minHeight[constant - HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT]);
92
93 case HB_OT_MATH_CONSTANT_RADICAL_KERN_AFTER_DEGREE:
94 case HB_OT_MATH_CONSTANT_RADICAL_KERN_BEFORE_DEGREE:
95 case HB_OT_MATH_CONSTANT_SKEWED_FRACTION_HORIZONTAL_GAP:
96 case HB_OT_MATH_CONSTANT_SPACE_AFTER_SCRIPT:
97 return mathValueRecords[constant - HB_OT_MATH_CONSTANT_MATH_LEADING].get_x_value (font, this);
98
99 case HB_OT_MATH_CONSTANT_ACCENT_BASE_HEIGHT:
100 case HB_OT_MATH_CONSTANT_AXIS_HEIGHT:
101 case HB_OT_MATH_CONSTANT_FLATTENED_ACCENT_BASE_HEIGHT:
102 case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN:
103 case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_GAP_MIN:
104 case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_SHIFT_DOWN:
105 case HB_OT_MATH_CONSTANT_FRACTION_DENOM_DISPLAY_STYLE_GAP_MIN:
106 case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP:
107 case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_GAP_MIN:
108 case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_SHIFT_UP:
109 case HB_OT_MATH_CONSTANT_FRACTION_NUM_DISPLAY_STYLE_GAP_MIN:
110 case HB_OT_MATH_CONSTANT_FRACTION_RULE_THICKNESS:
111 case HB_OT_MATH_CONSTANT_LOWER_LIMIT_BASELINE_DROP_MIN:
112 case HB_OT_MATH_CONSTANT_LOWER_LIMIT_GAP_MIN:
113 case HB_OT_MATH_CONSTANT_MATH_LEADING:
114 case HB_OT_MATH_CONSTANT_OVERBAR_EXTRA_ASCENDER:
115 case HB_OT_MATH_CONSTANT_OVERBAR_RULE_THICKNESS:
116 case HB_OT_MATH_CONSTANT_OVERBAR_VERTICAL_GAP:
117 case HB_OT_MATH_CONSTANT_RADICAL_DISPLAY_STYLE_VERTICAL_GAP:
118 case HB_OT_MATH_CONSTANT_RADICAL_EXTRA_ASCENDER:
119 case HB_OT_MATH_CONSTANT_RADICAL_RULE_THICKNESS:
120 case HB_OT_MATH_CONSTANT_RADICAL_VERTICAL_GAP:
121 case HB_OT_MATH_CONSTANT_SKEWED_FRACTION_VERTICAL_GAP:
122 case HB_OT_MATH_CONSTANT_STACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN:
123 case HB_OT_MATH_CONSTANT_STACK_BOTTOM_SHIFT_DOWN:
124 case HB_OT_MATH_CONSTANT_STACK_DISPLAY_STYLE_GAP_MIN:
125 case HB_OT_MATH_CONSTANT_STACK_GAP_MIN:
126 case HB_OT_MATH_CONSTANT_STACK_TOP_DISPLAY_STYLE_SHIFT_UP:
127 case HB_OT_MATH_CONSTANT_STACK_TOP_SHIFT_UP:
128 case HB_OT_MATH_CONSTANT_STRETCH_STACK_BOTTOM_SHIFT_DOWN:
129 case HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_ABOVE_MIN:
130 case HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_BELOW_MIN:
131 case HB_OT_MATH_CONSTANT_STRETCH_STACK_TOP_SHIFT_UP:
132 case HB_OT_MATH_CONSTANT_SUBSCRIPT_BASELINE_DROP_MIN:
133 case HB_OT_MATH_CONSTANT_SUBSCRIPT_SHIFT_DOWN:
134 case HB_OT_MATH_CONSTANT_SUBSCRIPT_TOP_MAX:
135 case HB_OT_MATH_CONSTANT_SUB_SUPERSCRIPT_GAP_MIN:
136 case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BASELINE_DROP_MAX:
137 case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT:
138 case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MIN:
139 case HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP:
140 case HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP_CRAMPED:
141 case HB_OT_MATH_CONSTANT_UNDERBAR_EXTRA_DESCENDER:
142 case HB_OT_MATH_CONSTANT_UNDERBAR_RULE_THICKNESS:
143 case HB_OT_MATH_CONSTANT_UNDERBAR_VERTICAL_GAP:
144 case HB_OT_MATH_CONSTANT_UPPER_LIMIT_BASELINE_RISE_MIN:
145 case HB_OT_MATH_CONSTANT_UPPER_LIMIT_GAP_MIN:
146 return mathValueRecords[constant - HB_OT_MATH_CONSTANT_MATH_LEADING].get_y_value (font, this);
147
148 case HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT:
149 return radicalDegreeBottomRaisePercent;
150
151 default:
152 return 0;
153 }
154 }
155
156 protected:
157 HBINT16 percentScaleDown[2];
158 HBUINT16 minHeight[2];
159 MathValueRecord mathValueRecords[51];
160 HBINT16 radicalDegreeBottomRaisePercent;
161
162 public:
163 DEFINE_SIZE_STATIC (214);
164 };
165
166 struct MathItalicsCorrectionInfo
167 {
168 bool sanitize (hb_sanitize_context_t *c) const
169 {
170 TRACE_SANITIZE (this);
171 return_trace (c->check_struct (this) &&
172 coverage.sanitize (c, this) &&
173 italicsCorrection.sanitize (c, this));
174 }
175
176 hb_position_t get_value (hb_codepoint_t glyph,
177 hb_font_t *font) const
178 {
179 unsigned int index = (this+coverage).get_coverage (glyph);
180 return italicsCorrection[index].get_x_value (font, this);
181 }
182
183 protected:
184 OffsetTo<Coverage> coverage; /* Offset to Coverage table -
185 * from the beginning of
186 * MathItalicsCorrectionInfo
187 * table. */
188 ArrayOf<MathValueRecord> italicsCorrection; /* Array of MathValueRecords
189 * defining italics correction
190 * values for each
191 * covered glyph. */
192
193 public:
194 DEFINE_SIZE_ARRAY (4, italicsCorrection);
195 };
196
197 struct MathTopAccentAttachment
198 {
199 bool sanitize (hb_sanitize_context_t *c) const
200 {
201 TRACE_SANITIZE (this);
202 return_trace (c->check_struct (this) &&
203 topAccentCoverage.sanitize (c, this) &&
204 topAccentAttachment.sanitize (c, this));
205 }
206
207 hb_position_t get_value (hb_codepoint_t glyph,
208 hb_font_t *font) const
209 {
210 unsigned int index = (this+topAccentCoverage).get_coverage (glyph);
211 if (index == NOT_COVERED)
212 return font->get_glyph_h_advance (glyph) / 2;
213 return topAccentAttachment[index].get_x_value (font, this);
214 }
215
216 protected:
217 OffsetTo<Coverage> topAccentCoverage; /* Offset to Coverage table -
218 * from the beginning of
219 * MathTopAccentAttachment
220 * table. */
221 ArrayOf<MathValueRecord> topAccentAttachment; /* Array of MathValueRecords
222 * defining top accent
223 * attachment points for each
224 * covered glyph. */
225
226 public:
227 DEFINE_SIZE_ARRAY (2 + 2, topAccentAttachment);
228 };
229
230 struct MathKern
231 {
232 bool sanitize_math_value_records (hb_sanitize_context_t *c) const
233 {
234 TRACE_SANITIZE (this);
235 unsigned int count = 2 * heightCount + 1;
236 for (unsigned int i = 0; i < count; i++)
237 if (!mathValueRecordsZ.arrayZ[i].sanitize (c, this)) return_trace (false);
238 return_trace (true);
239 }
240
241 bool sanitize (hb_sanitize_context_t *c) const
242 {
243 TRACE_SANITIZE (this);
244 return_trace (c->check_struct (this) &&
245 c->check_array (mathValueRecordsZ.arrayZ, 2 * heightCount + 1) &&
246 sanitize_math_value_records (c));
247 }
248
249 hb_position_t get_value (hb_position_t correction_height, hb_font_t *font) const
250 {
251 const MathValueRecord* correctionHeight = mathValueRecordsZ.arrayZ;
252 const MathValueRecord* kernValue = mathValueRecordsZ.arrayZ + heightCount;
253 int sign = font->y_scale < 0 ? -1 : +1;
254
255 /* The description of the MathKern table is a ambiguous, but interpreting
256 * "between the two heights found at those indexes" for 0 < i < len as
257 *
258 * correctionHeight[i-1] < correction_height <= correctionHeight[i]
259 *
260 * makes the result consistent with the limit cases and we can just use the
261 * binary search algorithm of std::upper_bound:
262 */
263 unsigned int i = 0;
264 unsigned int count = heightCount;
265 while (count > 0)
266 {
267 unsigned int half = count / 2;
268 hb_position_t height = correctionHeight[i + half].get_y_value (font, this);
269 if (sign * height < sign * correction_height)
270 {
271 i += half + 1;
272 count -= half + 1;
273 } else
274 count = half;
275 }
276 return kernValue[i].get_x_value (font, this);
277 }
278
279 protected:
280 HBUINT16 heightCount;
281 UnsizedArrayOf<MathValueRecord>
282 mathValueRecordsZ; /* Array of correction heights at
283 * which the kern value changes.
284 * Sorted by the height value in
285 * design units (heightCount entries),
286 * Followed by:
287 * Array of kern values corresponding
288 * to heights. (heightCount+1 entries).
289 */
290
291 public:
292 DEFINE_SIZE_ARRAY (2, mathValueRecordsZ);
293 };
294
295 struct MathKernInfoRecord
296 {
297 bool sanitize (hb_sanitize_context_t *c, const void *base) const
298 {
299 TRACE_SANITIZE (this);
300
301 unsigned int count = ARRAY_LENGTH (mathKern);
302 for (unsigned int i = 0; i < count; i++)
303 if (unlikely (!mathKern[i].sanitize (c, base)))
304 return_trace (false);
305
306 return_trace (true);
307 }
308
309 hb_position_t get_kerning (hb_ot_math_kern_t kern,
310 hb_position_t correction_height,
311 hb_font_t *font,
312 const void *base) const
313 {
314 unsigned int idx = kern;
315 if (unlikely (idx >= ARRAY_LENGTH (mathKern))) return 0;
316 return (base+mathKern[idx]).get_value (correction_height, font);
317 }
318
319 protected:
320 /* Offset to MathKern table for each corner -
321 * from the beginning of MathKernInfo table. May be NULL. */
322 OffsetTo<MathKern> mathKern[4];
323
324 public:
325 DEFINE_SIZE_STATIC (8);
326 };
327
328 struct MathKernInfo
329 {
330 bool sanitize (hb_sanitize_context_t *c) const
331 {
332 TRACE_SANITIZE (this);
333 return_trace (c->check_struct (this) &&
334 mathKernCoverage.sanitize (c, this) &&
335 mathKernInfoRecords.sanitize (c, this));
336 }
337
338 hb_position_t get_kerning (hb_codepoint_t glyph,
339 hb_ot_math_kern_t kern,
340 hb_position_t correction_height,
341 hb_font_t *font) const
342 {
343 unsigned int index = (this+mathKernCoverage).get_coverage (glyph);
344 return mathKernInfoRecords[index].get_kerning (kern, correction_height, font, this);
345 }
346
347 protected:
348 OffsetTo<Coverage> mathKernCoverage; /* Offset to Coverage table -
349 * from the beginning of the
350 * MathKernInfo table. */
351 ArrayOf<MathKernInfoRecord> mathKernInfoRecords; /* Array of
352 * MathKernInfoRecords,
353 * per-glyph information for
354 * mathematical positioning
355 * of subscripts and
356 * superscripts. */
357
358 public:
359 DEFINE_SIZE_ARRAY (4, mathKernInfoRecords);
360 };
361
362 struct MathGlyphInfo
363 {
364 bool sanitize (hb_sanitize_context_t *c) const
365 {
366 TRACE_SANITIZE (this);
367 return_trace (c->check_struct (this) &&
368 mathItalicsCorrectionInfo.sanitize (c, this) &&
369 mathTopAccentAttachment.sanitize (c, this) &&
370 extendedShapeCoverage.sanitize (c, this) &&
371 mathKernInfo.sanitize (c, this));
372 }
373
374 hb_position_t
375 get_italics_correction (hb_codepoint_t glyph, hb_font_t *font) const
376 { return (this+mathItalicsCorrectionInfo).get_value (glyph, font); }
377
378 hb_position_t
379 get_top_accent_attachment (hb_codepoint_t glyph, hb_font_t *font) const
380 { return (this+mathTopAccentAttachment).get_value (glyph, font); }
381
382 bool is_extended_shape (hb_codepoint_t glyph) const
383 { return (this+extendedShapeCoverage).get_coverage (glyph) != NOT_COVERED; }
384
385 hb_position_t get_kerning (hb_codepoint_t glyph,
386 hb_ot_math_kern_t kern,
387 hb_position_t correction_height,
388 hb_font_t *font) const
389 { return (this+mathKernInfo).get_kerning (glyph, kern, correction_height, font); }
390
391 protected:
392 /* Offset to MathItalicsCorrectionInfo table -
393 * from the beginning of MathGlyphInfo table. */
394 OffsetTo<MathItalicsCorrectionInfo> mathItalicsCorrectionInfo;
395
396 /* Offset to MathTopAccentAttachment table -
397 * from the beginning of MathGlyphInfo table. */
398 OffsetTo<MathTopAccentAttachment> mathTopAccentAttachment;
399
400 /* Offset to coverage table for Extended Shape glyphs -
401 * from the beginning of MathGlyphInfo table. When the left or right glyph of
402 * a box is an extended shape variant, the (ink) box (and not the default
403 * position defined by values in MathConstants table) should be used for
404 * vertical positioning purposes. May be NULL.. */
405 OffsetTo<Coverage> extendedShapeCoverage;
406
407 /* Offset to MathKernInfo table -
408 * from the beginning of MathGlyphInfo table. */
409 OffsetTo<MathKernInfo> mathKernInfo;
410
411 public:
412 DEFINE_SIZE_STATIC (8);
413 };
414
415 struct MathGlyphVariantRecord
416 {
417 friend struct MathGlyphConstruction;
418
419 bool sanitize (hb_sanitize_context_t *c) const
420 {
421 TRACE_SANITIZE (this);
422 return_trace (c->check_struct (this));
423 }
424
425 protected:
426 GlyphID variantGlyph; /* Glyph ID for the variant. */
427 HBUINT16 advanceMeasurement; /* Advance width/height, in design units, of the
428 * variant, in the direction of requested
429 * glyph extension. */
430
431 public:
432 DEFINE_SIZE_STATIC (4);
433 };
434
435 struct PartFlags : HBUINT16
436 {
437 enum Flags {
438 Extender = 0x0001u, /* If set, the part can be skipped or repeated. */
439
440 Defined = 0x0001u, /* All defined flags. */
441 };
442
443 public:
444 DEFINE_SIZE_STATIC (2);
445 };
446
447 struct MathGlyphPartRecord
448 {
449 bool sanitize (hb_sanitize_context_t *c) const
450 {
451 TRACE_SANITIZE (this);
452 return_trace (c->check_struct (this));
453 }
454
455 void extract (hb_ot_math_glyph_part_t &out,
456 int scale,
457 hb_font_t *font) const
458 {
459 out.glyph = glyph;
460
461 out.start_connector_length = font->em_scale (startConnectorLength, scale);
462 out.end_connector_length = font->em_scale (endConnectorLength, scale);
463 out.full_advance = font->em_scale (fullAdvance, scale);
464
465 static_assert ((unsigned int) HB_MATH_GLYPH_PART_FLAG_EXTENDER ==
466 (unsigned int) PartFlags::Extender, "");
467
468 out.flags = (hb_ot_math_glyph_part_flags_t)
469 (unsigned int)
470 (partFlags & PartFlags::Defined);
471 }
472
473 protected:
474 GlyphID glyph; /* Glyph ID for the part. */
475 HBUINT16 startConnectorLength; /* Advance width/ height of the straight bar
476 * connector material, in design units, is at
477 * the beginning of the glyph, in the
478 * direction of the extension. */
479 HBUINT16 endConnectorLength; /* Advance width/ height of the straight bar
480 * connector material, in design units, is at
481 * the end of the glyph, in the direction of
482 * the extension. */
483 HBUINT16 fullAdvance; /* Full advance width/height for this part,
484 * in the direction of the extension.
485 * In design units. */
486 PartFlags partFlags; /* Part qualifiers. */
487
488 public:
489 DEFINE_SIZE_STATIC (10);
490 };
491
492 struct MathGlyphAssembly
493 {
494 bool sanitize (hb_sanitize_context_t *c) const
495 {
496 TRACE_SANITIZE (this);
497 return_trace (c->check_struct (this) &&
498 italicsCorrection.sanitize (c, this) &&
499 partRecords.sanitize (c));
500 }
501
502 unsigned int get_parts (hb_direction_t direction,
503 hb_font_t *font,
504 unsigned int start_offset,
505 unsigned int *parts_count, /* IN/OUT */
506 hb_ot_math_glyph_part_t *parts /* OUT */,
507 hb_position_t *italics_correction /* OUT */) const
508 {
509 if (parts_count)
510 {
511 int scale = font->dir_scale (direction);
512 hb_array_t<const MathGlyphPartRecord> arr = partRecords.sub_array (start_offset, parts_count);
513 unsigned int count = arr.length;
514 for (unsigned int i = 0; i < count; i++)
515 arr[i].extract (parts[i], scale, font);
516 }
517
518 if (italics_correction)
519 *italics_correction = italicsCorrection.get_x_value (font, this);
520
521 return partRecords.len;
522 }
523
524 protected:
525 MathValueRecord italicsCorrection; /* Italics correction of this
526 * MathGlyphAssembly. Should not
527 * depend on the assembly size. */
528 ArrayOf<MathGlyphPartRecord> partRecords; /* Array of part records, from
529 * left to right and bottom to
530 * top. */
531
532 public:
533 DEFINE_SIZE_ARRAY (6, partRecords);
534 };
535
536 struct MathGlyphConstruction
537 {
538 bool sanitize (hb_sanitize_context_t *c) const
539 {
540 TRACE_SANITIZE (this);
541 return_trace (c->check_struct (this) &&
542 glyphAssembly.sanitize (c, this) &&
543 mathGlyphVariantRecord.sanitize (c));
544 }
545
546 const MathGlyphAssembly &get_assembly () const { return this+glyphAssembly; }
547
548 unsigned int get_variants (hb_direction_t direction,
549 hb_font_t *font,
550 unsigned int start_offset,
551 unsigned int *variants_count, /* IN/OUT */
552 hb_ot_math_glyph_variant_t *variants /* OUT */) const
553 {
554 if (variants_count)
555 {
556 int scale = font->dir_scale (direction);
557 hb_array_t<const MathGlyphVariantRecord> arr = mathGlyphVariantRecord.sub_array (start_offset, variants_count);
558 unsigned int count = arr.length;
559 for (unsigned int i = 0; i < count; i++)
560 {
561 variants[i].glyph = arr[i].variantGlyph;
562 variants[i].advance = font->em_scale (arr[i].advanceMeasurement, scale);
563 }
564 }
565 return mathGlyphVariantRecord.len;
566 }
567
568 protected:
569 /* Offset to MathGlyphAssembly table for this shape - from the beginning of
570 MathGlyphConstruction table. May be NULL. */
571 OffsetTo<MathGlyphAssembly> glyphAssembly;
572
573 /* MathGlyphVariantRecords for alternative variants of the glyphs. */
574 ArrayOf<MathGlyphVariantRecord> mathGlyphVariantRecord;
575
576 public:
577 DEFINE_SIZE_ARRAY (4, mathGlyphVariantRecord);
578 };
579
580 struct MathVariants
581 {
582 bool sanitize_offsets (hb_sanitize_context_t *c) const
583 {
584 TRACE_SANITIZE (this);
585 unsigned int count = vertGlyphCount + horizGlyphCount;
586 for (unsigned int i = 0; i < count; i++)
587 if (!glyphConstruction.arrayZ[i].sanitize (c, this)) return_trace (false);
588 return_trace (true);
589 }
590
591 bool sanitize (hb_sanitize_context_t *c) const
592 {
593 TRACE_SANITIZE (this);
594 return_trace (c->check_struct (this) &&
595 vertGlyphCoverage.sanitize (c, this) &&
596 horizGlyphCoverage.sanitize (c, this) &&
597 c->check_array (glyphConstruction.arrayZ, vertGlyphCount + horizGlyphCount) &&
598 sanitize_offsets (c));
599 }
600
601 hb_position_t get_min_connector_overlap (hb_direction_t direction,
602 hb_font_t *font) const
603 { return font->em_scale_dir (minConnectorOverlap, direction); }
604
605 unsigned int get_glyph_variants (hb_codepoint_t glyph,
606 hb_direction_t direction,
607 hb_font_t *font,
608 unsigned int start_offset,
609 unsigned int *variants_count, /* IN/OUT */
610 hb_ot_math_glyph_variant_t *variants /* OUT */) const
611 { return get_glyph_construction (glyph, direction, font)
612 .get_variants (direction, font, start_offset, variants_count, variants); }
613
614 unsigned int get_glyph_parts (hb_codepoint_t glyph,
615 hb_direction_t direction,
616 hb_font_t *font,
617 unsigned int start_offset,
618 unsigned int *parts_count, /* IN/OUT */
619 hb_ot_math_glyph_part_t *parts /* OUT */,
620 hb_position_t *italics_correction /* OUT */) const
621 { return get_glyph_construction (glyph, direction, font)
622 .get_assembly ()
623 .get_parts (direction, font,
624 start_offset, parts_count, parts,
625 italics_correction); }
626
627 private:
628 const MathGlyphConstruction &
629 get_glyph_construction (hb_codepoint_t glyph,
630 hb_direction_t direction,
631 hb_font_t *font HB_UNUSED) const
632 {
633 bool vertical = HB_DIRECTION_IS_VERTICAL (direction);
634 unsigned int count = vertical ? vertGlyphCount : horizGlyphCount;
635 const OffsetTo<Coverage> &coverage = vertical ? vertGlyphCoverage
636 : horizGlyphCoverage;
637
638 unsigned int index = (this+coverage).get_coverage (glyph);
639 if (unlikely (index >= count)) return Null (MathGlyphConstruction);
640
641 if (!vertical)
642 index += vertGlyphCount;
643
644 return this+glyphConstruction[index];
645 }
646
647 protected:
648 HBUINT16 minConnectorOverlap; /* Minimum overlap of connecting
649 * glyphs during glyph construction,
650 * in design units. */
651 OffsetTo<Coverage> vertGlyphCoverage; /* Offset to Coverage table -
652 * from the beginning of MathVariants
653 * table. */
654 OffsetTo<Coverage> horizGlyphCoverage; /* Offset to Coverage table -
655 * from the beginning of MathVariants
656 * table. */
657 HBUINT16 vertGlyphCount; /* Number of glyphs for which
658 * information is provided for
659 * vertically growing variants. */
660 HBUINT16 horizGlyphCount; /* Number of glyphs for which
661 * information is provided for
662 * horizontally growing variants. */
663
664 /* Array of offsets to MathGlyphConstruction tables - from the beginning of
665 the MathVariants table, for shapes growing in vertical/horizontal
666 direction. */
667 UnsizedArrayOf<OffsetTo<MathGlyphConstruction> >
668 glyphConstruction;
669
670 public:
671 DEFINE_SIZE_ARRAY (10, glyphConstruction);
672 };
673
674
675 /*
676 * MATH -- Mathematical typesetting
677 * https://docs.microsoft.com/en-us/typography/opentype/spec/math
678 */
679
680 struct MATH
681 {
682 static constexpr hb_tag_t tableTag = HB_OT_TAG_MATH;
683
684 bool has_data () const { return version.to_int (); }
685
686 bool sanitize (hb_sanitize_context_t *c) const
687 {
688 TRACE_SANITIZE (this);
689 return_trace (version.sanitize (c) &&
690 likely (version.major == 1) &&
691 mathConstants.sanitize (c, this) &&
692 mathGlyphInfo.sanitize (c, this) &&
693 mathVariants.sanitize (c, this));
694 }
695
696 hb_position_t get_constant (hb_ot_math_constant_t constant,
697 hb_font_t *font) const
698 { return (this+mathConstants).get_value (constant, font); }
699
700 const MathGlyphInfo &get_glyph_info () const { return this+mathGlyphInfo; }
701
702 const MathVariants &get_variants () const { return this+mathVariants; }
703
704 protected:
705 FixedVersion<>version; /* Version of the MATH table
706 * initially set to 0x00010000u */
707 OffsetTo<MathConstants> mathConstants;/* MathConstants table */
708 OffsetTo<MathGlyphInfo> mathGlyphInfo;/* MathGlyphInfo table */
709 OffsetTo<MathVariants> mathVariants; /* MathVariants table */
710
711 public:
712 DEFINE_SIZE_STATIC (10);
713 };
714
715 } /* namespace OT */
716
717
718 #endif /* HB_OT_MATH_TABLE_HH */