//
// Simple markdown to PDF converter example for PDFio.
//
// Copyright © 2024 by Michael R Sweet.
//
// Licensed under Apache License v2.0. See the file "LICENSE" for more
// information.
//
// Usage:
//
// ./md2pdf FILENAME.md FILENAME.pdf
// ./md2pdf FILENAME.md >FILENAME.pdf
//
// The generated PDF file is formatted for a "universal" paper size (8.27x11",
// the intersection of US Letter and ISO A4) with 1" top and bottom margins and
// 0.5" side margins. The document title (if present) is centered at the top
// of the second and subsequent pages while the current heading and page number
// are provided at the bottom of each page.
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#ifdef _WIN32
# include <io.h>
#else
# include <unistd.h>
#endif // _WIN32
#include "mmd.h"
#include <pdfio.h>
#include <pdfio-content.h>
//
// Types...
//
typedef enum doccolor_e // Document color enumeration
{
DOCCOLOR_BLACK, // #000
DOCCOLOR_RED, // #900
DOCCOLOR_ORANGE, // #CC0
DOCCOLOR_BLUE, // #00C
DOCCOLOR_LTGRAY, // #EEE
DOCCOLOR_GRAY // #555
} doccolor_t;
typedef enum docfont_e // Document font enumeration
{
DOCFONT_REGULAR, // Roboto-Regular
DOCFONT_BOLD, // Roboto-Bold
DOCFONT_ITALIC, // Roboto-Italic
DOCFONT_MONOSPACE, // RobotoMono-Regular
DOCFONT_MAX // Number of fonts
} docfont_t;
typedef struct docimage_s // Document image info
{
const char *url; // Reference URL
pdfio_obj_t *obj; // Image object
} docimage_t;
#define DOCIMAGE_MAX 1000 // Maximum number of images
typedef struct doclink_s // Document link info
{
const char *url; // Target URL
pdfio_rect_t box; // Link box
} doclink_t;
#define DOCLINK_MAX 1000 // Maximum number of links per page
typedef struct docaction_s // Document action info
{
const char *target; // Target name
pdfio_obj_t *obj; // Link object
} docaction_t;
#define DOCACTION_MAX 10000 // Maximum number of actions per document
typedef struct doctarget_s // Document target info
{
char name[128]; // Target name
size_t page; // Target page
double y; // Target page position
} doctarget_t;
#define DOCTARGET_MAX 1000 // Maximum number of targets per document
typedef struct doctoc_s // Document table-of-contents entry
{
int level; // Level
int count; // Total number of child entries
pdfio_obj_t *obj; // Dictionary object
pdfio_dict_t *dict; // Dictionary value
} doctoc_t;
#define DOCTOC_MAX 1000 // Maximum number of TOC entries
typedef struct docdata_s // Document formatting data
{
// State for the whole document
pdfio_file_t *pdf; // PDF file
pdfio_rect_t media_box; // Media (page) box
pdfio_rect_t crop_box; // Crop box (for margins)
pdfio_rect_t art_box; // Art box (for markdown content)
pdfio_obj_t *fonts[DOCFONT_MAX]; // Embedded fonts
double font_space; // Unit width of a space
size_t num_images; // Number of embedded images
docimage_t images[DOCIMAGE_MAX]; // Embedded images
const char *title; // Document title
char *heading; // Current document heading
size_t num_actions; // Number of actions for this document
docaction_t actions[DOCACTION_MAX]; // Actions for this document
size_t num_targets; // Number of targets for this document
doctarget_t targets[DOCTARGET_MAX]; // Targets for this document
size_t num_toc; // Number of table-of-contents entries
doctoc_t toc[DOCTOC_MAX]; // Table-of-contents entries
// State for the current page
pdfio_stream_t *st; // Current page stream
double y; // Current position on page
docfont_t font; // Current font
double fsize; // Current font size
doccolor_t color; // Current color
pdfio_array_t *annots_array; // Annotations array (for links)
pdfio_obj_t *annots_obj; // Annotations object (for links)
size_t num_links; // Number of links for this page
doclink_t links[DOCLINK_MAX]; // Links for this page
} docdata_t;
typedef struct linefrag_s // Line fragment
{
mmd_type_t type; // Type of fragment
double x, // X position of item
width, // Width of item
height; // Height of item
size_t imagenum; // Image number
const char *text; // Text string
const char *url; // Link URL string
bool ws; // Whitespace before text?
docfont_t font; // Text font
doccolor_t color; // Text color
} linefrag_t;
#define LINEFRAG_MAX 200 // Maximum number of fragments on a line
typedef struct tablecol_s // Table column data
{
double min_width, // Minimum required width of column
max_width, // Maximum required width of column
width, // Width of column
left, // Left edge
right; // Right edge
} tablecol_t;
#define TABLECOL_MAX 20 // Maximum number of table columns
typedef struct tablerow_s // Table row
{
mmd_t *cells[TABLECOL_MAX]; // Cells in row
double height; // Row height
} tablerow_t;
#define TABLEROW_MAX 1000 // Maximum number of table rows
//
// Macros...
//
#define in2pt(in) (in * 72.0)
#define mm2pt(mm) (mm * 72.0 / 25.4)
//
// Constants...
//
#define USE_TRUETYPE 0 // Set to 1 to use Roboto TrueType fonts
#if USE_TRUETYPE
# define UNICODE_VALUE true // `true` for Unicode text, `false` for ISO-8859-1
static const char * const docfont_filenames[] =
{
"Roboto-Regular.ttf",
"Roboto-Bold.ttf",
"Roboto-Italic.ttf",
"RobotoMono-Regular.ttf"
};
#else
# define UNICODE_VALUE false // `true` for Unicode text, `false` for ISO-8859-1
static const char * const docfont_filenames[] =
{
"Helvetica",
"Helvetica-Bold",
"Helvetica-Oblique",
"Courier"
};
#endif // USE_TRUETYPE
static const char * const docfont_names[] =
{
"FR",
"FB",
"FI",
"FM"
};
#define BQ_PADDING 18.0 // Padding for block quotes
#define BQ_THICKNESS 3.0 // Thickness of block quote bar
#define CODE_PADDING 4.5 // Padding for code blocks
#define IMAGE_PPI 100.0 // Pixels per inch for images
#define LINE_HEIGHT 1.4 // Multiplier for line height
#define LIST_PADDING 36.0 // Padding/indentation for lists
#define SIZE_BODY 11.0 // Size of body text (points)
#define SIZE_CODEBLOCK 10.0 // Size of code block text (points)
#define SIZE_HEADFOOT 9.0 // Size of header/footer text (points)
#define SIZE_HEADING_1 18.0 // Size of first level heading (points)
#define SIZE_HEADING_2 16.0 // Size of top level heading (points)
#define SIZE_HEADING_3 15.0 // Size of top level heading (points)
#define SIZE_HEADING_4 14.0 // Size of top level heading (points)
#define SIZE_HEADING_5 13.0 // Size of top level heading (points)
#define SIZE_HEADING_6 12.0 // Size of top level heading (points)
#define SIZE_TABLE 10.0 // Size of table text (points)
#define PAGE_WIDTH mm2pt(210) // Page width in points
#define PAGE_LENGTH in2pt(11) // Page length in points
#define PAGE_LEFT in2pt(0.5) // Left margin in points
#define PAGE_RIGHT (PAGE_WIDTH - in2pt(0.5))
// Right margin in points
#define PAGE_BOTTOM in2pt(1.0) // Bottom margin in points
#define PAGE_TOP (PAGE_LENGTH - in2pt(1.0))
// Top margin in points
#define PAGE_HEADER (PAGE_LENGTH - in2pt(0.5))
// Vertical position of header
#define PAGE_FOOTER in2pt(0.5) // Vertical position of footer
#define TABLE_PADDING 4.5 // Table padding value
//
// Functions...
//
static void add_images(docdata_t *dd, mmd_t *doc);
static void add_links(docdata_t *dd);
static pdfio_obj_t *find_image(docdata_t *dd, const char *url, size_t *imagenum);
static void format_block(docdata_t *dd, mmd_t *block, docfont_t deffont, double fsize, double left, double right, const char *leader);
static void format_code(docdata_t *dd, mmd_t *block, double left, double right);
static void format_doc(docdata_t *dd, mmd_t *doc, docfont_t deffont, double left, double right);
static void format_table(docdata_t *dd, mmd_t *table, double left, double right);
static void make_target_name(char *dst, const char *src, size_t dstsize);
static double measure_cell(docdata_t *dd, mmd_t *cell, tablecol_t *col);
static mmd_t *mmd_walk_next(mmd_t *top, mmd_t *node);
static void new_page(docdata_t *dd);
static ssize_t output_cb(void *output_cbdata, const void *buffer, size_t bytes);
static void render_line(docdata_t *dd, double margin_left, double need_bottom, double lineheight, size_t num_frags, linefrag_t *frags);
static void render_row(docdata_t *dd, size_t num_cols, tablecol_t *cols, tablerow_t *row);
static void set_color(docdata_t *dd, doccolor_t color);
static void set_font(docdata_t *dd, docfont_t font, double fsize);
static void write_actions(docdata_t *dd);
static void write_toc(docdata_t *dd);
//
// 'main()' - Convert markdown to PDF.
//
int // O - Exit status
main(int argc, // I - Number of command-line arguments
char *argv[]) // I - Command-line arguments
{
docdata_t dd; // Document data
docfont_t fontface; // Current font
mmd_t *doc; // Markdown document
const char *value; // Metadata value
setbuf(stderr, NULL);
// Get the markdown file from the command-line...
if (argc < 2 || argc > 3)
{
fputs("Usage: md2pdf FILENANE.md [FILENAME.pdf]\n", stderr);
fputs(" md2pdf FILENANE.md >FILENAME.pdf\n", stderr);
return (1);
}
if ((doc = mmdLoad(/*root*/NULL, argv[1])) == NULL)
return (1);
// Initialize the document data
memset(&dd, 0, sizeof(dd));
dd.media_box.x2 = PAGE_WIDTH;
dd.media_box.y2 = PAGE_LENGTH;
dd.crop_box.x1 = PAGE_LEFT;
dd.crop_box.y1 = PAGE_FOOTER;
dd.crop_box.x2 = PAGE_RIGHT;
dd.crop_box.y2 = PAGE_HEADER;
dd.art_box.x1 = PAGE_LEFT;
dd.art_box.y1 = PAGE_BOTTOM;
dd.art_box.x2 = PAGE_RIGHT;
dd.art_box.y2 = PAGE_TOP;
if ((dd.title = mmdGetMetadata(doc, "title")) == NULL)
dd.art_box.y2 = PAGE_HEADER; // No header if there is no title
if (argc == 2)
{
// Output a PDF file to the standard output...
#ifdef _WIN32
setmode(1, O_BINARY); // Force binary output on Windows
#endif // _WIN32
if ((dd.pdf = pdfioFileCreateOutput(output_cb, /*output_cbdata*/NULL, /*version*/NULL, /*media_box*/NULL, /*crop_box*/NULL, /*error_cb*/NULL, /*error_data*/NULL)) == NULL)
return (1);
}
else if ((dd.pdf = pdfioFileCreate(argv[2], /*version*/NULL, /*media_box*/NULL, /*crop_box*/NULL, /*error_cb*/NULL, /*error_data*/NULL)) == NULL)
{
return (1);
}
if ((value = mmdGetMetadata(doc, "author")) != NULL)
pdfioFileSetAuthor(dd.pdf, value);
if ((value = mmdGetMetadata(doc, "keywords")) != NULL)
pdfioFileSetKeywords(dd.pdf, value);
if ((value = mmdGetMetadata(doc, "subject")) != NULL)
pdfioFileSetSubject(dd.pdf, value);
else if ((value = mmdGetMetadata(doc, "copyright")) != NULL)
pdfioFileSetSubject(dd.pdf, value);
if (dd.title)
pdfioFileSetTitle(dd.pdf, dd.title);
// Add fonts...
for (fontface = DOCFONT_REGULAR; fontface < DOCFONT_MAX; fontface ++)
{
#if USE_TRUETYPE
if ((dd.fonts[fontface] = pdfioFileCreateFontObjFromFile(dd.pdf, docfont_filenames[fontface], UNICODE_VALUE)) == NULL)
return (1);
#else
if ((dd.fonts[fontface] = pdfioFileCreateFontObjFromBase(dd.pdf, docfont_filenames[fontface])) == NULL)
return (1);
#endif // USE_TRUETYPE
}
dd.font_space = pdfioContentTextMeasure(dd.fonts[DOCFONT_REGULAR], " ", 1.0);
// Add images...
add_images(&dd, doc);
// Parse the markdown document...
format_doc(&dd, doc, DOCFONT_REGULAR, dd.art_box.x1, dd.art_box.x2);
// Close the PDF and return...
if (dd.st)
{
pdfioStreamClose(dd.st);
add_links(&dd);
}
write_actions(&dd);
if (dd.num_toc > 0)
write_toc(&dd);
pdfioFileClose(dd.pdf);
mmdFree(doc);
return (0);
}
//
// 'add_images()' - Scan the markdown document for images.
//
static void
add_images(docdata_t *dd, // I - Document data
mmd_t *doc) // I - Markdown document
{
mmd_t *current, // Current node
*next; // Next node
// Scan the entire document for images...
for (current = mmdGetFirstChild(doc); current; current = next)
{
// Get next node
next = mmd_walk_next(doc, current);
// Look for image nodes...
if (mmdGetType(current) == MMD_TYPE_IMAGE)
{
const char *url, // URL for image
*ext; // Extension
url = mmdGetURL(current);
ext = strrchr(url, '.');
if (!access(url, 0) && ext && (!strcmp(ext, ".png") || !strcmp(ext, ".jpg") || !strcmp(ext, ".jpeg")))
{
// Local JPEG or PNG file, so add it if we haven't already...
size_t i; // Looping var
for (i = 0; i < dd->num_images; i ++)
{
if (!strcmp(dd->images[i].url, url))
break;
}
if (i >= dd->num_images && dd->num_images < DOCIMAGE_MAX)
{
dd->images[i].url = url;
if ((dd->images[i].obj = pdfioFileCreateImageObjFromFile(dd->pdf, url, false)) != NULL)
dd->num_images ++;
}
}
}
}
}
//
// 'add_links()' - Add the page links, if any.
//
static void
add_links(docdata_t *dd) // I - Document data
{
size_t i; // Looping var
doclink_t *l; // Current link
pdfio_dict_t *dict; // Object dictionary
pdfio_obj_t *aobj, // Annotation object
*lobj; // Link object
pdfio_array_t *border; // Border values
// Add any links we have...
for (i = 0, l = dd->links; i < dd->num_links; i ++, l ++)
{
if (l->url[0] == '#')
{
// No remote action...
aobj = NULL;
}
else
{
// Create the link action (remote URL)
dict = pdfioDictCreate(dd->pdf);
pdfioDictSetName(dict, "S", "URI");
pdfioDictSetString(dict, "URI", pdfioStringCreate(dd->pdf, l->url));
aobj = pdfioFileCreateObj(dd->pdf, dict);
pdfioObjClose(aobj);
}
// Create the annotation object pointing to the action...
dict = pdfioDictCreate(dd->pdf);
pdfioDictSetName(dict, "Subtype", "Link");
pdfioDictSetRect(dict, "Rect", &l->box);
border = pdfioArrayCreate(dd->pdf);
pdfioArrayAppendNumber(border, 0.0);
pdfioArrayAppendNumber(border, 0.0);
pdfioArrayAppendNumber(border, 0.0);
pdfioDictSetArray(dict, "Border", border);
lobj = pdfioFileCreateObj(dd->pdf, dict);
if (l->url[0] == '#' && dd->num_actions < DOCACTION_MAX)
{
// Save this link action for later...
docaction_t *a = dd->actions + dd->num_actions;
// New action
a->target = l->url + 1;
a->obj = lobj;
dd->num_actions ++;
}
else if (aobj)
{
// Close out this link since we have a remote URL...
pdfioDictSetObj(dict, "A", aobj);
pdfioObjClose(lobj);
}
else
{
// Nothing that can be done for this one...
pdfioObjClose(lobj);
}
pdfioArrayAppendObj(dd->annots_array, lobj);
}
// Close the Annots array object...
pdfioObjClose(dd->annots_obj);
// Reset links...
dd->annots_array = NULL;
dd->annots_obj = NULL;
dd->num_links = 0;
}
//
// 'find_image()' - Find an image in the document.
//
static pdfio_obj_t * // O - Image object or `NULL` if none
find_image(docdata_t *dd, // I - Document data
const char *url, // I - Image URL
size_t *imagenum) // O - Image number
{
size_t i; // Looping var
// Look for a matching URL...
for (i = 0; i < dd->num_images; i ++)
{
if (!strcmp(dd->images[i].url, url))
{
if (imagenum)
*imagenum = i;
return (dd->images[i].obj);
}
}
// Not found, return NULL...
if (imagenum)
*imagenum = 0;
return (NULL);
}
//
// 'format_block()' - Format a block of text
//
static void
format_block(docdata_t *dd, // I - Document data
mmd_t *block, // I - Block to format
docfont_t deffont, // I - Default font
double fsize, // I - Size of font
double left, // I - Left margin
double right, // I - Right margin
const char *leader) // I - Leader text on the first line
{
mmd_type_t blocktype; // Block type
mmd_t *current, // Current node
*next; // Next node
size_t num_frags; // Number of line fragments
linefrag_t frags[LINEFRAG_MAX], // Line fragments
*frag; // Current fragment
mmd_type_t type; // Current node type
const char *text, // Current text
*url; // Current URL, if any
bool ws; // Current whitespace
pdfio_obj_t *image; // Current image, if any
size_t imagenum; // Current image number
doccolor_t color = DOCCOLOR_BLACK; // Current text color
docfont_t font = deffont; // Current text font
double x, // Current position
width, // Width of current fragment
wswidth, // Width of whitespace
margin_left, // Left margin
need_bottom, // Space needed after this block
height, // Height of current fragment
lineheight; // Height of current line
blocktype = mmdGetType(block);
if (mmdGetNextSibling(block))
need_bottom = 3.0 * SIZE_BODY * LINE_HEIGHT;
else
need_bottom = 0.0;
if (leader)
{
// Add leader text on first line...
frags[0].type = MMD_TYPE_NORMAL_TEXT;
frags[0].width = pdfioContentTextMeasure(dd->fonts[deffont], leader, fsize);
frags[0].height = fsize;
frags[0].x = left - frags[0].width;
frags[0].imagenum = 0;
frags[0].text = leader;
frags[0].url = NULL;
frags[0].ws = false;
frags[0].font = deffont;
frags[0].color = DOCCOLOR_BLACK;
num_frags = 1;
lineheight = fsize * LINE_HEIGHT;
}
else
{
// No leader text...
num_frags = 0;
lineheight = 0.0;
}
frag = frags + num_frags;
// Loop through the block and render lines...
for (current = mmdGetFirstChild(block), x = left; current; current = next)
{
// Get information about the current node...
type = mmdGetType(current);
text = mmdGetText(current);
image = NULL;
imagenum = 0;
url = mmdGetURL(current);
ws = mmdGetWhitespace(current);
wswidth = ws ? dd->font_space * fsize : 0.0;
next = mmd_walk_next(block, current);
// Process the node...
if (type == MMD_TYPE_IMAGE && url)
{
// Embed an image
if ((image = find_image(dd, url, &imagenum)) == NULL)
continue;
// Image - treat as 100dpi
width = 72.0 * pdfioImageGetWidth(image) / IMAGE_PPI;
height = 72.0 * pdfioImageGetHeight(image) / IMAGE_PPI;
text = NULL;
if (width > (right - left))
{
// Too wide, scale to width...
width = right - left;
height = width * pdfioImageGetHeight(image) / pdfioImageGetWidth(image);
}
else if (height > (dd->art_box.y2 - dd->art_box.y1))
{
// Too tall, scale to height...
height = dd->art_box.y2 - dd->art_box.y1;
width = height * pdfioImageGetWidth(image) / pdfioImageGetHeight(image);
}
}
else if (type == MMD_TYPE_HARD_BREAK && num_frags > 0)
{
if (blocktype == MMD_TYPE_TABLE_HEADER_CELL || blocktype == MMD_TYPE_TABLE_BODY_CELL_CENTER)
margin_left = 0.5 * (right - x);
else if (blocktype == MMD_TYPE_TABLE_BODY_CELL_RIGHT)
margin_left = right - x;
else
margin_left = 0.0;
render_line(dd, margin_left, need_bottom, lineheight, num_frags, frags);
if (deffont == DOCFONT_ITALIC)
{
// Add an orange bar to the left of block quotes...
set_color(dd, DOCCOLOR_ORANGE);
pdfioContentPathRect(dd->st, left - BQ_PADDING, dd->y - (LINE_HEIGHT - 1.0) * fsize - BQ_THICKNESS, BQ_THICKNESS, lineheight + 2.0 * BQ_THICKNESS);
pdfioContentFill(dd->st, /*even_odd*/false);
}
num_frags = 0;
frag = frags;
x = left;
lineheight = 0.0;
need_bottom = 0.0;
continue;
}
else if (type == MMD_TYPE_CHECKBOX)
{
// Checkbox
width = height = fsize;
}
else if (!text)
{
continue;
}
else
{
// Text fragment...
if (type == MMD_TYPE_EMPHASIZED_TEXT)
font = DOCFONT_ITALIC;
else if (type == MMD_TYPE_STRONG_TEXT)
font = DOCFONT_BOLD;
else if (type == MMD_TYPE_CODE_TEXT)
font = DOCFONT_MONOSPACE;
else
font = deffont;
if (type == MMD_TYPE_CODE_TEXT)
color = DOCCOLOR_RED;
else if (type == MMD_TYPE_LINKED_TEXT)
color = DOCCOLOR_BLUE;
else
color = DOCCOLOR_BLACK;
width = pdfioContentTextMeasure(dd->fonts[font], text, fsize);
height = fsize * LINE_HEIGHT;
}
// See if this node will fit on the current line...
if ((num_frags > 0 && (x + width + wswidth) >= right) || num_frags == LINEFRAG_MAX)
{
// No, render this line and start over...
if (blocktype == MMD_TYPE_TABLE_HEADER_CELL || blocktype == MMD_TYPE_TABLE_BODY_CELL_CENTER)
margin_left = 0.5 * (right - x);
else if (blocktype == MMD_TYPE_TABLE_BODY_CELL_RIGHT)
margin_left = right - x;
else
margin_left = 0.0;
render_line(dd, margin_left, need_bottom, lineheight, num_frags, frags);
num_frags = 0;
frag = frags;
x = left;
lineheight = 0.0;
need_bottom = 0.0;
if (deffont == DOCFONT_ITALIC)
{
// Add an orange bar to the left of block quotes...
set_color(dd, DOCCOLOR_ORANGE);
pdfioContentSave(dd->st);
pdfioContentSetLineWidth(dd->st, 3.0);
pdfioContentPathMoveTo(dd->st, left - 6.0, dd->y - (LINE_HEIGHT - 1.0) * fsize);
pdfioContentPathLineTo(dd->st, left - 6.0, dd->y + fsize);
pdfioContentStroke(dd->st);
pdfioContentRestore(dd->st);
}
}
// Add the current node to the fragment list
if (num_frags == 0)
{
// No leading whitespace at the start of the line
ws = false;
wswidth = 0.0;
}
frag->type = type;
frag->x = x;
frag->width = width + wswidth;
frag->height = text ? fsize : height;
frag->imagenum = imagenum;
frag->text = text;
frag->url = url;
frag->ws = ws;
frag->font = font;
frag->color = color;
num_frags ++;
frag ++;
x += width + wswidth;
if (height > lineheight)
lineheight = height;
}
if (num_frags > 0)
{
if (blocktype == MMD_TYPE_TABLE_HEADER_CELL || blocktype == MMD_TYPE_TABLE_BODY_CELL_CENTER)
margin_left = 0.5 * (right - x);
else if (blocktype == MMD_TYPE_TABLE_BODY_CELL_RIGHT)
margin_left = right - x;
else
margin_left = 0.0;
render_line(dd, margin_left, need_bottom, lineheight, num_frags, frags);
if (deffont == DOCFONT_ITALIC)
{
// Add an orange bar to the left of block quotes...
set_color(dd, DOCCOLOR_ORANGE);
pdfioContentSave(dd->st);
pdfioContentSetLineWidth(dd->st, 3.0);
pdfioContentPathMoveTo(dd->st, left - 6.0, dd->y - (LINE_HEIGHT - 1.0) * fsize);
pdfioContentPathLineTo(dd->st, left - 6.0, dd->y + fsize);
pdfioContentStroke(dd->st);
pdfioContentRestore(dd->st);
}
}
}
//
// 'format_code()' - Format a code block...
//
static void
format_code(docdata_t *dd, // I - Document data
mmd_t *block, // I - Code block
double left, // I - Left margin
double right) // I - Right margin
{
mmd_t *code; // Current code block
double lineheight; // Line height
// Compute line height...
lineheight = SIZE_CODEBLOCK * LINE_HEIGHT;
// Start a new page as needed...
if (!dd->st)
new_page(dd);
dd->y -= lineheight + CODE_PADDING;
if ((dd->y - lineheight) < dd->art_box.y1)
{
new_page(dd);
dd->y -= lineheight + CODE_PADDING;
}
// Draw the top padding...
set_color(dd, DOCCOLOR_LTGRAY);
pdfioContentPathRect(dd->st, left - CODE_PADDING, dd->y + SIZE_CODEBLOCK, right - left + 2.0 * CODE_PADDING, CODE_PADDING);
pdfioContentFillAndStroke(dd->st, false);
// Start a code text block...
set_font(dd, DOCFONT_MONOSPACE, SIZE_CODEBLOCK);
pdfioContentTextBegin(dd->st);
pdfioContentTextMoveTo(dd->st, left, dd->y);
for (code = mmdGetFirstChild(block); code; code = mmdGetNextSibling(code))
{
set_color(dd, DOCCOLOR_LTGRAY);
pdfioContentPathRect(dd->st, left - CODE_PADDING, dd->y - (LINE_HEIGHT - 1.0) * SIZE_CODEBLOCK, right - left + 2.0 * CODE_PADDING, lineheight);
pdfioContentFillAndStroke(dd->st, false);
set_color(dd, DOCCOLOR_RED);
pdfioContentTextShow(dd->st, UNICODE_VALUE, mmdGetText(code));
dd->y -= lineheight;
if (dd->y < dd->art_box.y1)
{
// End the current text block...
pdfioContentTextEnd(dd->st);
// Start a new page...
new_page(dd);
set_font(dd, DOCFONT_MONOSPACE, SIZE_CODEBLOCK);
dd->y -= lineheight;
pdfioContentTextBegin(dd->st);
pdfioContentTextMoveTo(dd->st, left, dd->y);
}
}
// End the current text block...
pdfioContentTextEnd(dd->st);
dd->y += lineheight;
// Draw the bottom padding...
set_color(dd, DOCCOLOR_LTGRAY);
pdfioContentPathRect(dd->st, left - CODE_PADDING, dd->y - CODE_PADDING - (LINE_HEIGHT - 1.0) * SIZE_CODEBLOCK, right - left + 2.0 * CODE_PADDING, CODE_PADDING);
pdfioContentFillAndStroke(dd->st, false);
}
//
// 'format_doc()' - Format a document.
//
static void
format_doc(docdata_t *dd, // I - Document data
mmd_t *doc, // I - Document node to format
docfont_t deffont, // I - Default font
double left, // I - Left margin
double right) // I - Right margin
{
int i; // Child number
mmd_type_t doctype; // Document node type
mmd_t *current; // Current node
mmd_type_t curtype; // Current node type
char leader[32]; // Leader
static const double heading_sizes[] = // Heading font sizes
{
SIZE_HEADING_1,
SIZE_HEADING_2,
SIZE_HEADING_3,
SIZE_HEADING_4,
SIZE_HEADING_5,
SIZE_HEADING_6
};
doctype = mmdGetType(doc);
for (i = 1, current = mmdGetFirstChild(doc); current; i ++, current = mmdGetNextSibling(current))
{
switch (curtype = mmdGetType(current))
{
default :
break;
case MMD_TYPE_THEMATIC_BREAK :
// Force a page break
dd->y = dd->art_box.y1;
break;
case MMD_TYPE_BLOCK_QUOTE :
format_doc(dd, current, DOCFONT_ITALIC, left + BQ_PADDING, right - BQ_PADDING);
break;
case MMD_TYPE_ORDERED_LIST :
case MMD_TYPE_UNORDERED_LIST :
dd->y -= SIZE_BODY * LINE_HEIGHT;
format_doc(dd, current, deffont, left + LIST_PADDING, right);
break;
case MMD_TYPE_LIST_ITEM :
if (doctype == MMD_TYPE_ORDERED_LIST)
{
snprintf(leader, sizeof(leader), "%d. ", i);
format_block(dd, current, deffont, SIZE_BODY, left, right, leader);
}
else
{
format_block(dd, current, deffont, SIZE_BODY, left, right, /*leader*/"• ");
}
break;
case MMD_TYPE_HEADING_1 :
case MMD_TYPE_HEADING_2 :
case MMD_TYPE_HEADING_3 :
case MMD_TYPE_HEADING_4 :
case MMD_TYPE_HEADING_5 :
case MMD_TYPE_HEADING_6 :
// Update the current heading
free(dd->heading);
dd->heading = mmdCopyAllText(current);
// Add a blank line before the heading...
dd->y -= heading_sizes[curtype - MMD_TYPE_HEADING_1] * LINE_HEIGHT;
// Format the heading...
format_block(dd, current, DOCFONT_BOLD, heading_sizes[curtype - MMD_TYPE_HEADING_1], left, right, /*leader*/NULL);
// Add the heading to the table-of-contents...
if (dd->num_toc < DOCTOC_MAX)
{
doctoc_t *t = dd->toc + dd->num_toc;
// New TOC
pdfio_array_t *dest; // Destination array
t->level = curtype - MMD_TYPE_HEADING_1;
t->dict = pdfioDictCreate(dd->pdf);
t->obj = pdfioFileCreateObj(dd->pdf, t->dict);
dest = pdfioArrayCreate(dd->pdf);
pdfioArrayAppendObj(dest, pdfioFileGetPage(dd->pdf, pdfioFileGetNumPages(dd->pdf) - 1));
pdfioArrayAppendName(dest, "XYZ");
pdfioArrayAppendNumber(dest, PAGE_LEFT);
pdfioArrayAppendNumber(dest, dd->y + heading_sizes[curtype - MMD_TYPE_HEADING_1] * LINE_HEIGHT);
pdfioArrayAppendNumber(dest, 0.0);
pdfioDictSetArray(t->dict, "Dest", dest);
pdfioDictSetString(t->dict, "Title", pdfioStringCreate(dd->pdf, dd->heading));
dd->num_toc ++;
}
// Add the heading to the list of link targets...
if (dd->num_targets < DOCTARGET_MAX)
{
doctarget_t *t = dd->targets + dd->num_targets;
// New target
make_target_name(t->name, dd->heading, sizeof(t->name));
t->page = pdfioFileGetNumPages(dd->pdf) - 1;
t->y = dd->y + heading_sizes[curtype - MMD_TYPE_HEADING_1] * LINE_HEIGHT;
dd->num_targets ++;
}
break;
case MMD_TYPE_PARAGRAPH :
// Add a blank line before the paragraph...
dd->y -= SIZE_BODY * LINE_HEIGHT;
// Format the paragraph...
format_block(dd, current, deffont, SIZE_BODY, left, right, /*leader*/NULL);
break;
case MMD_TYPE_TABLE :
// Add a blank line before the paragraph...
dd->y -= SIZE_BODY * LINE_HEIGHT;
// Format the table...
format_table(dd, current, left, right);
break;
case MMD_TYPE_CODE_BLOCK :
// Add a blank line before the code block...
dd->y -= SIZE_BODY * LINE_HEIGHT;
// Format the code block...
format_code(dd, current, left + CODE_PADDING, right - CODE_PADDING);
break;
}
}
}
//
// 'format_table()' - Format a table...
//
static void
format_table(docdata_t *dd, // I - Document data
mmd_t *table, // I - Table node
double left, // I - Left margin
double right) // I - Right margin
{
mmd_t *current, // Current node
*next; // Next node
mmd_type_t type; // Node type
size_t col, // Current column
num_cols; // Number of columns
tablecol_t cols[TABLECOL_MAX]; // Columns
size_t row, // Current row
num_rows; // Number of rows
tablerow_t rows[TABLEROW_MAX], // Rows
*rowptr; // Pointer to current row
double x, // Current X position
height, // Height of cell
format_width, // Maximum format width of table
table_width; // Total width of table
// Find all of the rows and columns in the table...
memset(cols, 0, sizeof(cols));
memset(rows, 0, sizeof(rows));
for (num_cols = 0, num_rows = 0, rowptr = rows, current = mmdGetFirstChild(table); current && num_rows < TABLEROW_MAX; current = next)
{
next = mmd_walk_next(table, current);
type = mmdGetType(current);
if (type == MMD_TYPE_TABLE_ROW)
{
// Parse row...
for (col = 0, current = mmdGetFirstChild(current); current && num_cols < TABLECOL_MAX; current = mmdGetNextSibling(current), col ++)
{
rowptr->cells[col] = current;
measure_cell(dd, current, cols + col);
if (col >= num_cols)
num_cols = col + 1;
}
rowptr ++;
num_rows ++;
}
}
// Figure out the width of each column...
for (col = 0, table_width = 0.0; col < num_cols; col ++)
{
cols[col].max_width += 2.0 * TABLE_PADDING;
table_width += cols[col].max_width;
cols[col].width = cols[col].max_width;
}
format_width = right - left - 2.0 * TABLE_PADDING * num_cols;
if (table_width > format_width)
{
// Content too wide, try scaling the widths...
double avg_width, // Average column width
base_width, // Base width
remaining_width, // Remaining width
scale_width; // Width for scaling
size_t num_remaining_cols = 0; // Number of remaining columns
// First mark any columns that are narrower than the average width...
avg_width = format_width / num_cols;
for (col = 0, base_width = 0.0, remaining_width = 0.0; col < num_cols; col ++)
{
if (cols[col].width > avg_width)
{
remaining_width += cols[col].width;
num_remaining_cols ++;
}
else
{
base_width += cols[col].width;
}
}
// Then proportionately distribute the remaining width to the other columns...
format_width -= base_width;
for (col = 0, table_width = 0.0; col < num_cols; col ++)
{
if (cols[col].width > avg_width)
cols[col].width = cols[col].width * format_width / remaining_width;
table_width += cols[col].width;
}
}
// Calculate the margins of each column in preparation for formatting
for (col = 0, x = left + TABLE_PADDING; col < num_cols; col ++)
{
cols[col].left = x;
cols[col].right = x + cols[col].width;
x += cols[col].width + 2.0 * TABLE_PADDING;
}
// Calculate the height of each row and cell in preparation for formatting
for (row = 0, rowptr = rows; row < num_rows; row ++, rowptr ++)
{
for (col = 0; col < num_cols; col ++)
{
height = measure_cell(dd, rowptr->cells[col], cols + col) + 2.0 * TABLE_PADDING;
if (height > rowptr->height)
rowptr->height = height;
}
}
// Render each table row...
for (row = 0, rowptr = rows; row < num_rows; row ++, rowptr ++)
render_row(dd, num_cols, cols, rowptr);
}
//
// 'make_target_name()' - Convert text to a target name.
//
static void
make_target_name(char *dst, // I - Destination buffer
const char *src, // I - Source text
size_t dstsize) // I - Size of destination buffer
{
char *dstptr = dst, // Pointer into destination
*dstend = dst + dstsize - 1; // End of destination
while (*src && dstptr < dstend)
{
if (isalnum(*src) || *src == '.' || *src == '-')
*dstptr++ = tolower(*src);
else if (*src == ' ')
*dstptr++ = '-';
src ++;
}
*dstptr = '\0';
}
//
// 'measure_cell()' - Measure the dimensions of a table cell.
//
static double // O - Formatted height
measure_cell(docdata_t *dd, // I - Document data
mmd_t *cell, // I - Cell node
tablecol_t *col) // O - Column data
{
mmd_t *current, // Current node
*next; // Next node
mmd_type_t type; // Node type
const char *text, // Current text
*url; // Current URL, if any
bool ws; // Current whitespace
docfont_t font; // Current font
double x = 0.0, // Current X position
width, // Width of node
wswidth, // Width of whitespace
height, // Height of node
lineheight = 0.0, // Height of line
cellheight = 0.0; // Height of cell
for (current = mmdGetFirstChild(cell); current; current = next)
{
next = mmd_walk_next(cell, current);
type = mmdGetType(current);
text = mmdGetText(current);
url = mmdGetURL(current);
ws = mmdGetWhitespace(current);
wswidth = 0.0;
if (type == MMD_TYPE_IMAGE && url)
{
// Embed an image
pdfio_obj_t *image = find_image(dd, url, /*imagenum*/NULL);
// Image object
if (!image)
continue;
// Image - treat as 100dpi
width = 72.0 * pdfioImageGetWidth(image) / IMAGE_PPI;
height = 72.0 * pdfioImageGetHeight(image) / IMAGE_PPI;
if (col->width > 0.0 && width > col->width)
{
// Too wide, scale to width...
width = col->width;
height = width * pdfioImageGetHeight(image) / pdfioImageGetWidth(image);
}
else if (height > (dd->art_box.y2 - dd->art_box.y1))
{
// Too tall, scale to height...
height = dd->art_box.y2 - dd->art_box.y1;
width = height * pdfioImageGetWidth(image) / pdfioImageGetHeight(image);
}
}
else if (type == MMD_TYPE_HARD_BREAK && x > 0.0)
{
// Hard break...
if (x > col->max_width)
col->max_width = x;
cellheight += lineheight;
x = 0.0;
lineheight = 0.0;
continue;
}
else if (type == MMD_TYPE_CHECKBOX)
{
// Checkbox...
width = height = SIZE_TABLE;
}
else if (!text)
{
continue;
}
else
{
// Text fragment...
if (type == MMD_TYPE_EMPHASIZED_TEXT)
font = DOCFONT_ITALIC;
else if (type == MMD_TYPE_STRONG_TEXT)
font = DOCFONT_BOLD;
else if (type == MMD_TYPE_CODE_TEXT)
font = DOCFONT_MONOSPACE;
else if (mmdGetType(cell) == MMD_TYPE_TABLE_HEADER_CELL)
font = DOCFONT_BOLD;
else
font = DOCFONT_REGULAR;
width = pdfioContentTextMeasure(dd->fonts[font], text, SIZE_TABLE);
height = SIZE_TABLE * LINE_HEIGHT;
if (ws && x > 0.0)
wswidth = pdfioContentTextMeasure(dd->fonts[font], " ", SIZE_TABLE);
}
if (width > col->min_width)
col->min_width = width;
// See if this node will fit on the current line
if (col->width > 0.0 && (x + width + wswidth) >= col->width)
{
// No, record the new line...
if (x > col->max_width)
col->max_width = x;
cellheight += lineheight;
x = 0.0;
lineheight = 0.0;
wswidth = 0.0;
}
x += width + wswidth;
if (height > lineheight)
lineheight = height;
}
// Capture the last line's measurements...
if (x > col->max_width)
col->max_width = x;
if (x > 0.0)
cellheight += lineheight;
// Return the total height...
return (cellheight);
}
//
// 'mmd_walk_next()' - Find the next markdown node.
//
static mmd_t * // O - Next node or `NULL` at end
mmd_walk_next(mmd_t *top, // I - Top node
mmd_t *node) // I - Current node
{
mmd_t *next, // Next node
*parent; // Parent node
// Figure out the next node under "top"...
if ((next = mmdGetFirstChild(node)) == NULL)
{
if ((next = mmdGetNextSibling(node)) == NULL)
{
if ((parent = mmdGetParent(node)) != top)
{
while ((next = mmdGetNextSibling(parent)) == NULL)
{
if ((parent = mmdGetParent(parent)) == top)
break;
}
}
}
}
return (next);
}
//
// 'new_page()' - Start a new page.
//
static void
new_page(docdata_t *dd) // I - Document data
{
pdfio_dict_t *page_dict; // Page dictionary
docfont_t fontface; // Current font face
size_t i; // Looping var
char temp[32]; // Temporary string
double width; // Width of fragment
// Close the current page...
if (dd->st)
{
pdfioStreamClose(dd->st);
add_links(dd);
}
// Prep the new page...
page_dict = pdfioDictCreate(dd->pdf);
dd->annots_array = pdfioArrayCreate(dd->pdf);
dd->annots_obj = pdfioFileCreateArrayObj(dd->pdf, dd->annots_array);
pdfioDictSetObj(page_dict, "Annots", dd->annots_obj);
pdfioDictSetRect(page_dict, "MediaBox", &dd->media_box);
// pdfioDictSetRect(page_dict, "CropBox", &dd->crop_box);
pdfioDictSetRect(page_dict, "ArtBox", &dd->art_box);
for (fontface = DOCFONT_REGULAR; fontface < DOCFONT_MAX; fontface ++)
pdfioPageDictAddFont(page_dict, docfont_names[fontface], dd->fonts[fontface]);
for (i = 0; i < dd->num_images; i ++)
pdfioPageDictAddImage(page_dict, pdfioStringCreatef(dd->pdf, "I%u", (unsigned)i), dd->images[i].obj);
dd->st = pdfioFileCreatePage(dd->pdf, page_dict);
dd->color = DOCCOLOR_BLACK;
dd->font = DOCFONT_MAX;
dd->fsize = 0.0;
dd->y = dd->art_box.y2;
// Add header/footer text
set_color(dd, DOCCOLOR_GRAY);
set_font(dd, DOCFONT_REGULAR, SIZE_HEADFOOT);
if (pdfioFileGetNumPages(dd->pdf) > 1 && dd->title)
{
// Show title in header...
width = pdfioContentTextMeasure(dd->fonts[DOCFONT_REGULAR], dd->title, SIZE_HEADFOOT);
pdfioContentTextBegin(dd->st);
pdfioContentTextMoveTo(dd->st, dd->crop_box.x1 + 0.5 * (dd->crop_box.x2 - dd->crop_box.x1 - width), dd->crop_box.y2 - SIZE_HEADFOOT);
pdfioContentTextShow(dd->st, UNICODE_VALUE, dd->title);
pdfioContentTextEnd(dd->st);
pdfioContentPathMoveTo(dd->st, dd->crop_box.x1, dd->crop_box.y2 - 2 * SIZE_HEADFOOT * LINE_HEIGHT + SIZE_HEADFOOT);
pdfioContentPathLineTo(dd->st, dd->crop_box.x2, dd->crop_box.y2 - 2 * SIZE_HEADFOOT * LINE_HEIGHT + SIZE_HEADFOOT);
pdfioContentStroke(dd->st);
}
// Show page number and current heading...
pdfioContentPathMoveTo(dd->st, dd->crop_box.x1, dd->crop_box.y1 + SIZE_HEADFOOT * LINE_HEIGHT);
pdfioContentPathLineTo(dd->st, dd->crop_box.x2, dd->crop_box.y1 + SIZE_HEADFOOT * LINE_HEIGHT);
pdfioContentStroke(dd->st);
pdfioContentTextBegin(dd->st);
snprintf(temp, sizeof(temp), "%u", (unsigned)pdfioFileGetNumPages(dd->pdf));
if (pdfioFileGetNumPages(dd->pdf) & 1)
{
// Page number on right...
width = pdfioContentTextMeasure(dd->fonts[DOCFONT_REGULAR], temp, SIZE_HEADFOOT);
pdfioContentTextMoveTo(dd->st, dd->crop_box.x2 - width, dd->crop_box.y1);
}
else
{
// Page number on left...
pdfioContentTextMoveTo(dd->st, dd->crop_box.x1, dd->crop_box.y1);
}
pdfioContentTextShow(dd->st, UNICODE_VALUE, temp);
pdfioContentTextEnd(dd->st);
if (dd->heading)
{
pdfioContentTextBegin(dd->st);
if (pdfioFileGetNumPages(dd->pdf) & 1)
{
// Current heading on left...
pdfioContentTextMoveTo(dd->st, dd->crop_box.x1, dd->crop_box.y1);
}
else
{
width = pdfioContentTextMeasure(dd->fonts[DOCFONT_REGULAR], dd->heading, SIZE_HEADFOOT);
pdfioContentTextMoveTo(dd->st, dd->crop_box.x2 - width, dd->crop_box.y1);
}
pdfioContentTextShow(dd->st, UNICODE_VALUE, dd->heading);
pdfioContentTextEnd(dd->st);
}
}
//
// 'output_cb()' - Write PDF data to the standard output...
//
static ssize_t // O - Number of bytes written
output_cb(void *output_cbdata, // I - Callback data (not used)
const void *buffer, // I - Buffer to write
size_t bytes) // I - Number of bytes to write
{
(void)output_cbdata;
return ((ssize_t)fwrite(buffer, 1, bytes, stdout));
}
//
// 'render_line()' - Render a line of text/graphics.
//
static void
render_line(docdata_t *dd, // I - Document data
double margin_left, // I - Left margin
double need_bottom, // I - How much space is needed after
double lineheight, // I - Height of line
size_t num_frags, // I - Number of line fragments
linefrag_t *frags) // I - Line fragments
{
size_t i; // Looping var
linefrag_t *frag; // Current line fragment
bool in_text = false; // Are we in a text block?
if (!dd->st)
new_page(dd);
dd->y -= lineheight;
if ((dd->y - need_bottom) < dd->art_box.y1)
{
new_page(dd);
dd->y -= lineheight;
}
for (i = 0, frag = frags; i < num_frags; i ++, frag ++)
{
if (frag->type == MMD_TYPE_CHECKBOX)
{
// Draw checkbox...
set_color(dd, frag->color);
if (in_text)
{
pdfioContentTextEnd(dd->st);
in_text = false;
}
// Add box
pdfioContentPathRect(dd->st, frag->x + 1.0 + margin_left, dd->y, frag->width - 3.0, frag->height - 3.0);
if (frag->text)
{
// Add check
pdfioContentPathMoveTo(dd->st, frag->x + 3.0 + margin_left, dd->y + 2.0);
pdfioContentPathLineTo(dd->st, frag->x + frag->width - 4.0 + margin_left, dd->y + frag->height - 5.0);
pdfioContentPathMoveTo(dd->st, frag->x + 3.0 + margin_left, dd->y + frag->height - 5.0);
pdfioContentPathLineTo(dd->st, frag->x + frag->width - 4.0 + margin_left, dd->y + 2.0);
}
pdfioContentStroke(dd->st);
}
else if (frag->text)
{
// Draw text
if (!in_text)
{
pdfioContentTextBegin(dd->st);
pdfioContentTextMoveTo(dd->st, frag->x + margin_left, dd->y);
in_text = true;
}
if (frag->ws && frag->font == DOCFONT_MONOSPACE)
{
set_font(dd, DOCFONT_REGULAR, frag->height);
pdfioContentTextShow(dd->st, UNICODE_VALUE, " ");
}
set_color(dd, frag->color);
set_font(dd, frag->font, frag->height);
if (frag->font == DOCFONT_MONOSPACE)
pdfioContentTextShow(dd->st, UNICODE_VALUE, frag->text);
else
pdfioContentTextShowf(dd->st, UNICODE_VALUE, "%s%s", frag->ws ? " " : "", frag->text);
if (frag->url && dd->num_links < DOCLINK_MAX)
{
doclink_t *l = dd->links + dd->num_links;
// Pointer to this link record
if (!strcmp(frag->url, "@"))
{
// Use mapped text as link target...
char targetlink[129]; // Targeted link
targetlink[0] = '#';
make_target_name(targetlink + 1, frag->text, sizeof(targetlink) - 1);
l->url = pdfioStringCreate(dd->pdf, targetlink);
}
else if (!strcmp(frag->url, "@@"))
{
// Use literal text as anchor...
l->url = pdfioStringCreatef(dd->pdf, "#%s", frag->text);
}
else
{
// Use URL as-is...
l->url = frag->url;
}
l->box.x1 = frag->x;
l->box.y1 = dd->y;
l->box.x2 = frag->x + frag->width;
l->box.y2 = dd->y + frag->height;
dd->num_links ++;
}
}
else
{
// Draw image
char imagename[32]; // Current image name
if (in_text)
{
pdfioContentTextEnd(dd->st);
in_text = false;
}
snprintf(imagename, sizeof(imagename), "I%u", (unsigned)frag->imagenum);
pdfioContentDrawImage(dd->st, imagename, frag->x + margin_left, dd->y, frag->width, frag->height);
}
}
if (in_text)
pdfioContentTextEnd(dd->st);
}
//
// 'render_row()' - Render a table row...
//
static void
render_row(docdata_t *dd, // I - Document data
size_t num_cols, // I - Number of columns
tablecol_t *cols, // I - Column information
tablerow_t *row) // I - Row
{
size_t col; // Current column
double row_y; // Start of row
docfont_t deffont; // Default font
// Start a new page as needed...
if (!dd->st)
new_page(dd);
if ((dd->y - row->height) < dd->art_box.y1)
new_page(dd);
if (mmdGetType(row->cells[0]) == MMD_TYPE_TABLE_HEADER_CELL)
{
// Header row, no border...
deffont = DOCFONT_BOLD;
}
else
{
// Regular body row, add borders...
deffont = DOCFONT_REGULAR;
set_color(dd, DOCCOLOR_GRAY);
pdfioContentPathRect(dd->st, cols[0].left - TABLE_PADDING, dd->y - row->height, cols[num_cols - 1].right - cols[0].left + 2.0 * TABLE_PADDING, row->height);
for (col = 1; col < num_cols; col ++)
{
pdfioContentPathMoveTo(dd->st, cols[col].left - TABLE_PADDING, dd->y);
pdfioContentPathLineTo(dd->st, cols[col].left - TABLE_PADDING, dd->y - row->height);
}
pdfioContentStroke(dd->st);
}
row_y = dd->y;
for (col = 0; col < num_cols; col ++)
{
dd->y = row_y;
format_block(dd, row->cells[col], deffont, SIZE_TABLE, cols[col].left, cols[col].right, /*leader*/NULL);
}
dd->y = row_y - row->height;
}
//
// 'set_color()' - Set the stroke and fill color as needed.
//
static void
set_color(docdata_t *dd, // I - Document data
doccolor_t color) // I - Document color
{
if (color == dd->color)
return;
switch (color)
{
case DOCCOLOR_BLACK :
pdfioContentSetFillColorDeviceGray(dd->st, 0.0);
pdfioContentSetStrokeColorDeviceGray(dd->st, 0.0);
break;
case DOCCOLOR_RED :
pdfioContentSetFillColorDeviceRGB(dd->st, 0.6, 0.0, 0.0);
pdfioContentSetStrokeColorDeviceRGB(dd->st, 0.6, 0.0, 0.0);
break;
case DOCCOLOR_ORANGE :
pdfioContentSetFillColorDeviceRGB(dd->st, 1.0, 0.5, 0.0);
pdfioContentSetStrokeColorDeviceRGB(dd->st, 1.0, 0.5, 0.0);
break;
case DOCCOLOR_BLUE :
pdfioContentSetFillColorDeviceRGB(dd->st, 0.0, 0.0, 0.8);
pdfioContentSetStrokeColorDeviceRGB(dd->st, 0.0, 0.0, 0.8);
break;
case DOCCOLOR_LTGRAY :
pdfioContentSetFillColorDeviceGray(dd->st, 0.933);
pdfioContentSetStrokeColorDeviceGray(dd->st, 0.933);
break;
case DOCCOLOR_GRAY :
pdfioContentSetFillColorDeviceGray(dd->st, 0.333);
pdfioContentSetStrokeColorDeviceGray(dd->st, 0.333);
break;
}
dd->color = color;
}
//
// 'set_font()' - Set the font typeface and size as needed.
//
static void
set_font(docdata_t *dd, // I - Document data
docfont_t font, // I - Font
double fsize) // I - Font size
{
if (font == dd->font && fabs(fsize - dd->fsize) < 0.1)
return;
if (font == DOCFONT_MAX)
return;
pdfioContentSetTextFont(dd->st, docfont_names[font], fsize);
if (fabs(fsize - dd->fsize) >= 0.1)
pdfioContentSetTextLeading(dd->st, fsize * LINE_HEIGHT);
dd->font = font;
dd->fsize = fsize;
}
//
// 'write_actions()' - Write remaining actions to the PDF file.
//
static void
write_actions(docdata_t *dd) // I - Document data
{
size_t i, j; // Looping vars
docaction_t *a; // Current action
doctarget_t *t; // Current target
for (i = 0, a = dd->actions; i < dd->num_actions; i ++, a ++)
{
for (j = 0, t = dd->targets; j < dd->num_targets; j ++, t ++)
{
if (!strcmp(a->target, t->name))
break;
}
if (j < dd->num_targets)
{
pdfio_array_t *dest = pdfioArrayCreate(dd->pdf);
// Destination array
pdfioArrayAppendObj(dest, pdfioFileGetPage(dd->pdf, t->page));
pdfioArrayAppendName(dest, "XYZ");
pdfioArrayAppendNumber(dest, PAGE_LEFT);
pdfioArrayAppendNumber(dest, t->y);
pdfioArrayAppendNumber(dest, 0.0);
pdfioDictSetArray(pdfioObjGetDict(a->obj), "Dest", dest);
}
pdfioObjClose(a->obj);
}
}
//
// 'write_toc()' - Write the table-of-contents outline.
//
static void
write_toc(docdata_t *dd) // I - Document data
{
size_t i, j; // Looping vars
doctoc_t *t, // Table-of-contents entry
*nt, // Next entry
*levels[6]; // Current entries for each level
int level; // Current level
pdfio_dict_t *dict; // Outline dictionary
pdfio_obj_t *obj; // Outline object
// Initialize the various TOC levels...
levels[0] = levels[1] = levels[2] = levels[3] = levels[4] = levels[5] = NULL;
// Scan the table of contents and finalize the dictionaries...
for (i = 0, t = dd->toc; i < dd->num_toc; i ++, t ++)
{
// Set parent, previous, and next entries...
if (t->level > 0 && levels[t->level - 1])
pdfioDictSetObj(t->dict, "Parent", levels[t->level - 1]->obj);
if (levels[t->level])
pdfioDictSetObj(t->dict, "Prev", levels[t->level]->obj);
for (j = i + 1, nt = t + 1; j < dd->num_toc; j ++, nt ++)
{
if (nt->level == t->level)
{
pdfioDictSetObj(t->dict, "Next", nt->obj);
break;
}
else if (nt->level < t->level)
{
break;
}
}
// First, last, and count...
for (level = 0; level < t->level; level ++)
levels[level]->count ++;
levels[t->level] = t;
if ((i + 1) < dd->num_toc && t[1].level > t->level)
pdfioDictSetObj(t->dict, "First", t[1].obj);
if ((i + 1) >= dd->num_toc)
{
// Close out all levels...
for (level = t->level; level > 0; level --)
{
pdfioDictSetObj(levels[level - 1]->dict, "Last", levels[level]->obj);
levels[level] = NULL;
}
}
else if (t->level > t[1].level)
{
// Close out N levels...
for (level = t->level; level > t[1].level; level --)
{
pdfioDictSetObj(levels[level - 1]->dict, "Last", levels[level]->obj);
levels[level] = NULL;
}
}
}
// Create the top-level outline object...
dict = pdfioDictCreate(dd->pdf);
obj = pdfioFileCreateObj(dd->pdf, dict);
pdfioDictSetName(dict, "Type", "Outline");
pdfioDictSetNumber(dict, "Count", dd->num_toc);
pdfioDictSetObj(dict, "First", dd->toc[0].obj);
// Close the objects for the entries...
for (i = 0, t = dd->toc; i < dd->num_toc; i ++, t ++)
{
if (t->level == 0)
pdfioDictSetObj(dict, "Last", t->obj);
if (t->count)
{
// Set Count value...
if (t->level == 0)
pdfioDictSetNumber(t->dict, "Count", t->count);
else
pdfioDictSetNumber(t->dict, "Count", -t->count);
}
pdfioObjClose(t->obj);
}
// Close the outline object and add it to the document catalog...
pdfioObjClose(obj);
pdfioDictSetObj(pdfioFileGetCatalog(dd->pdf), "Outlines", obj);
}