630 lines
24 KiB
C++
630 lines
24 KiB
C++
/*
|
|
* pdf_page.cpp
|
|
* PDF content stream parsing and text extraction
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include "pdfviewer.h"
|
|
|
|
// ============================================================================
|
|
// Content Stream Tokenizer
|
|
// ============================================================================
|
|
|
|
enum TokType {
|
|
TOK_EOF, TOK_INT, TOK_REAL, TOK_STRING, TOK_HEX_STRING,
|
|
TOK_NAME, TOK_ARRAY_START, TOK_ARRAY_END, TOK_OPERATOR
|
|
};
|
|
|
|
struct Token {
|
|
TokType type;
|
|
float num;
|
|
char str[MAX_TEXT_LEN];
|
|
int str_len;
|
|
};
|
|
|
|
static int next_token(const uint8_t* d, int len, int p, Token* tok) {
|
|
// Skip whitespace
|
|
while (p < len && (d[p] == ' ' || d[p] == '\t' || d[p] == '\n' || d[p] == '\r'))
|
|
p++;
|
|
|
|
// Skip comments
|
|
while (p < len && d[p] == '%') {
|
|
while (p < len && d[p] != '\n' && d[p] != '\r') p++;
|
|
while (p < len && (d[p] == ' ' || d[p] == '\t' || d[p] == '\n' || d[p] == '\r'))
|
|
p++;
|
|
}
|
|
|
|
if (p >= len) { tok->type = TOK_EOF; return p; }
|
|
|
|
// Literal string
|
|
if (d[p] == '(') {
|
|
p++;
|
|
int depth = 1;
|
|
tok->type = TOK_STRING;
|
|
tok->str_len = 0;
|
|
while (p < len && depth > 0) {
|
|
if (d[p] == '\\' && p + 1 < len) {
|
|
p++;
|
|
char c;
|
|
switch (d[p]) {
|
|
case 'n': c = '\n'; break;
|
|
case 'r': c = '\r'; break;
|
|
case 't': c = '\t'; break;
|
|
case 'b': c = '\b'; break;
|
|
case 'f': c = '\f'; break;
|
|
case '(': c = '('; break;
|
|
case ')': c = ')'; break;
|
|
case '\\': c = '\\'; break;
|
|
default:
|
|
// Octal escape
|
|
if (d[p] >= '0' && d[p] <= '7') {
|
|
int val = d[p] - '0';
|
|
if (p + 1 < len && d[p + 1] >= '0' && d[p + 1] <= '7') {
|
|
p++; val = val * 8 + (d[p] - '0');
|
|
if (p + 1 < len && d[p + 1] >= '0' && d[p + 1] <= '7') {
|
|
p++; val = val * 8 + (d[p] - '0');
|
|
}
|
|
}
|
|
c = (char)val;
|
|
} else {
|
|
c = (char)d[p];
|
|
}
|
|
break;
|
|
}
|
|
if (tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = c;
|
|
p++;
|
|
} else if (d[p] == '(') {
|
|
depth++;
|
|
if (tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = '(';
|
|
p++;
|
|
} else if (d[p] == ')') {
|
|
depth--;
|
|
if (depth > 0 && tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = ')';
|
|
p++;
|
|
} else {
|
|
if (tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = (char)d[p];
|
|
p++;
|
|
}
|
|
}
|
|
tok->str[tok->str_len] = '\0';
|
|
return p;
|
|
}
|
|
|
|
// Hex string
|
|
if (d[p] == '<' && (p + 1 >= len || d[p + 1] != '<')) {
|
|
p++;
|
|
tok->type = TOK_HEX_STRING;
|
|
tok->str_len = 0;
|
|
int nibble = -1;
|
|
while (p < len && d[p] != '>') {
|
|
int val = -1;
|
|
if (d[p] >= '0' && d[p] <= '9') val = d[p] - '0';
|
|
else if (d[p] >= 'a' && d[p] <= 'f') val = d[p] - 'a' + 10;
|
|
else if (d[p] >= 'A' && d[p] <= 'F') val = d[p] - 'A' + 10;
|
|
p++;
|
|
if (val < 0) continue;
|
|
if (nibble < 0) {
|
|
nibble = val;
|
|
} else {
|
|
if (tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = (char)((nibble << 4) | val);
|
|
nibble = -1;
|
|
}
|
|
}
|
|
if (nibble >= 0 && tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = (char)(nibble << 4);
|
|
tok->str[tok->str_len] = '\0';
|
|
if (p < len) p++; // skip '>'
|
|
return p;
|
|
}
|
|
|
|
// Array start/end
|
|
if (d[p] == '[') { tok->type = TOK_ARRAY_START; return p + 1; }
|
|
if (d[p] == ']') { tok->type = TOK_ARRAY_END; return p + 1; }
|
|
|
|
// Name
|
|
if (d[p] == '/') {
|
|
p++;
|
|
tok->type = TOK_NAME;
|
|
tok->str_len = 0;
|
|
while (p < len && d[p] != ' ' && d[p] != '\t' && d[p] != '\n' &&
|
|
d[p] != '\r' && d[p] != '/' && d[p] != '<' && d[p] != '>' &&
|
|
d[p] != '[' && d[p] != ']' && d[p] != '(' && d[p] != ')') {
|
|
if (tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = (char)d[p];
|
|
p++;
|
|
}
|
|
tok->str[tok->str_len] = '\0';
|
|
return p;
|
|
}
|
|
|
|
// Number or operator
|
|
if ((d[p] >= '0' && d[p] <= '9') || d[p] == '-' || d[p] == '+' || d[p] == '.') {
|
|
// Try to parse as number
|
|
float val;
|
|
int np = parse_real_at(d, len, p, &val);
|
|
if (np > p) {
|
|
tok->type = TOK_REAL;
|
|
tok->num = val;
|
|
return np;
|
|
}
|
|
}
|
|
|
|
// Operator (keyword)
|
|
tok->type = TOK_OPERATOR;
|
|
tok->str_len = 0;
|
|
while (p < len && d[p] != ' ' && d[p] != '\t' && d[p] != '\n' &&
|
|
d[p] != '\r' && d[p] != '/' && d[p] != '<' && d[p] != '>' &&
|
|
d[p] != '[' && d[p] != ']' && d[p] != '(' && d[p] != ')') {
|
|
if (tok->str_len < MAX_TEXT_LEN - 1)
|
|
tok->str[tok->str_len++] = (char)d[p];
|
|
p++;
|
|
}
|
|
tok->str[tok->str_len] = '\0';
|
|
return p;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Text State and Item Output
|
|
// ============================================================================
|
|
|
|
struct TextState {
|
|
float tm[6]; // text matrix [a b c d e f]
|
|
float lm[6]; // text line matrix
|
|
float tl; // text leading (TL)
|
|
float font_size;
|
|
char font_name[32];
|
|
uint8_t font_flags;
|
|
uint16_t* tounicode; // current font's glyph->Unicode table (may be nullptr)
|
|
TrueTypeFont* embedded_font; // embedded font from PDF, or nullptr
|
|
};
|
|
|
|
// Apply ToUnicode mapping to raw glyph bytes, producing a UTF-8-ish output.
|
|
// For BMP codepoints (which is all we handle), just output as Latin-1 where possible.
|
|
static int apply_tounicode(const char* raw, int raw_len, char* out, int out_max,
|
|
const uint16_t* tounicode) {
|
|
int oi = 0;
|
|
for (int i = 0; i < raw_len && oi < out_max - 1; i++) {
|
|
uint8_t glyph = (uint8_t)raw[i];
|
|
uint16_t cp = tounicode ? tounicode[glyph] : (uint16_t)glyph;
|
|
if (cp == 0) cp = glyph; // fallback to raw byte
|
|
if (cp < 128) {
|
|
out[oi++] = (char)cp;
|
|
} else if (cp < 0x800) {
|
|
// 2-byte UTF-8 - but our font renderer likely only handles Latin-1
|
|
// For now, output as Latin-1 if <= 255, otherwise skip
|
|
if (cp <= 255) {
|
|
out[oi++] = (char)cp;
|
|
} else {
|
|
out[oi++] = '?';
|
|
}
|
|
} else {
|
|
out[oi++] = '?';
|
|
}
|
|
}
|
|
out[oi] = '\0';
|
|
return oi;
|
|
}
|
|
|
|
static void add_text_item(PdfPage* page, float x, float y, float size,
|
|
const char* text, int text_len, uint8_t flags,
|
|
const uint16_t* tounicode, TrueTypeFont* embedded_font) {
|
|
if (text_len <= 0) return;
|
|
|
|
// Apply ToUnicode mapping if available (only when not using embedded font,
|
|
// since embedded subset fonts need the raw character codes for cmap lookup)
|
|
char mapped[MAX_TEXT_LEN];
|
|
if (tounicode && !embedded_font) {
|
|
text_len = apply_tounicode(text, text_len, mapped, MAX_TEXT_LEN, tounicode);
|
|
text = mapped;
|
|
}
|
|
if (text_len <= 0) return;
|
|
|
|
// Grow items array if needed
|
|
if (page->item_count >= page->item_cap) {
|
|
int new_cap = page->item_cap ? page->item_cap * 2 : 64;
|
|
TextItem* new_items = (TextItem*)montauk::malloc(new_cap * sizeof(TextItem));
|
|
if (!new_items) return;
|
|
if (page->items) {
|
|
montauk::memcpy(new_items, page->items, page->item_count * sizeof(TextItem));
|
|
montauk::mfree(page->items);
|
|
}
|
|
page->items = new_items;
|
|
page->item_cap = new_cap;
|
|
}
|
|
|
|
TextItem* item = &page->items[page->item_count++];
|
|
item->x = x;
|
|
item->y = y;
|
|
item->font_size = size;
|
|
item->flags = flags;
|
|
item->font = embedded_font;
|
|
|
|
int copy = text_len < MAX_TEXT_LEN - 1 ? text_len : MAX_TEXT_LEN - 1;
|
|
montauk::memcpy(item->text, text, copy);
|
|
item->text[copy] = '\0';
|
|
}
|
|
|
|
static void matrix_multiply(float* result, const float* a, const float* b) {
|
|
// Multiply two 3x3 matrices represented as [a b c d e f]
|
|
// where the matrix is: [a b 0]
|
|
// [c d 0]
|
|
// [e f 1]
|
|
result[0] = a[0] * b[0] + a[1] * b[2];
|
|
result[1] = a[0] * b[1] + a[1] * b[3];
|
|
result[2] = a[2] * b[0] + a[3] * b[2];
|
|
result[3] = a[2] * b[1] + a[3] * b[3];
|
|
result[4] = a[4] * b[0] + a[5] * b[2] + b[4];
|
|
result[5] = a[4] * b[1] + a[5] * b[3] + b[5];
|
|
}
|
|
|
|
// ============================================================================
|
|
// Operand Stack
|
|
// ============================================================================
|
|
|
|
struct Operand {
|
|
float num;
|
|
char str[MAX_TEXT_LEN];
|
|
int str_len;
|
|
bool is_name;
|
|
bool is_string;
|
|
};
|
|
|
|
// ============================================================================
|
|
// Content Stream Parser
|
|
// ============================================================================
|
|
|
|
static FontInfo* lookup_font(FontMap* fonts, const char* name) {
|
|
for (int i = 0; i < fonts->count; i++) {
|
|
if (str_len(fonts->fonts[i].name) == str_len(name)) {
|
|
bool match = true;
|
|
for (int j = 0; name[j]; j++) {
|
|
if (fonts->fonts[i].name[j] != name[j]) { match = false; break; }
|
|
}
|
|
if (match) return &fonts->fonts[i];
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void parse_page(int page_idx, int page_obj_num) {
|
|
PdfPage* page = &g_doc.pages[page_idx];
|
|
|
|
// Build font map for this page
|
|
FontMap* fonts = (FontMap*)montauk::malloc(sizeof(FontMap));
|
|
if (!fonts) return;
|
|
build_font_map(page_obj_num, fonts);
|
|
|
|
// Get content stream(s)
|
|
int start, end;
|
|
if (find_obj_content(page_obj_num, &start, &end) < 0) {
|
|
for (int fi = 0; fi < fonts->count; fi++)
|
|
if (fonts->fonts[fi].tounicode) montauk::mfree(fonts->fonts[fi].tounicode);
|
|
montauk::mfree(fonts);
|
|
return;
|
|
}
|
|
|
|
const uint8_t* d = g_doc.data;
|
|
int len = g_doc.data_len;
|
|
|
|
int contents_pos = dict_lookup(d, len, start, "Contents");
|
|
if (contents_pos < 0) {
|
|
for (int fi = 0; fi < fonts->count; fi++)
|
|
if (fonts->fonts[fi].tounicode) montauk::mfree(fonts->fonts[fi].tounicode);
|
|
montauk::mfree(fonts);
|
|
return;
|
|
}
|
|
|
|
// Collect content stream object numbers
|
|
int content_objs[32];
|
|
int content_count = 0;
|
|
|
|
int cp = skip_ws(d, len, contents_pos);
|
|
if (cp < len && d[cp] == '[') {
|
|
// Array of references
|
|
cp++;
|
|
while (cp < len && d[cp] != ']' && content_count < 32) {
|
|
cp = skip_ws(d, len, cp);
|
|
if (cp >= len || d[cp] == ']') break;
|
|
int ref_num;
|
|
int rp = parse_ref_at(d, len, cp, &ref_num);
|
|
if (rp > 0) {
|
|
content_objs[content_count++] = ref_num;
|
|
cp = rp;
|
|
} else {
|
|
cp++;
|
|
}
|
|
}
|
|
} else {
|
|
// Single reference
|
|
int ref_num;
|
|
if (parse_ref_at(d, len, cp, &ref_num) > 0) {
|
|
content_objs[content_count++] = ref_num;
|
|
}
|
|
}
|
|
|
|
// Concatenate and parse all content streams
|
|
for (int ci = 0; ci < content_count; ci++) {
|
|
int stream_len;
|
|
uint8_t* stream_data = get_stream_data(content_objs[ci], &stream_len);
|
|
if (!stream_data) continue;
|
|
|
|
// Parse the content stream
|
|
Operand* ops = (Operand*)montauk::malloc(MAX_OPERANDS * sizeof(Operand));
|
|
if (!ops) { montauk::mfree(stream_data); continue; }
|
|
int op_count = 0;
|
|
|
|
TextState ts;
|
|
ts.tm[0] = 1; ts.tm[1] = 0; ts.tm[2] = 0; ts.tm[3] = 1; ts.tm[4] = 0; ts.tm[5] = 0;
|
|
ts.lm[0] = 1; ts.lm[1] = 0; ts.lm[2] = 0; ts.lm[3] = 1; ts.lm[4] = 0; ts.lm[5] = 0;
|
|
ts.tl = 0;
|
|
ts.font_size = 12;
|
|
ts.font_name[0] = '\0';
|
|
ts.font_flags = 0;
|
|
ts.tounicode = nullptr;
|
|
ts.embedded_font = nullptr;
|
|
|
|
bool in_text = false;
|
|
Token tok;
|
|
int pos = 0;
|
|
|
|
while (pos < stream_len) {
|
|
pos = next_token(stream_data, stream_len, pos, &tok);
|
|
if (tok.type == TOK_EOF) break;
|
|
|
|
// Accumulate operands
|
|
if (tok.type == TOK_REAL || tok.type == TOK_INT) {
|
|
if (op_count < MAX_OPERANDS) {
|
|
ops[op_count].num = tok.num;
|
|
ops[op_count].is_name = false;
|
|
ops[op_count].is_string = false;
|
|
ops[op_count].str_len = 0;
|
|
op_count++;
|
|
}
|
|
continue;
|
|
}
|
|
if (tok.type == TOK_NAME) {
|
|
if (op_count < MAX_OPERANDS) {
|
|
ops[op_count].is_name = true;
|
|
ops[op_count].is_string = false;
|
|
str_cpy(ops[op_count].str, tok.str, MAX_TEXT_LEN);
|
|
ops[op_count].str_len = tok.str_len;
|
|
op_count++;
|
|
}
|
|
continue;
|
|
}
|
|
if (tok.type == TOK_STRING || tok.type == TOK_HEX_STRING) {
|
|
if (op_count < MAX_OPERANDS) {
|
|
ops[op_count].is_name = false;
|
|
ops[op_count].is_string = true;
|
|
montauk::memcpy(ops[op_count].str, tok.str, tok.str_len);
|
|
ops[op_count].str[tok.str_len] = '\0';
|
|
ops[op_count].str_len = tok.str_len;
|
|
ops[op_count].num = 0;
|
|
op_count++;
|
|
}
|
|
continue;
|
|
}
|
|
if (tok.type == TOK_ARRAY_START) {
|
|
// Special handling for TJ arrays
|
|
// Collect items until ']'
|
|
// Build concatenated string from string elements
|
|
char tj_buf[MAX_TEXT_LEN];
|
|
int tj_len = 0;
|
|
|
|
while (pos < stream_len) {
|
|
Token atk;
|
|
int next_pos = next_token(stream_data, stream_len, pos, &atk);
|
|
if (atk.type == TOK_EOF) break;
|
|
if (atk.type == TOK_ARRAY_END) { pos = next_pos; break; }
|
|
|
|
if ((atk.type == TOK_STRING || atk.type == TOK_HEX_STRING) &&
|
|
tj_len + atk.str_len < MAX_TEXT_LEN - 1) {
|
|
montauk::memcpy(tj_buf + tj_len, atk.str, atk.str_len);
|
|
tj_len += atk.str_len;
|
|
}
|
|
// Number entries in TJ arrays are kerning values - skip them
|
|
pos = next_pos;
|
|
}
|
|
tj_buf[tj_len] = '\0';
|
|
|
|
if (tj_len > 0 && op_count < MAX_OPERANDS) {
|
|
ops[op_count].is_name = false;
|
|
ops[op_count].is_string = true;
|
|
montauk::memcpy(ops[op_count].str, tj_buf, tj_len + 1);
|
|
ops[op_count].str_len = tj_len;
|
|
ops[op_count].num = 0;
|
|
op_count++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Process operator
|
|
if (tok.type != TOK_OPERATOR) { op_count = 0; continue; }
|
|
|
|
const char* op = tok.str;
|
|
|
|
// BT - begin text
|
|
if (op[0] == 'B' && op[1] == 'T' && op[2] == '\0') {
|
|
in_text = true;
|
|
ts.tm[0] = 1; ts.tm[1] = 0; ts.tm[2] = 0; ts.tm[3] = 1;
|
|
ts.tm[4] = 0; ts.tm[5] = 0;
|
|
ts.lm[0] = 1; ts.lm[1] = 0; ts.lm[2] = 0; ts.lm[3] = 1;
|
|
ts.lm[4] = 0; ts.lm[5] = 0;
|
|
}
|
|
// ET - end text
|
|
else if (op[0] == 'E' && op[1] == 'T' && op[2] == '\0') {
|
|
in_text = false;
|
|
}
|
|
// Tf - set font
|
|
else if (op[0] == 'T' && op[1] == 'f' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 2 && ops[0].is_name) {
|
|
str_cpy(ts.font_name, ops[0].str, 32);
|
|
ts.font_size = ops[1].num;
|
|
FontInfo* fi = lookup_font(fonts, ts.font_name);
|
|
ts.font_flags = fi ? fi->flags : 0;
|
|
ts.tounicode = fi ? fi->tounicode : nullptr;
|
|
ts.embedded_font = fi ? fi->embedded_font : nullptr;
|
|
}
|
|
}
|
|
// TL - set text leading
|
|
else if (op[0] == 'T' && op[1] == 'L' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 1) ts.tl = ops[0].num;
|
|
}
|
|
// Td - move text position
|
|
else if (op[0] == 'T' && op[1] == 'd' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 2) {
|
|
float tx = ops[0].num;
|
|
float ty = ops[1].num;
|
|
float translate[6] = {1, 0, 0, 1, tx, ty};
|
|
float result[6];
|
|
matrix_multiply(result, translate, ts.lm);
|
|
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
|
|
}
|
|
}
|
|
// TD - move text position and set leading
|
|
else if (op[0] == 'T' && op[1] == 'D' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 2) {
|
|
ts.tl = -ops[1].num;
|
|
float tx = ops[0].num;
|
|
float ty = ops[1].num;
|
|
float translate[6] = {1, 0, 0, 1, tx, ty};
|
|
float result[6];
|
|
matrix_multiply(result, translate, ts.lm);
|
|
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
|
|
}
|
|
}
|
|
// Tm - set text matrix
|
|
else if (op[0] == 'T' && op[1] == 'm' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 6) {
|
|
for (int i = 0; i < 6; i++) {
|
|
ts.tm[i] = ops[i].num;
|
|
ts.lm[i] = ops[i].num;
|
|
}
|
|
}
|
|
}
|
|
// T* - move to start of next line
|
|
else if (op[0] == 'T' && op[1] == '*' && op[2] == '\0' && in_text) {
|
|
float translate[6] = {1, 0, 0, 1, 0, -ts.tl};
|
|
float result[6];
|
|
matrix_multiply(result, translate, ts.lm);
|
|
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
|
|
}
|
|
// Tj - show string
|
|
else if (op[0] == 'T' && op[1] == 'j' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 1 && ops[0].is_string && ops[0].str_len > 0) {
|
|
float eff_size = ts.font_size;
|
|
// Scale by text matrix
|
|
float sy = ts.tm[3];
|
|
if (sy < 0) sy = -sy;
|
|
if (sy > 0.01f) eff_size *= sy;
|
|
|
|
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
|
|
ops[0].str, ops[0].str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
|
|
|
|
// Advance text position using font metrics when available
|
|
TrueTypeFont* adv_font = ts.embedded_font;
|
|
if (!adv_font) {
|
|
adv_font = g_font;
|
|
if ((ts.font_flags & 1) && g_font_bold) adv_font = g_font_bold;
|
|
if ((ts.font_flags & 4) && g_font_mono) adv_font = g_font_mono;
|
|
}
|
|
float advance;
|
|
if (adv_font) {
|
|
int msz = (int)(ts.font_size + 0.5f);
|
|
if (msz < 4) msz = 4;
|
|
if (msz > 120) msz = 120;
|
|
advance = (float)adv_font->measure_text(ops[0].str, msz);
|
|
} else {
|
|
advance = ops[0].str_len * ts.font_size * 0.5f;
|
|
}
|
|
ts.tm[4] += advance * ts.tm[0];
|
|
ts.tm[5] += advance * ts.tm[1];
|
|
}
|
|
}
|
|
// TJ - show string (array already concatenated)
|
|
else if (op[0] == 'T' && op[1] == 'J' && op[2] == '\0' && in_text) {
|
|
if (op_count >= 1 && ops[op_count - 1].is_string && ops[op_count - 1].str_len > 0) {
|
|
Operand* sop = &ops[op_count - 1];
|
|
float eff_size = ts.font_size;
|
|
float sy = ts.tm[3];
|
|
if (sy < 0) sy = -sy;
|
|
if (sy > 0.01f) eff_size *= sy;
|
|
|
|
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
|
|
sop->str, sop->str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
|
|
|
|
TrueTypeFont* adv_font = ts.embedded_font;
|
|
if (!adv_font) {
|
|
adv_font = g_font;
|
|
if ((ts.font_flags & 1) && g_font_bold) adv_font = g_font_bold;
|
|
if ((ts.font_flags & 4) && g_font_mono) adv_font = g_font_mono;
|
|
}
|
|
float advance;
|
|
if (adv_font) {
|
|
int msz = (int)(ts.font_size + 0.5f);
|
|
if (msz < 4) msz = 4;
|
|
if (msz > 120) msz = 120;
|
|
advance = (float)adv_font->measure_text(sop->str, msz);
|
|
} else {
|
|
advance = sop->str_len * ts.font_size * 0.5f;
|
|
}
|
|
ts.tm[4] += advance * ts.tm[0];
|
|
ts.tm[5] += advance * ts.tm[1];
|
|
}
|
|
}
|
|
// ' (single quote) - move to next line and show string
|
|
else if (op[0] == '\'' && op[1] == '\0' && in_text) {
|
|
// T*
|
|
float translate[6] = {1, 0, 0, 1, 0, -ts.tl};
|
|
float result[6];
|
|
matrix_multiply(result, translate, ts.lm);
|
|
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
|
|
|
|
// Tj
|
|
if (op_count >= 1 && ops[0].is_string && ops[0].str_len > 0) {
|
|
float eff_size = ts.font_size;
|
|
float sy = ts.tm[3];
|
|
if (sy < 0) sy = -sy;
|
|
if (sy > 0.01f) eff_size *= sy;
|
|
|
|
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
|
|
ops[0].str, ops[0].str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
|
|
}
|
|
}
|
|
// " (double quote) - set aw, ac, move to next line, show string
|
|
else if (op[0] == '"' && op[1] == '\0' && in_text) {
|
|
// T*
|
|
float translate[6] = {1, 0, 0, 1, 0, -ts.tl};
|
|
float result[6];
|
|
matrix_multiply(result, translate, ts.lm);
|
|
for (int i = 0; i < 6; i++) { ts.tm[i] = result[i]; ts.lm[i] = result[i]; }
|
|
|
|
// Show string (third operand)
|
|
if (op_count >= 3 && ops[2].is_string && ops[2].str_len > 0) {
|
|
float eff_size = ts.font_size;
|
|
float sy = ts.tm[3];
|
|
if (sy < 0) sy = -sy;
|
|
if (sy > 0.01f) eff_size *= sy;
|
|
|
|
add_text_item(page, ts.tm[4], ts.tm[5], eff_size,
|
|
ops[2].str, ops[2].str_len, ts.font_flags, ts.tounicode, ts.embedded_font);
|
|
}
|
|
}
|
|
|
|
op_count = 0; // reset operand stack after operator
|
|
}
|
|
|
|
montauk::mfree(ops);
|
|
montauk::mfree(stream_data);
|
|
}
|
|
|
|
for (int fi = 0; fi < fonts->count; fi++)
|
|
if (fonts->fonts[fi].tounicode) montauk::mfree(fonts->fonts[fi].tounicode);
|
|
montauk::mfree(fonts);
|
|
}
|