Files
pipelines/app/lib/ui/theme/custom_fonts/font_file_info.dart
T
alan c24e7f40b4 Settings: add your own fonts (.ttf/.otf) per device
Add font… picks one or more files, checks them with a bounded sfnt reader
(name table family, OS/2 weight), registers them with FontLoader before
storing, and chooses the new family. Added fonts list below the bundled ones
with Rename and Remove; removing the chosen one falls back to System default.
Bytes live in the app support directory natively and in IndexedDB on the web
(localStorage is too small); a shared_preferences index names them. Limits:
10 MB per file, 40 MB total. The capture kit gains a files= step.
2026-11-04 18:45:01 +00:00

184 lines
6.5 KiB
Dart
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import 'dart:typed_data';
/// What a TrueType or OpenType file says about itself: enough to name the
/// family it belongs to and to tell its weights apart.
///
/// [FontFileInfo.parse] is a small, bounded reader of the sfnt table
/// directory, the `name` table and the `OS/2` table. Every offset is checked
/// against the file before it is read, so a damaged or hostile file fails
/// with a [FormatException], never a range error or a long loop.
class FontFileInfo {
const FontFileInfo({
required this.family,
required this.subfamily,
required this.weight,
required this.italic,
});
/// The typographic family (name ID 16), else the legacy family (ID 1);
/// null when the file names neither readably.
final String? family;
/// The style name (ID 17, else ID 2), e.g. "Bold Italic"; may be null.
final String? subfamily;
/// `OS/2.usWeightClass` (1–1000), 400 when the table is absent or odd.
final int weight;
/// `OS/2.fsSelection` bit 0, else a subfamily naming italic or oblique.
final bool italic;
static const int _maxTables = 512;
static const int _maxNameRecords = 4096;
static const int _maxNameLength = 64;
/// Reads [bytes]. Throws [FormatException] with a user-facing message
/// when they are not a single TrueType/OpenType font.
static FontFileInfo parse(Uint8List bytes) {
final data = ByteData.sublistView(bytes);
if (bytes.length < 12) {
throw const FormatException('The file is too short.');
}
final version = data.getUint32(0);
switch (version) {
case 0x00010000 || 0x4F54544F || 0x74727565: // 1.0, 'OTTO', 'true'
break;
case 0x74746366: // 'ttcf'
throw const FormatException(
'Font collections (.ttc) are not supported; add single fonts.',
);
case 0x774F4646 || 0x774F4632: // 'wOFF', 'wOF2'
throw const FormatException('WOFF web fonts are not supported.');
default:
throw const FormatException('Not a TrueType or OpenType font.');
}
final count = data.getUint16(4);
if (count == 0 || count > _maxTables || 12 + count * 16 > bytes.length) {
throw const FormatException('The font table directory is damaged.');
}
final tables = <String, (int, int)>{};
for (var i = 0; i < count; i++) {
final record = 12 + i * 16;
final tag = String.fromCharCodes(bytes, record, record + 4);
final offset = data.getUint32(record + 8);
final length = data.getUint32(record + 12);
if (offset + length > bytes.length) {
throw const FormatException('A font table lies outside the file.');
}
tables[tag] = (offset, length);
}
final outlines =
(tables.containsKey('glyf') && tables.containsKey('loca')) ||
tables.containsKey('CFF ') ||
tables.containsKey('CFF2');
if (!tables.containsKey('cmap') ||
!tables.containsKey('head') ||
!outlines) {
throw const FormatException('The font is missing required tables.');
}
final names = _names(data, tables['name']);
final subfamily = names[17] ?? names[2];
final os2 = tables['OS/2'];
var weight = 400;
bool? italic;
if (os2 != null && os2.$2 >= 6) {
final value = data.getUint16(os2.$1 + 4);
if (value >= 1 && value <= 1000) weight = value;
if (os2.$2 >= 64) italic = data.getUint16(os2.$1 + 62) & 1 == 1;
}
italic ??= RegExp(
'italic|oblique',
caseSensitive: false,
).hasMatch(subfamily ?? '');
return FontFileInfo(
family: names[16] ?? names[1],
subfamily: subfamily,
weight: weight,
italic: italic,
);
}
/// Name IDs 1, 2, 16 and 17, each from the best record: Windows English,
/// then any Windows, then Unicode, then Mac Roman.
static Map<int, String> _names(ByteData data, (int, int)? table) {
final found = <int, (int, String)>{};
if (table == null || table.$2 < 6) return const <int, String>{};
final (start, length) = table;
final end = start + length;
final count = data.getUint16(start + 2);
final strings = start + data.getUint16(start + 4);
if (count > _maxNameRecords || start + 6 + count * 12 > end) {
return const <int, String>{};
}
for (var i = 0; i < count; i++) {
final record = start + 6 + i * 12;
final platform = data.getUint16(record);
final encoding = data.getUint16(record + 2);
final language = data.getUint16(record + 4);
final id = data.getUint16(record + 6);
if (id != 1 && id != 2 && id != 16 && id != 17) continue;
final rank = switch (platform) {
3 when encoding == 1 || encoding == 10 => language == 0x409 ? 4 : 3,
0 => 2,
1 when encoding == 0 && language == 0 => 1,
_ => 0,
};
if (rank == 0 || (found[id]?.$1 ?? 0) >= rank) continue;
final size = data.getUint16(record + 8);
final offset = strings + data.getUint16(record + 10);
if (offset + size > end || size > _maxNameLength * 4) continue;
final text = _clean(
platform == 1
? _macRoman(data, offset, size)
: _utf16(data, offset, size),
);
if (text.isNotEmpty) found[id] = (rank, text);
}
return <int, String>{
for (final entry in found.entries) entry.key: entry.value.$2,
};
}
static String _utf16(ByteData data, int offset, int size) =>
String.fromCharCodes(<int>[
for (var i = 0; i + 1 < size; i += 2) data.getUint16(offset + i),
]);
/// ASCII from Mac Roman; the rare accented byte becomes a space.
static String _macRoman(ByteData data, int offset, int size) =>
String.fromCharCodes(<int>[
for (var i = 0; i < size; i++)
data.getUint8(offset + i) < 0x80 ? data.getUint8(offset + i) : 0x20,
]);
/// Drops control characters, collapses runs of space and caps the length.
static String _clean(String raw) {
final text = raw
.replaceAll(RegExp(r'[\x00-\x1F\x7F�]'), '')
.replaceAll(RegExp(r'\s+'), ' ')
.trim();
return text.length > _maxNameLength
? text.substring(0, _maxNameLength).trim()
: text;
}
}
/// The conventional name of an OpenType weight class, plus "Italic".
String fontStyleName(int weight, {bool italic = false}) {
const names = <String>[
'Thin',
'ExtraLight',
'Light',
'Regular',
'Medium',
'SemiBold',
'Bold',
'ExtraBold',
'Black',
];
final index = ((weight.clamp(100, 900) + 50) ~/ 100) - 1;
final name = names[index.clamp(0, names.length - 1)];
if (!italic) return name;
return name == 'Regular' ? 'Italic' : '$name Italic';
}