mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 21:52:32 +00:00
* metafile: hold a placed pen width to what covers the frame Picture::place scaled a pen width by the fit with no upper bound, so a pen of 1e30 units made a renderer flatten round caps of that size. A placed pen is now at most twice the diagonal of the frame and the path together, which already covers the whole frame. Ported from storytold/wordcraft#5427. * metafile: one byte budget for items, EMF+ objects and clips; count clip regions when placing - Canvas::shade_shape returns when the canvas is full or the clip is empty, instead of sampling a tile that is then dropped. - EMF+ objects, the pieces of a continued object and the current and saved EMF+ clips count against the canvas's 256 MiB budget, in both directions: an object is not stored past what the canvas holds, and the canvas stops at what the objects hold. - A nested metafile held by an EMF+ image object is charged for what its items own (segments, pixels, text, clip rectangles; a shared tile or clip path once) rather than 128 bytes an item. - Picture::place charges each clip region it expands to the 500,000 element budget, for every kind of item, and expands a region once for the consecutive items that share it. Ported from storytold/deckcraft#1777, with its review comments addressed (the canvas checks include the held bytes; text and bitmap items are checked too; regions are matched by content, not by address). * metafile: a negative crop side pads the picture crop_window took each side as 0..1, so a negative side (a negative a:srcRect side in an Office file, or a picture fitted whole into a frame of another shape) was dropped and the picture was stretched over its frame. A side is now taken down to -100: the window starts before the source or ends past it, and Picture::fit places the source inside the frame at its own proportions. Ported from storytold/wordcraft#2027 (the -100 bound and the invariant test) and storytold/wordcraft#5206 (the padding test). * metafile: decode 8-bit text in the font's code page 8-bit text (WMF TEXTOUT and EXTTEXTOUT, EMF EXTTEXTOUTA and SMALLTEXTOUT) was decoded in Windows-1250, 1251 or 1252 only, and a double-byte character became a blank. - Greek, Turkish, Vietnamese, Hebrew, Arabic, Baltic and Thai character sets decode in their code pages (encoding_rs, already a workspace dependency). - Shift_JIS, UHC, GBK and Big5 pairs decode to their character, with the lead and trail ranges of each set; the character keeps the advances of both bytes. A lead byte without a trail byte is one undefined byte. - A WMF face name is read in the font's code page. - The Symbol font selected with DEFAULT_CHARSET keeps its bytes as symbol codes (U+F000 + code), as SYMBOL_CHARSET fonts do. Ported from storytold/wordcraft#5187 (the code pages, the double-byte ranges, the face name and the Symbol font) and storytold/deckcraft#792 (the Hebrew and Arabic tests). --------- Co-authored-by: Dmitrii Khlapov <19991457+dkhlapov@users.noreply.github.com> Co-authored-by: David Lin <woei66@gmail.com>
266 lines
12 KiB
Rust
266 lines
12 KiB
Rust
//! Text records: the font (LOGFONT), the text string decoded from its character set, and the
|
||
//! neutral [`Text`] item. The metafile crate knows no fonts, so measuring, alignment against the
|
||
//! font's metrics and glyph drawing are left to the renderer.
|
||
|
||
/// A font chosen by a CREATEFONTINDIRECT record (MS-WMF 2.2.1.2 Font, MS-EMF 2.2.13 LogFont).
|
||
#[derive(Debug, Clone, PartialEq, Default)]
|
||
pub struct Font {
|
||
/// The face name the file asks for (`"Arial"`, `"Wingdings"`); may be empty.
|
||
pub family: String,
|
||
/// LOGFONT height in text units: negative is the character (em) height, positive the cell
|
||
/// height (ascent plus descent), 0 the default size.
|
||
pub height: f32,
|
||
/// Average character width in text units; 0 keeps the font's own proportions.
|
||
pub width: f32,
|
||
/// 100..=900 (400 regular, 700 bold); 0 is the default weight.
|
||
pub weight: u16,
|
||
pub italic: bool,
|
||
pub underline: bool,
|
||
pub strike: bool,
|
||
/// LOGFONT character set (0 ANSI, 2 SYMBOL, 238 EASTEUROPE…).
|
||
pub charset: u8,
|
||
}
|
||
|
||
/// SYMBOL_CHARSET: byte codes are the font's own symbol codes.
|
||
pub const SYMBOL_CHARSET: u8 = 2;
|
||
/// DEFAULT_CHARSET: the font decides.
|
||
const DEFAULT_CHARSET: u8 = 1;
|
||
|
||
/// Where the reference point sits on the string horizontally (TA_LEFT, TA_CENTER, TA_RIGHT).
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||
pub enum HAlign {
|
||
#[default]
|
||
Left,
|
||
Center,
|
||
Right,
|
||
}
|
||
|
||
/// Where the reference point sits vertically (TA_TOP, TA_BASELINE, TA_BOTTOM): the top of the
|
||
/// character cell, the baseline or the bottom of the cell.
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||
pub enum VAlign {
|
||
#[default]
|
||
Top,
|
||
Baseline,
|
||
Bottom,
|
||
}
|
||
|
||
/// One string drawn by EXTTEXTOUT, TEXTOUT or SMALLTEXTOUT.
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub struct Text {
|
||
/// Text space to picture space as affine coefficients `[a, b, c, d, e, f]` (`x' = a·x + c·y + e`,
|
||
/// `y' = b·x + d·y + f`, kurbo's order). Text space has x along the baseline and y down, in the
|
||
/// metafile's logical units, with the reference point at the origin. Escapement and the
|
||
/// mapping are folded in; glyphs are never mirrored.
|
||
pub transform: [f64; 6],
|
||
pub text: String,
|
||
/// Advance after each character of `text`, in text units (the dx array). Empty when the file
|
||
/// gives none: the font's own advances apply.
|
||
pub dx: Vec<f32>,
|
||
pub font: Font,
|
||
pub color: [u8; 4],
|
||
/// Colour filled behind the character cells (OPAQUE background mode); None when transparent.
|
||
pub background: Option<[u8; 4]>,
|
||
pub h_align: HAlign,
|
||
pub v_align: VAlign,
|
||
/// Clip rectangle `[x0, y0, x1, y1]` in picture units (ETO_CLIPPED).
|
||
pub clip: Option<[f32; 4]>,
|
||
/// Clip region from the device context, in picture units. None is the default clip. Drawn
|
||
/// together with [`Text::clip`] when both are set.
|
||
pub region: Option<Vec<[f32; 4]>>,
|
||
/// Clip paths from the device context, as on [`crate::Item::Path`].
|
||
pub clips: Vec<std::sync::Arc<crate::ClipPath>>,
|
||
}
|
||
|
||
/// TA_UPDATECP: the string starts at the current position, which moves past it.
|
||
pub(crate) const TA_UPDATECP: u32 = 0x0001;
|
||
/// ETO_OPAQUE fills the rectangle with the background colour; ETO_CLIPPED clips the text to it.
|
||
pub(crate) const ETO_OPAQUE: u32 = 0x0002;
|
||
pub(crate) const ETO_CLIPPED: u32 = 0x0004;
|
||
/// The string holds glyph indices, not characters (drawn only when the font matches).
|
||
pub(crate) const ETO_GLYPH_INDEX: u32 = 0x0010;
|
||
/// The dx array holds (dx, dy) pairs.
|
||
pub(crate) const ETO_PDY: u32 = 0x2000;
|
||
/// Longest string kept from one record.
|
||
pub(crate) const MAX_CHARS: usize = 16_384;
|
||
|
||
/// Horizontal and vertical alignment from a TA_* word (the vertical bits are 0 top, 8 bottom,
|
||
/// 24 baseline; the horizontal ones 0 left, 2 right, 6 center).
|
||
pub(crate) fn align(ta: u32) -> (HAlign, VAlign) {
|
||
let h = match ta & 0x06 {
|
||
6 => HAlign::Center,
|
||
2 => HAlign::Right,
|
||
_ => HAlign::Left,
|
||
};
|
||
let v = match ta & 0x18 {
|
||
0x18 => VAlign::Baseline,
|
||
0x08 => VAlign::Bottom,
|
||
_ => VAlign::Top,
|
||
};
|
||
(h, v)
|
||
}
|
||
|
||
/// Decodes 8-bit text in `charset` and merges `dx` to match, one entry per character. In a
|
||
/// double-byte character set (Shift_JIS, UHC, GBK, Big5) a lead and trail byte are one character
|
||
/// whose advance is the sum of both; a lead byte without a trail byte it pairs with is one
|
||
/// undefined byte (U+FFFD). Johab is not decoded: its pairs become blanks. `dx` may be empty.
|
||
pub(crate) fn decode_bytes(bytes: &[u8], charset: u8, dx: &[f32]) -> (String, Vec<f32>) {
|
||
let mut s = String::with_capacity(bytes.len());
|
||
let mut out_dx = Vec::with_capacity(dx.len().min(bytes.len()));
|
||
let mut i = 0;
|
||
while let Some(&b) = bytes.get(i) {
|
||
let pair = bytes.get(i + 1).and_then(|t| pair_char(b, *t, charset));
|
||
let n = if pair.is_some() { 2 } else { 1 };
|
||
s.push(pair.unwrap_or_else(|| byte_char(b, charset)));
|
||
if !dx.is_empty() {
|
||
out_dx.push((i..i + n).filter_map(|k| dx.get(k)).sum());
|
||
}
|
||
i += n;
|
||
}
|
||
(s, out_dx)
|
||
}
|
||
|
||
/// The character set 8-bit text in `font` is decoded in. DEFAULT_CHARSET leaves the choice to the
|
||
/// font, and the Symbol font's bytes are its own codes.
|
||
pub(crate) fn text_charset(font: &Font) -> u8 {
|
||
let symbol = ["Symbol", "Symbol (PCL6)"].iter().any(|n| font.family.eq_ignore_ascii_case(n));
|
||
if font.charset == DEFAULT_CHARSET && symbol { SYMBOL_CHARSET } else { font.charset }
|
||
}
|
||
|
||
/// The encoding of a character set this module has no table of its own for.
|
||
fn encoding(charset: u8) -> Option<&'static encoding_rs::Encoding> {
|
||
Some(match charset {
|
||
// SHIFTJIS_CHARSET, HANGUL_CHARSET, GB2312_CHARSET, CHINESEBIG5_CHARSET.
|
||
128 => encoding_rs::SHIFT_JIS,
|
||
129 => encoding_rs::EUC_KR,
|
||
134 => encoding_rs::GBK,
|
||
136 => encoding_rs::BIG5,
|
||
// GREEK, TURKISH, VIETNAMESE, HEBREW, ARABIC, BALTIC and THAI_CHARSET.
|
||
161 => encoding_rs::WINDOWS_1253,
|
||
162 => encoding_rs::WINDOWS_1254,
|
||
163 => encoding_rs::WINDOWS_1258,
|
||
177 => encoding_rs::WINDOWS_1255,
|
||
178 => encoding_rs::WINDOWS_1256,
|
||
186 => encoding_rs::WINDOWS_1257,
|
||
222 => encoding_rs::WINDOWS_874,
|
||
_ => return None,
|
||
})
|
||
}
|
||
|
||
/// The one character that `enc` decodes `bytes` to; None when they are not exactly one.
|
||
fn one_char(enc: &'static encoding_rs::Encoding, bytes: &[u8]) -> Option<char> {
|
||
let (text, bad) = enc.decode_without_bom_handling(bytes);
|
||
let mut chars = text.chars();
|
||
let c = chars.next()?;
|
||
(!bad && chars.next().is_none()).then_some(c)
|
||
}
|
||
|
||
/// The character of a lead and trail byte in a double-byte character set; None when the bytes
|
||
/// are not a pair there. The ranges differ: Shift_JIS leaves its half-width katakana (0xA1..=0xDF)
|
||
/// as single bytes, and GBK has no trail byte 0x7F.
|
||
fn pair_char(lead: u8, trail: u8, charset: u8) -> Option<char> {
|
||
let (is_lead, is_trail) = match charset {
|
||
128 => (matches!(lead, 0x81..=0x9F | 0xE0..=0xFC), matches!(trail, 0x40..=0x7E | 0x80..=0xFC)),
|
||
129 => (matches!(lead, 0x81..=0xFE), matches!(trail, 0x41..=0xFE)),
|
||
134 => (matches!(lead, 0x81..=0xFE), matches!(trail, 0x40..=0x7E | 0x80..=0xFE)),
|
||
136 => (matches!(lead, 0x81..=0xFE), matches!(trail, 0x40..=0x7E | 0xA1..=0xFE)),
|
||
// JOHAB_CHARSET: not decoded.
|
||
130 => return (lead >= 0x81).then_some(' '),
|
||
_ => return None,
|
||
};
|
||
if !(is_lead && is_trail) {
|
||
return None;
|
||
}
|
||
one_char(encoding(charset)?, &[lead, trail])
|
||
}
|
||
|
||
/// UTF-16 text to a string with one dx entry per character: a surrogate pair takes the sum of
|
||
/// its two advances. Unpaired surrogates become U+FFFD.
|
||
pub(crate) fn decode_utf16(units: &[u16], dx: &[f32]) -> (String, Vec<f32>) {
|
||
let mut s = String::with_capacity(units.len());
|
||
let mut out_dx = Vec::with_capacity(dx.len().min(units.len()));
|
||
let mut i = 0;
|
||
for r in char::decode_utf16(units.iter().copied()) {
|
||
let c = r.unwrap_or(char::REPLACEMENT_CHARACTER);
|
||
let n = c.len_utf16();
|
||
s.push(c);
|
||
if !dx.is_empty() {
|
||
out_dx.push((i..i + n).filter_map(|k| dx.get(k)).sum());
|
||
}
|
||
i += n;
|
||
}
|
||
(s, out_dx)
|
||
}
|
||
|
||
/// One byte that is not part of a double-byte pair, in its Windows code page. Symbol fonts keep their codes in the private-use
|
||
/// range (U+F000 + code), where symbol fonts map them.
|
||
fn byte_char(b: u8, charset: u8) -> char {
|
||
if b < 0x80 && charset != SYMBOL_CHARSET {
|
||
return char::from(b);
|
||
}
|
||
let cp = match charset {
|
||
SYMBOL_CHARSET => 0xF000 | u32::from(b),
|
||
238 => high(b, &CP1250),
|
||
204 => high(b, &CP1251),
|
||
_ => match encoding(charset) {
|
||
// An undefined byte, and a lead byte with no trail byte, are U+FFFD.
|
||
Some(enc) => return one_char(enc, &[b]).unwrap_or(char::REPLACEMENT_CHARACTER),
|
||
None => high(b, &CP1252),
|
||
},
|
||
};
|
||
char::from_u32(cp).unwrap_or(char::REPLACEMENT_CHARACTER)
|
||
}
|
||
|
||
/// The code point of byte `b` (0x80..=0xFF) from a table of the upper half; 0 entries are
|
||
/// undefined bytes, drawn as U+FFFD.
|
||
fn high(b: u8, table: &[u16; 128]) -> u32 {
|
||
match table.get(usize::from(b.wrapping_sub(0x80))) {
|
||
Some(0) | None => 0xFFFD,
|
||
Some(v) => u32::from(*v),
|
||
}
|
||
}
|
||
|
||
/// Windows-1252 (Western) 0x80..=0xFF: the upper half of Latin-1 with typographic marks in 0x80..=0x9F.
|
||
const CP1252: [u16; 128] = {
|
||
let mut t = [0u16; 128];
|
||
let low: [u16; 32] = [
|
||
0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, 0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0, 0x017D, 0, 0, 0x2018, 0x2019, 0x201C,
|
||
0x201D, 0x2022, 0x2013, 0x2014, 0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0, 0x017E, 0x0178,
|
||
];
|
||
let mut i = 0;
|
||
while i < 128 {
|
||
t[i] = if i < 32 { low[i] } else { 0x80 + i as u16 };
|
||
i += 1;
|
||
}
|
||
t
|
||
};
|
||
|
||
/// Windows-1250 (Central European) 0x80..=0xFF.
|
||
const CP1250: [u16; 128] = [
|
||
0x20AC, 0, 0x201A, 0, 0x201E, 0x2026, 0x2020, 0x2021, 0, 0x2030, 0x0160, 0x2039, 0x015A, 0x0164, 0x017D, 0x0179, //
|
||
0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0, 0x2122, 0x0161, 0x203A, 0x015B, 0x0165, 0x017E, 0x017A, //
|
||
0x00A0, 0x02C7, 0x02D8, 0x0141, 0x00A4, 0x0104, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x015E, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x017B, //
|
||
0x00B0, 0x00B1, 0x02DB, 0x0142, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x0105, 0x015F, 0x00BB, 0x013D, 0x02DD, 0x013E, 0x017C, //
|
||
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E, //
|
||
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7, 0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF, //
|
||
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F, //
|
||
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7, 0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9,
|
||
];
|
||
|
||
/// Windows-1251 (Cyrillic) 0x80..=0xFF; 0xC0..=0xFF are А..я in order.
|
||
const CP1251: [u16; 128] = {
|
||
let low: [u16; 64] = [
|
||
0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021, 0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F, //
|
||
0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F, //
|
||
0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7, 0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407, //
|
||
0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7, 0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
|
||
];
|
||
let mut t = [0u16; 128];
|
||
let mut i = 0;
|
||
while i < 128 {
|
||
t[i] = if i < 64 { low[i] } else { 0x0410 + (i as u16 - 64) };
|
||
i += 1;
|
||
}
|
||
t
|
||
};
|