699 lines
41 KiB
C++
699 lines
41 KiB
C++
#include "parser/pdfium_internal.hpp"
|
|
#include "fonts/face/free_type_manager.hpp"
|
|
#include "fonts/face/font_face.hpp"
|
|
#include "pdfengine/text_layout_engine.hpp"
|
|
namespace pdfengine::parser {
|
|
|
|
std::expected<void, EngineError> PdfiumDocument::applyOp_reflow(const nlohmann::json& op, int pageIndex) {
|
|
#ifdef PDFENGINE_WITH_PDFIUM
|
|
if (!op.contains("data") || !op["data"].is_object()) {
|
|
spdlog::error("reflow_paragraph missing 'data'");
|
|
return std::unexpected(EngineError::InvalidFormat);
|
|
}
|
|
auto data = op["data"];
|
|
|
|
struct RunStyle {
|
|
std::string text;
|
|
std::string internalFontId;
|
|
double fontSize;
|
|
unsigned int r, g, b;
|
|
std::vector<double> advances;
|
|
// When set (and advances.size() == advanceSeedText.size()), advances are
|
|
// metrics for advanceSeedText; merge onto text via LCP/LCS so typing
|
|
// preserves kerning on the unchanged prefix/suffix.
|
|
std::string advanceSeedText;
|
|
};
|
|
std::vector<RunStyle> runs;
|
|
auto parseHex = [](const std::string& hex, unsigned int& r, unsigned int& g, unsigned int& b) {
|
|
r = 0; g = 0; b = 0;
|
|
if (hex.size() >= 7 && hex[0] == '#') {
|
|
auto hv = [](char ch) -> int {
|
|
if (ch >= '0' && ch <= '9') return ch - '0';
|
|
if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
|
|
if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
|
|
return 0;
|
|
};
|
|
r = static_cast<unsigned int>(hv(hex[1]) * 16 + hv(hex[2]));
|
|
g = static_cast<unsigned int>(hv(hex[3]) * 16 + hv(hex[4]));
|
|
b = static_cast<unsigned int>(hv(hex[5]) * 16 + hv(hex[6]));
|
|
}
|
|
};
|
|
auto parseRun = [&](const nlohmann::json& rj) {
|
|
RunStyle rs;
|
|
rs.text = rj.value("text", "");
|
|
rs.internalFontId = rj.value("internalFontId", "");
|
|
rs.fontSize = rj.value("fontSize", 0.0);
|
|
parseHex(rj.value("color", std::string("#000000")), rs.r, rs.g, rs.b);
|
|
if (rj.contains("advances") && rj["advances"].is_array()) {
|
|
for (const auto& a : rj["advances"]) rs.advances.push_back(a.get<double>());
|
|
}
|
|
rs.advanceSeedText = rj.value("advanceSeedText", "");
|
|
runs.push_back(std::move(rs));
|
|
};
|
|
std::vector<std::vector<int>> providedLines;
|
|
bool hasProvidedLines = data.contains("lines") && data["lines"].is_array() && !data["lines"].empty();
|
|
if (hasProvidedLines) {
|
|
for (const auto& lineJson : data["lines"]) {
|
|
std::vector<int> lineRunIdxs;
|
|
if (lineJson.is_array()) {
|
|
for (const auto& rj : lineJson) { lineRunIdxs.push_back(static_cast<int>(runs.size())); parseRun(rj); }
|
|
}
|
|
providedLines.push_back(std::move(lineRunIdxs));
|
|
}
|
|
} else if (data.contains("runs") && data["runs"].is_array()) {
|
|
for (const auto& rj : data["runs"]) parseRun(rj);
|
|
}
|
|
std::vector<int> objectIndices;
|
|
if (data.contains("objectIndices") && data["objectIndices"].is_array()) {
|
|
for (auto& idx : data["objectIndices"]) objectIndices.push_back(idx.get<int>());
|
|
}
|
|
double columnLeft = data.value("columnLeft", 0.0);
|
|
double columnRight = data.value("columnRight", 0.0);
|
|
double firstBaselineY = data.value("firstBaselineY", 0.0);
|
|
double leading = data.value("leading", 0.0);
|
|
int oldLineCount = data.value("oldLineCount", 1);
|
|
std::string align = data.value("align", std::string("left"));
|
|
std::vector<double> lineBaselineY, lineX;
|
|
if (data.contains("lineBaselineY") && data["lineBaselineY"].is_array())
|
|
for (const auto& v : data["lineBaselineY"]) lineBaselineY.push_back(v.get<double>());
|
|
if (data.contains("lineX") && data["lineX"].is_array())
|
|
for (const auto& v : data["lineX"]) lineX.push_back(v.get<double>());
|
|
double columnWidth = columnRight - columnLeft;
|
|
double pushColumnLeft = data.value("pushColumnLeft", columnLeft);
|
|
double hangingIndent = data.value("hangingIndent", 0.0);
|
|
std::string paraId;
|
|
if (data.contains("paraId") && data["paraId"].is_string())
|
|
paraId = data["paraId"].get<std::string>();
|
|
|
|
if (runs.empty() || objectIndices.empty() || columnWidth <= 1.0 || leading <= 0.0) {
|
|
spdlog::warn("reflow_paragraph: insufficient layout data, skipping");
|
|
return {};
|
|
}
|
|
|
|
FPDF_PAGE page = FPDF_LoadPage(doc_, pageIndex);
|
|
if (!page) {
|
|
spdlog::error("Failed to load page {} for reflow_paragraph", pageIndex);
|
|
return std::unexpected(EngineError::Unknown);
|
|
}
|
|
|
|
PageBand startBand = repagComputeBand(page, pushColumnLeft, columnRight);
|
|
double bottomLimitY = startBand.valid ? startBand.bottomLimitY : -1e18;
|
|
std::vector<double> anchoredCentersStart =
|
|
startBand.valid ? repagAnchoredCenters(page, pushColumnLeft, columnRight, bottomLimitY)
|
|
: std::vector<double>{};
|
|
|
|
if (!paraId.empty()) {
|
|
int cont = repagRemoveContinuations(doc_, pageIndex, paraId, pushColumnLeft, columnRight);
|
|
if (cont > 0)
|
|
spdlog::info("reflow_paragraph: removed continuation of paraId={} on {} page(s)", paraId, cont);
|
|
}
|
|
|
|
std::vector<int> paragraphSet = objectIndices;
|
|
{
|
|
float ul = 0, ub = 0, ur = 0, ut = 0; bool haveUnion = false;
|
|
for (int idx : objectIndices) {
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, idx);
|
|
if (!o) continue;
|
|
float l = 0, b = 0, r = 0, t = 0;
|
|
if (!FPDFPageObj_GetBounds(o, &l, &b, &r, &t)) continue;
|
|
if (!haveUnion) { ul = l; ub = b; ur = r; ut = t; haveUnion = true; }
|
|
else {
|
|
if (l < ul) ul = l; if (b < ub) ub = b;
|
|
if (r > ur) ur = r; if (t > ut) ut = t;
|
|
}
|
|
}
|
|
if (haveUnion) {
|
|
const float eps = 0.5f;
|
|
int nObjs = FPDFPage_CountObjects(page);
|
|
int adopted = 0;
|
|
for (int k = 0; k < nObjs; ++k) {
|
|
if (std::find(objectIndices.begin(), objectIndices.end(), k) != objectIndices.end()) continue;
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, k);
|
|
if (!o || FPDFPageObj_GetType(o) != FPDF_PAGEOBJ_TEXT) continue;
|
|
float l = 0, b = 0, r = 0, t = 0;
|
|
if (!FPDFPageObj_GetBounds(o, &l, &b, &r, &t)) continue;
|
|
if (l >= ul - eps && b >= ub - eps && r <= ur + eps && t <= ut + eps) {
|
|
paragraphSet.push_back(k);
|
|
adopted++;
|
|
spdlog::debug("reflow_paragraph: adopted leftover text object idx={} inside paragraph bbox (not in objectIndices) -> prevents bulge/merge + font substitution", k);
|
|
}
|
|
}
|
|
if (adopted > 0)
|
|
spdlog::debug("reflow_paragraph: geometric backstop adopted {} object(s) the model omitted", adopted);
|
|
}
|
|
}
|
|
|
|
if (!paraId.empty()) {
|
|
int nObjs = FPDFPage_CountObjects(page);
|
|
int adoptedById = 0;
|
|
for (int k = 0; k < nObjs; ++k) {
|
|
if (std::find(paragraphSet.begin(), paragraphSet.end(), k) != paragraphSet.end()) continue;
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, k);
|
|
if (o && repagGetParaId(o) == paraId) { paragraphSet.push_back(k); adoptedById++; }
|
|
}
|
|
if (adoptedById > 0)
|
|
spdlog::debug("reflow_paragraph: adopted {} anchor-page object(s) by paraId", adoptedById);
|
|
}
|
|
|
|
double exactNominal = 0.0;
|
|
double exactScaleX = 1.0;
|
|
double exactScaleY = 1.0;
|
|
for (int idx : paragraphSet) {
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, idx);
|
|
if (!o || FPDFPageObj_GetType(o) != FPDF_PAGEOBJ_TEXT) continue;
|
|
float nom = 0;
|
|
if (FPDFTextObj_GetFontSize(o, &nom) && nom > 0.1) {
|
|
FS_MATRIX mtx;
|
|
if (FPDFPageObj_GetMatrix(o, &mtx)) {
|
|
exactScaleX = std::sqrt(static_cast<double>(mtx.a) * mtx.a + static_cast<double>(mtx.b) * mtx.b);
|
|
exactScaleY = std::sqrt(static_cast<double>(mtx.c) * mtx.c + static_cast<double>(mtx.d) * mtx.d);
|
|
exactNominal = nom;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
double textAspect = 1.0;
|
|
if (exactNominal > 0.1 && exactScaleY > 0.001) {
|
|
double trueVerticalSize = exactNominal * exactScaleY;
|
|
for (auto& rs : runs) {
|
|
spdlog::info("[STAGE_3_WASM_INPUT] fontSize={:.2f}, trueVerticalSize={:.2f}, exactNominal={:.2f}, exactScaleY={:.4f}", rs.fontSize, trueVerticalSize, exactNominal, exactScaleY);
|
|
if (rs.fontSize <= 0.0 || rs.fontSize < trueVerticalSize * 0.85) {
|
|
rs.fontSize = trueVerticalSize;
|
|
}
|
|
}
|
|
textAspect = exactScaleX / exactScaleY;
|
|
} else {
|
|
for (auto& rs : runs) {
|
|
if (rs.fontSize <= 0.0) {
|
|
rs.fontSize = 12.0;
|
|
}
|
|
}
|
|
}
|
|
spdlog::info("[FONT_METRICS_DEBUG] exactNominal={:.2f}, exactScaleX={:.2f}, exactScaleY={:.2f}, trueVerticalSize={:.2f}, textAspect={:.2f}", exactNominal, exactScaleX, exactScaleY, exactNominal * exactScaleY, textAspect);
|
|
|
|
std::vector<EmissionFont> runFonts(runs.size());
|
|
// utf8_to_utf16le appends a trailing NUL for PDFium wide-string APIs.
|
|
// That terminator is not text content and must not enter coverage checks.
|
|
auto toCodepoints = [](const std::string& s) {
|
|
auto u16 = utf8_to_utf16le(s);
|
|
std::vector<uint32_t> cps;
|
|
for (size_t i = 0; i < u16.size();) {
|
|
uint32_t cp = u16[i];
|
|
if (cp >= 0xD800 && cp <= 0xDBFF && i + 1 < u16.size()) {
|
|
uint32_t low = u16[i + 1];
|
|
if (low >= 0xDC00 && low <= 0xDFFF) { cp = 0x10000 + ((cp - 0xD800) << 10) + (low - 0xDC00); i += 2; }
|
|
else i += 1;
|
|
} else i += 1;
|
|
if (cp == 0) continue;
|
|
cps.push_back(cp);
|
|
}
|
|
return cps;
|
|
};
|
|
{
|
|
std::unordered_map<std::string, std::vector<uint32_t>> fontCps;
|
|
for (const auto& rs : runs) {
|
|
auto cps = toCodepoints(rs.text);
|
|
auto& dst = fontCps[rs.internalFontId];
|
|
dst.insert(dst.end(), cps.begin(), cps.end());
|
|
}
|
|
auto resolveOrigFont = [&](const std::string& fid) -> FPDF_FONT {
|
|
const std::string expected = baseNameFromInternalFontId(fid);
|
|
for (int idx : paragraphSet) {
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, idx);
|
|
if (!o || FPDFPageObj_GetType(o) != FPDF_PAGEOBJ_TEXT) continue;
|
|
FPDF_FONT fo = FPDFTextObj_GetFont(o);
|
|
if (!fo) continue;
|
|
size_t nl = FPDFFont_GetBaseFontName(fo, nullptr, 0);
|
|
if (nl == 0) continue;
|
|
std::vector<char> nb(nl);
|
|
if (FPDFFont_GetBaseFontName(fo, nb.data(), nl) == 0) continue;
|
|
if (std::string(nb.data()) == expected) return fo;
|
|
}
|
|
return nullptr;
|
|
};
|
|
std::unordered_map<std::string, EmissionFont> fontByFid;
|
|
for (const auto& rs : runs) {
|
|
if (!fontByFid.count(rs.internalFontId))
|
|
fontByFid[rs.internalFontId] = loadEmissionFont(pageIndex, rs.internalFontId, rs.fontSize, fontCps[rs.internalFontId], paragraphSet, resolveOrigFont(rs.internalFontId));
|
|
}
|
|
for (size_t ri = 0; ri < runs.size(); ++ri) runFonts[ri] = fontByFid[runs[ri].internalFontId];
|
|
|
|
for (size_t ri = 0; ri < runs.size(); ++ri) {
|
|
const fonts::FontFace* face = runFonts[ri].measureFace
|
|
? runFonts[ri].measureFace.get()
|
|
: (runFonts[ri].resolved ? &runFonts[ri].resolved->getFontFace() : nullptr);
|
|
runs[ri].text = normalizeReflowText(runs[ri].text, face);
|
|
}
|
|
}
|
|
|
|
fonts::HbShaper shaper;
|
|
constexpr unsigned int kRefSize = 1000;
|
|
auto perCharAdvances = [&](size_t runIdx, const std::string& text) -> std::vector<double> {
|
|
std::vector<double> out(text.size(), 0.0);
|
|
if (text.empty()) return out;
|
|
auto& rf = runFonts[runIdx];
|
|
double size = runs[runIdx].fontSize > 0 ? runs[runIdx].fontSize : 12.0;
|
|
double scale = (size * textAspect) / static_cast<double>(kRefSize);
|
|
fonts::FontFace* face = rf.measureFace ? rf.measureFace.get()
|
|
: (rf.resolved ? &rf.resolved->getFontFace() : nullptr);
|
|
if (face) {
|
|
auto glyphs = shaper.shapeRun(text, *face, kRefSize);
|
|
if (glyphs.size() == text.size()) {
|
|
for (size_t i = 0; i < text.size(); ++i) out[i] = glyphs[i].advanceX * scale;
|
|
return out;
|
|
}
|
|
double w = 0.0; for (auto& gph : glyphs) w += gph.advanceX;
|
|
double per = w * scale / static_cast<double>(text.size());
|
|
for (auto& v : out) v = per;
|
|
return out;
|
|
}
|
|
for (auto& v : out) v = size * 0.5;
|
|
return out;
|
|
};
|
|
|
|
// Forensic flag: force whole-run emission while keeping client advances.
|
|
// Set data.forensicForceWholeRun=true to isolate whether runPerChar causes the visual change.
|
|
const bool forensicForceWholeRun = data.value("forensicForceWholeRun", false);
|
|
std::vector<std::vector<double>> runCharAdv(runs.size());
|
|
std::vector<char> runPerChar(runs.size(), 0);
|
|
|
|
// Merge seed advances onto edited text: keep LCP/LCS metrics, HB-fill the edit middle.
|
|
// (Logic inlined in the run loop so unchanged glyphs are never passed to HarfBuzz.)
|
|
|
|
for (size_t ri = 0; ri < runs.size(); ++ri) {
|
|
const auto& rs = runs[ri];
|
|
bool usedClient = false;
|
|
|
|
// Prefer client/seed advances for UNCHANGED glyphs. Only HarfBuzz-shape
|
|
// characters that are not covered by seed metrics (the edited middle).
|
|
if (rs.advances.size() == rs.text.size() && !rs.text.empty()) {
|
|
runCharAdv[ri] = rs.advances;
|
|
usedClient = true;
|
|
} else if (!rs.advanceSeedText.empty()
|
|
&& rs.advances.size() == rs.advanceSeedText.size()
|
|
&& !rs.text.empty()) {
|
|
// Shape only the middle gap; prefix/suffix keep seed advances.
|
|
size_t p = 0;
|
|
const auto& seed = rs.advanceSeedText;
|
|
while (p < seed.size() && p < rs.text.size() && seed[p] == rs.text[p]) ++p;
|
|
size_t s = 0;
|
|
while (s < seed.size() - p && s < rs.text.size() - p
|
|
&& seed[seed.size() - 1 - s] == rs.text[rs.text.size() - 1 - s]) ++s;
|
|
runCharAdv[ri].assign(rs.text.size(), 0.0);
|
|
for (size_t i = 0; i < p; ++i) runCharAdv[ri][i] = rs.advances[i];
|
|
for (size_t i = 0; i < s; ++i)
|
|
runCharAdv[ri][rs.text.size() - 1 - i] = rs.advances[seed.size() - 1 - i];
|
|
if (p + s < rs.text.size()) {
|
|
std::string middle = rs.text.substr(p, rs.text.size() - p - s);
|
|
auto midNat = perCharAdvances(ri, middle);
|
|
for (size_t i = 0; i < midNat.size(); ++i) runCharAdv[ri][p + i] = midNat[i];
|
|
}
|
|
usedClient = true;
|
|
spdlog::info("[ADVANCE_SEED_MERGE] run={} seedLen={} textLen={} "
|
|
"prefixKept={} suffixKept={} (unchanged glyphs not reshaped)",
|
|
ri, seed.size(), rs.text.size(), p, s);
|
|
} else if (!rs.advances.empty() && !rs.text.empty()
|
|
&& rs.advances.size() < rs.text.size()) {
|
|
// Prefix-only advances (append without advanceSeedText).
|
|
runCharAdv[ri] = perCharAdvances(ri, rs.text);
|
|
for (size_t c = 0; c < rs.advances.size(); ++c) runCharAdv[ri][c] = rs.advances[c];
|
|
usedClient = true;
|
|
spdlog::info("[ADVANCE_PREFIX_KEEP] run={} prefixAdv={} textLen={} "
|
|
"(unchanged prefix kept; only suffix reshaped)",
|
|
ri, rs.advances.size(), rs.text.size());
|
|
} else if (!rs.advances.empty() && !rs.text.empty()
|
|
&& rs.advances.size() > rs.text.size()) {
|
|
// Truncate (end-delete without advanceSeedText).
|
|
runCharAdv[ri].assign(rs.advances.begin(),
|
|
rs.advances.begin() + static_cast<std::ptrdiff_t>(rs.text.size()));
|
|
usedClient = true;
|
|
} else {
|
|
// FIRST MUTATION SITE when client advances are missing/mismatched:
|
|
// HarfBuzz recomputes advances for EVERY glyph, including unchanged ones.
|
|
runCharAdv[ri] = perCharAdvances(ri, rs.text);
|
|
spdlog::warn("[ADVANCE_RECOMPUTE_ALL] run={} textLen={} advLen={} "
|
|
"FIRST_MUTATION=perCharAdvances full reshape (no client advances)",
|
|
ri, rs.text.size(), rs.advances.size());
|
|
}
|
|
|
|
if (usedClient) {
|
|
// Client advances (esp. PDF TJ kerning) diverge from HarfBuzz naturals.
|
|
// Emit per-glyph so those advances are applied; do NOT replace them.
|
|
auto natural = perCharAdvances(ri, rs.text);
|
|
bool diverges = natural.size() != runCharAdv[ri].size();
|
|
for (size_t c = 0; !diverges && c < natural.size(); ++c)
|
|
if (std::abs(natural[c] - runCharAdv[ri][c]) > 0.05) diverges = true;
|
|
runPerChar[ri] = (forensicForceWholeRun ? 0 : (diverges ? 1 : 0));
|
|
spdlog::info("[FORENSIC_RUNPERCHAR] run={} textLen={} advLen={} seedLen={} diverges={} forceWhole={} runPerChar={} natural0={:.4f} client0={:.4f} measureFace={}",
|
|
ri, rs.text.size(), rs.advances.size(), rs.advanceSeedText.size(), diverges,
|
|
forensicForceWholeRun, (int)runPerChar[ri],
|
|
natural.empty() ? -1.0 : natural[0],
|
|
runCharAdv[ri].empty() ? -1.0 : runCharAdv[ri][0],
|
|
(bool)(runFonts[ri].measureFace));
|
|
} else {
|
|
spdlog::info("[FORENSIC_RUNPERCHAR] run={} textLen={} advLen={} -> recomputed advances (no client match) runPerChar=0 forceWhole={}",
|
|
ri, rs.text.size(), rs.advances.size(), forensicForceWholeRun);
|
|
}
|
|
}
|
|
auto charAdvAt = [&](int ri, size_t off) -> double {
|
|
const auto& v = runCharAdv[static_cast<size_t>(ri)];
|
|
return off < v.size() ? v[off] : 0.0;
|
|
};
|
|
|
|
auto isSpace = [](char ch) { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'; };
|
|
constexpr size_t kHardBreak = static_cast<size_t>(-1);
|
|
struct Seg { int runIdx; std::string text; double width; size_t off; };
|
|
struct Word { std::vector<Seg> segs; double width; double spaceAfter; };
|
|
std::vector<Word> words;
|
|
|
|
auto tokenize = [&](const std::vector<int>& runIdxs) -> std::vector<size_t> {
|
|
std::string ft; std::vector<int> sof; std::vector<size_t> cof;
|
|
for (int ri : runIdxs) {
|
|
size_t off = 0;
|
|
for (char ch : runs[ri].text) { ft.push_back(ch); sof.push_back(ri); cof.push_back(off++); }
|
|
}
|
|
std::vector<size_t> out;
|
|
size_t i = 0;
|
|
while (i < ft.size()) {
|
|
if (isSpace(ft[i])) { if (ft[i] == '\n') out.push_back(kHardBreak); i++; continue; }
|
|
Word w; w.width = 0.0; w.spaceAfter = 0.0;
|
|
while (i < ft.size() && !isSpace(ft[i])) {
|
|
int st = sof[i]; size_t segOff = cof[i]; std::string frag; double fw = 0.0;
|
|
while (i < ft.size() && !isSpace(ft[i]) && sof[i] == st) { frag.push_back(ft[i]); fw += charAdvAt(st, cof[i]); i++; }
|
|
w.segs.push_back({st, frag, fw, segOff}); w.width += fw;
|
|
}
|
|
size_t newlines = 0;
|
|
while (i < ft.size() && isSpace(ft[i])) {
|
|
if (ft[i] == '\n') newlines++;
|
|
else if (newlines == 0) w.spaceAfter += charAdvAt(sof[i], cof[i]);
|
|
i++;
|
|
}
|
|
out.push_back(words.size());
|
|
words.push_back(std::move(w));
|
|
for (size_t n = 0; n < newlines; ++n) out.push_back(kHardBreak);
|
|
}
|
|
return out;
|
|
};
|
|
|
|
std::vector<std::vector<size_t>> lines;
|
|
std::vector<char> lineCont;
|
|
std::vector<char> lineSegEnd;
|
|
if (hasProvidedLines) {
|
|
for (const auto& lineRunIdxs : providedLines) {
|
|
auto wi = tokenize(lineRunIdxs);
|
|
wi.erase(std::remove(wi.begin(), wi.end(), kHardBreak), wi.end());
|
|
if (!wi.empty()) { lines.push_back(std::move(wi)); lineCont.push_back(0); lineSegEnd.push_back(0); }
|
|
}
|
|
for (size_t li = 0; li < lineSegEnd.size(); ++li)
|
|
lineSegEnd[li] = (li + 1 == lineSegEnd.size()) ? 1 : 0;
|
|
} else {
|
|
std::vector<int> allRuns(runs.size());
|
|
for (size_t ri = 0; ri < runs.size(); ++ri) allRuns[ri] = static_cast<int>(ri);
|
|
auto allWords = tokenize(allRuns);
|
|
std::vector<size_t> cur; double curW = 0.0;
|
|
size_t prevWord = kHardBreak;
|
|
bool firstLineOfSeg = true;
|
|
auto pushLine = [&](char segEnd) {
|
|
lines.push_back(cur);
|
|
lineCont.push_back(firstLineOfSeg ? 0 : 1);
|
|
lineSegEnd.push_back(segEnd);
|
|
};
|
|
spdlog::info("[KEYSTROKE_BACKEND_DEBUG] columnLeft={:.2f}, columnRight={:.2f}, columnWidth={:.2f}, firstBaselineY={:.2f}, oldLineCount={}, hangingIndent={:.2f}",
|
|
columnLeft, columnRight, columnWidth, firstBaselineY, oldLineCount, hangingIndent);
|
|
for (size_t k = 0; k < allWords.size(); ++k) {
|
|
size_t wi = allWords[k];
|
|
if (wi == kHardBreak) { // forced break: end the current line (may be blank)
|
|
pushLine(1);
|
|
cur.clear(); curW = 0.0; prevWord = kHardBreak; firstLineOfSeg = true;
|
|
continue;
|
|
}
|
|
double effW = columnWidth - (firstLineOfSeg ? 0.0 : hangingIndent);
|
|
double gap = (cur.empty() || prevWord == kHardBreak) ? 0.0 : words[prevWord].spaceAfter;
|
|
if (!cur.empty() && curW + gap + words[wi].width > effW) {
|
|
spdlog::info("[KEYSTROKE_BACKEND_WRAP] Wrapped at word index {} ('{}'): curW={:.2f}, gap={:.2f}, wordW={:.2f}, sum={:.2f} > effW={:.2f} (columnWidth={:.2f})",
|
|
wi, words[wi].segs.empty() ? "" : words[wi].segs[0].text, curW, gap, words[wi].width, curW + gap + words[wi].width, effW, columnWidth);
|
|
pushLine(0);
|
|
cur.clear(); firstLineOfSeg = false;
|
|
cur.push_back(wi); curW = words[wi].width;
|
|
} else {
|
|
cur.push_back(wi); curW += gap + words[wi].width;
|
|
}
|
|
prevWord = wi;
|
|
}
|
|
if (!cur.empty()) pushLine(1);
|
|
}
|
|
if (words.empty() || lines.empty()) { FPDF_ClosePage(page); return {}; }
|
|
int newLineCount = static_cast<int>(lines.size());
|
|
|
|
double deltaH = (newLineCount - oldLineCount) * leading;
|
|
double paragraphBottomBaseline = firstBaselineY - (oldLineCount - 1) * leading;
|
|
if (std::abs(deltaH) > 0.01) {
|
|
double threshold = paragraphBottomBaseline - 0.5 * leading;
|
|
int nObjs = FPDFPage_CountObjects(page);
|
|
int pushed = 0;
|
|
for (int k = 0; k < nObjs; ++k) {
|
|
if (std::find(paragraphSet.begin(), paragraphSet.end(), k) != paragraphSet.end()) continue;
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, k);
|
|
if (!o) continue;
|
|
float l = 0, bo = 0, rr = 0, tt = 0;
|
|
if (!FPDFPageObj_GetBounds(o, &l, &bo, &rr, &tt)) continue;
|
|
double cY = (bo + tt) / 2.0;
|
|
if (cY < threshold && cY >= bottomLimitY && rr > pushColumnLeft && l < columnRight) {
|
|
FPDFPageObj_Transform(o, 1.0, 0.0, 0.0, 1.0, 0.0, -deltaH);
|
|
pushed++;
|
|
}
|
|
}
|
|
spdlog::info("reflow_paragraph: lines {}->{}, deltaH={}, pushed {} objects", oldLineCount, newLineCount, deltaH, pushed);
|
|
}
|
|
|
|
std::sort(paragraphSet.begin(), paragraphSet.end(), std::greater<int>());
|
|
int minIndex = paragraphSet.back();
|
|
for (int idx : paragraphSet) {
|
|
FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, idx);
|
|
if (o) { FPDFPage_RemoveObject(page, o); FPDFPageObj_Destroy(o); }
|
|
}
|
|
|
|
nlohmann::json layoutLines = nlohmann::json::array();
|
|
for (size_t li = 0; li < lines.size(); ++li) {
|
|
double baselineY = (li < lineBaselineY.size())
|
|
? lineBaselineY[li] : firstBaselineY - static_cast<double>(li) * leading;
|
|
auto& lw = lines[li];
|
|
double naturalW = 0.0;
|
|
for (size_t k = 0; k < lw.size(); ++k) {
|
|
naturalW += words[lw[k]].width;
|
|
if (k > 0) naturalW += words[lw[k - 1]].spaceAfter;
|
|
}
|
|
double indent = (li < lineCont.size() && lineCont[li]) ? hangingIndent : 0.0;
|
|
double effCol = columnWidth - indent;
|
|
bool segEnd = (li < lineSegEnd.size()) ? (lineSegEnd[li] != 0) : (li + 1 == lines.size());
|
|
bool justifyThis = (align == "justify") && !segEnd && lw.size() > 1;
|
|
double extraPerGap = 0.0;
|
|
if (justifyThis) { double slack = effCol - naturalW; if (slack > 0) extraPerGap = slack / static_cast<double>(lw.size() - 1); }
|
|
|
|
std::string lineText;
|
|
std::vector<double> adv;
|
|
double lineFontSize = 0.0;
|
|
double x = (li < lineX.size()) ? lineX[li] : (columnLeft + indent);
|
|
if (li >= lineX.size()) {
|
|
if (align == "right") x = columnLeft + indent + (effCol - naturalW);
|
|
else if (align == "center") x = columnLeft + indent + (effCol - naturalW) / 2.0;
|
|
}
|
|
const double lineStartX = x;
|
|
for (size_t k = 0; k < lw.size(); ++k) {
|
|
size_t wi = lw[k];
|
|
if (k > 0) {
|
|
double gap = words[lw[k - 1]].spaceAfter + (justifyThis ? extraPerGap : 0.0);
|
|
x += gap;
|
|
lineText.push_back(' ');
|
|
adv.push_back(gap);
|
|
}
|
|
for (auto& seg : words[wi].segs) {
|
|
double segX = x;
|
|
FPDF_FONT font = runFonts[seg.runIdx].font;
|
|
double emitFontSize = runs[seg.runIdx].fontSize;
|
|
double mtxScaleX = textAspect;
|
|
double mtxScaleY = 1.0;
|
|
if (exactNominal > 0.1 && exactScaleY > 0.001) {
|
|
emitFontSize = exactNominal;
|
|
mtxScaleX = exactScaleX;
|
|
mtxScaleY = exactScaleY;
|
|
lineFontSize = exactNominal * exactScaleY;
|
|
} else {
|
|
lineFontSize = (std::max)(lineFontSize, runs[seg.runIdx].fontSize);
|
|
}
|
|
spdlog::info("[STAGE_4_REFLOW_OUTPUT] lineFontSize={:.2f}, emitFontSize={:.2f}, mtxScaleY={:.4f}", lineFontSize, emitFontSize, mtxScaleY);
|
|
auto emitObj = [&](const std::string& s, double atX) {
|
|
if (!font || s.empty()) return;
|
|
std::string baseFontName;
|
|
{
|
|
size_t nl = FPDFFont_GetBaseFontName(font, nullptr, 0);
|
|
if (nl > 0) {
|
|
std::vector<char> nb(nl);
|
|
if (FPDFFont_GetBaseFontName(font, nb.data(), nl) > 0)
|
|
baseFontName = nb.data();
|
|
}
|
|
}
|
|
const auto& ef = runFonts[seg.runIdx];
|
|
spdlog::info("[EMIT_FONT] text='{}' baseFont='{}' fontPtr={} measureFacePtr={} "
|
|
"hasResolved={} fontSize={:.4f} atX={:.4f} baselineY={:.4f} "
|
|
"mtxScaleX={:.4f} mtxScaleY={:.4f} runPerChar={} internalFontId='{}'",
|
|
s, baseFontName, (void*)font,
|
|
(void*)(ef.measureFace ? ef.measureFace.get() : nullptr),
|
|
(bool)ef.resolved, emitFontSize, atX, baselineY,
|
|
mtxScaleX, mtxScaleY, (int)runPerChar[seg.runIdx],
|
|
runs[seg.runIdx].internalFontId);
|
|
FPDF_PAGEOBJECT obj = FPDFPageObj_CreateTextObj(doc_, font, static_cast<float>(emitFontSize));
|
|
if (!obj) return;
|
|
FPDFPageObj_SetFillColor(obj, runs[seg.runIdx].r, runs[seg.runIdx].g, runs[seg.runIdx].b, 255);
|
|
auto u16 = utf8_to_utf16le(s); u16.push_back(0);
|
|
FPDFText_SetText(obj, reinterpret_cast<FPDF_WIDESTRING>(u16.data()));
|
|
FPDFPageObj_Transform(obj, mtxScaleX, 0.0, 0.0, mtxScaleY, atX, baselineY);
|
|
repagSetParaId(doc_, obj, paraId);
|
|
FPDFPage_InsertObjectAtIndex(page, obj, minIndex);
|
|
FS_MATRIX objMtx;
|
|
FPDFPageObj_GetMatrix(obj, &objMtx);
|
|
float objFS = 0;
|
|
FPDFTextObj_GetFontSize(obj, &objFS);
|
|
float l = 0, b = 0, r = 0, t = 0;
|
|
FPDFPageObj_GetBounds(obj, &l, &b, &r, &t);
|
|
FPDF_FONT objFont = FPDFTextObj_GetFont(obj);
|
|
std::string objBase;
|
|
if (objFont) {
|
|
size_t nl = FPDFFont_GetBaseFontName(objFont, nullptr, 0);
|
|
if (nl > 0) {
|
|
std::vector<char> nb(nl);
|
|
if (FPDFFont_GetBaseFontName(objFont, nb.data(), nl) > 0)
|
|
objBase = nb.data();
|
|
}
|
|
}
|
|
spdlog::info("[EDITED_TEXT_OBJECT_DEBUG] text='{}' objBaseFont='{}' fontSize={:.2f}, "
|
|
"matrix=[{:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}, {:.4f}], "
|
|
"bbox=[{:.2f}, {:.2f}, {:.2f}, {:.2f}]",
|
|
s, objBase, objFS,
|
|
objMtx.a, objMtx.b, objMtx.c, objMtx.d, objMtx.e, objMtx.f,
|
|
l, b, r, t);
|
|
};
|
|
if (runPerChar[seg.runIdx]) {
|
|
double gx = segX;
|
|
for (size_t c = 0; c < seg.text.size(); ++c) {
|
|
double a = charAdvAt(seg.runIdx, seg.off + c);
|
|
if (seg.text[c] != ' ') emitObj(std::string(1, seg.text[c]), gx);
|
|
lineText.push_back(seg.text[c]); adv.push_back(a);
|
|
gx += a;
|
|
}
|
|
} else {
|
|
emitObj(seg.text, segX);
|
|
for (size_t c = 0; c < seg.text.size(); ++c) { lineText.push_back(seg.text[c]); adv.push_back(charAdvAt(seg.runIdx, seg.off + c)); }
|
|
}
|
|
segX += seg.width;
|
|
}
|
|
x += words[wi].width;
|
|
}
|
|
layoutLines.push_back({
|
|
{"baselineY", baselineY}, {"x0", lineStartX},
|
|
{"fontSize", lineFontSize > 0 ? lineFontSize : leading / 1.2},
|
|
{"text", lineText}, {"adv", adv},
|
|
});
|
|
}
|
|
|
|
{
|
|
int pageOff = 0; double cur = 0.0; bool flowing = false;
|
|
for (auto& ln : layoutLines) {
|
|
double b = ln["baselineY"].get<double>();
|
|
if (!flowing && startBand.valid && b < startBand.bottomLimitY - 0.01) {
|
|
flowing = true; pageOff = 1; cur = startBand.placementTopY;
|
|
}
|
|
if (flowing) {
|
|
if (cur < startBand.bottomLimitY - 0.01) { pageOff++; cur = startBand.placementTopY; }
|
|
ln["baselineY"] = cur; cur -= leading;
|
|
}
|
|
ln["pageIndex"] = pageIndex + pageOff;
|
|
}
|
|
}
|
|
lastReflowLayout_ = nlohmann::json{
|
|
{"columnLeft", columnLeft}, {"anchorPage", pageIndex}, {"lines", layoutLines}}.dump();
|
|
spdlog::info("[STAGE_5_SERIALIZED_JSON] {}", lastReflowLayout_);
|
|
|
|
if (!FPDFPage_GenerateContent(page)) {
|
|
spdlog::error("Failed to generate page content after reflow_paragraph");
|
|
}
|
|
FPDF_ClosePage(page);
|
|
|
|
lastReflowOverflowed_ = false;
|
|
if (startBand.valid) {
|
|
int moved = 0;
|
|
int added = repaginateForward(doc_, pageIndex, columnLeft, columnRight,
|
|
pushColumnLeft, leading, anchoredCentersStart, &moved);
|
|
int removed = repaginateBackward(doc_, pageIndex, columnLeft, columnRight,
|
|
pushColumnLeft, leading);
|
|
lastReflowOverflowed_ = (moved > 0 || added > 0 || removed > 0);
|
|
if (added > 0 || removed > 0)
|
|
spdlog::info("reflow_paragraph: cross-page reflow added {} / removed {} page(s)",
|
|
added, removed);
|
|
}
|
|
return {};
|
|
#else
|
|
(void)op; (void)pageIndex;
|
|
return std::unexpected(EngineError::Unknown);
|
|
#endif
|
|
}
|
|
|
|
std::string PdfiumDocument::validateLayout(int pageIndex, const std::string& jsonStr) {
|
|
#ifdef PDFENGINE_WITH_PDFIUM
|
|
try {
|
|
auto data = nlohmann::json::parse(jsonStr);
|
|
if (!data.is_object()) return "{}";
|
|
|
|
std::string text = "";
|
|
std::string internalFontId = "";
|
|
double fontSize = 12.0;
|
|
|
|
if (data.contains("runs") && data["runs"].is_array() && !data["runs"].empty()) {
|
|
auto run = data["runs"][0];
|
|
text = run.value("text", "");
|
|
internalFontId = run.value("internalFontId", "");
|
|
fontSize = run.value("fontSize", 12.0);
|
|
}
|
|
|
|
text::LayoutConstraints constraints;
|
|
constraints.columnLeft = data.value("columnLeft", 0.0);
|
|
constraints.columnRight = data.value("columnRight", 0.0);
|
|
constraints.firstBaselineY = data.value("firstBaselineY", 0.0);
|
|
constraints.leading = data.value("leading", 0.0);
|
|
|
|
auto fontDataRes = getFontData(internalFontId);
|
|
auto face = std::make_shared<fonts::FontFace>();
|
|
if (!fontDataRes || !face->loadFromMemory(*fontDataRes)) {
|
|
return "{}";
|
|
}
|
|
|
|
text::TextLayoutEngine engine;
|
|
auto layout = engine.ComputeLayout(text, constraints, *face, fontSize);
|
|
|
|
nlohmann::json out;
|
|
out["lines"] = nlohmann::json::array();
|
|
for (const auto& l : layout.lines) {
|
|
out["lines"].push_back({
|
|
{"rect", {{"x", l.rect.x}, {"y", l.rect.y}, {"width", l.rect.width}, {"height", l.rect.height}}}
|
|
});
|
|
}
|
|
out["glyphs"] = nlohmann::json::array();
|
|
for (const auto& g : layout.glyphs) {
|
|
out["glyphs"].push_back({
|
|
{"x", g.x}, {"y", g.y}, {"width", g.width}, {"advance", g.advance},
|
|
{"ascent", g.ascent}, {"descent", g.descent}, {"cluster", g.cluster},
|
|
{"text", g.text}
|
|
});
|
|
}
|
|
return out.dump();
|
|
} catch (...) {
|
|
return "{}";
|
|
}
|
|
#else
|
|
(void)pageIndex; (void)jsonStr;
|
|
return "{}";
|
|
#endif
|
|
}
|
|
|
|
}
|