*/
/*
- * To be done:
- *
- * - index
- *
- * - header/footer? Page numbers at least would be handy. Fully
- * configurable footer can wait, though.
- *
- * That should bring us to the same level of functionality that
- * original-Halibut had, and the same in PDF plus the obvious
- * interactive navigation features. After that, in future work:
+ * TODO in future work:
*
* - linearised PDF, perhaps?
*
+ * - we should use PDFDocEncoding or Unicode for outline strings,
+ * now that I actually know how to do them. Probably easiest if
+ * I do this _after_ bringing in libcharset, since I can simply
+ * supply PDFDocEncoding in there.
+ *
* - I'm uncertain of whether I need to include a ToUnicode CMap
* in each of my font definitions in PDF. Currently things (by
* which I mean cut and paste out of acroread) seem to be
* working fairly happily without it, but I don't know.
*
+ * - rather than the ugly aux_text mechanism for rendering chapter
+ * titles, we could actually build the correct word list and
+ * wrap it as a whole.
+ *
+ * - get vertical font metrics and use them to position the PDF
+ * xref boxes more pleasantly
+ *
* - configurability
+ * * page header and footer should be configurable; we should
+ * be able to shift the page number elsewhere, and add other
+ * things such as the current chapter/section title and fixed
+ * text
+ * * remove the fixed mapping from heading levels to heading
+ * styles; offer a menu of styles from which the user can
+ * choose at every heading level
+ * * first-line indent in paragraphs
+ * * fixed text: `Contents', `Index', the colon-space and full
+ * stop in chapter title constructions
+ * * configurable location of contents?
+ * * certainly configurably _remove_ the contents, and possibly
+ * also the index
+ * * double-sided document switch?
+ * + means you have two header/footer formats which
+ * alternate
+ * + and means that mandatory page breaks before chapter
+ * titles should include a blank page if necessary to
+ * start the next section to a right-hand page
*
* - title pages
+ *
+ * - ability to import other Type 1 fonts
+ * * we need to parse the font to extract its metrics
+ * * then we pass the font bodily to both PS and PDF so it can
+ * be included in the output file
+ *
+ * - character substitution for better typography?
+ * * fi, fl, ffi, ffl ligatures
+ * * use real ellipsis rather than ...
+ * * a hyphen in a word by itself might prefer to be an en-dash
+ * * (Americans might even want a convenient way to use an
+ * em-dash)
+ * * DON'T DO ANY OF THE ABOVE WITHIN \c OR \cw!
+ * * substituting `minus' for `hyphen' in the standard encoding
+ * is probably preferable in Courier, though certainly not in
+ * the main text font
+ * * if I do do this lot, I'm rather inclined to at least try
+ * to think up a configurable way to do it so that Americans
+ * can do em-dash tricks without my intervention and other
+ * people can do other odd things too.
*/
#include <assert.h>
#include <stdio.h>
+#include <stdarg.h>
#include "halibut.h"
#include "paper.h"
int right_margin;
int bottom_margin;
int indent_list_bullet;
+ int indent_list_after;
int indent_list;
int indent_quote;
int base_leading;
int index_gutter;
int index_cols;
int index_minsep;
+ int pagenum_fontsize;
+ int footer_distance;
+ wchar_t *lquote, *rquote, *bullet;
/* These are derived from the above */
int base_width;
int page_height;
page_data *lastpage;
};
+enum {
+ word_PageXref = word_NotWordType + 1
+};
+
static font_data *make_std_font(font_list *fontlist, char const *name);
static void wrap_paragraph(para_data *pdata, word *words,
- int w, int i1, int i2);
+ int w, int i1, int i2, paper_conf *conf);
static page_data *page_breaks(line_data *first, line_data *last,
int page_height, int ncols, int headspace);
static int render_string(page_data *page, font_data *font, int fontsize,
int x, int y, wchar_t *str);
static int render_line(line_data *ldata, int left_x, int top_y,
- xref_dest *dest, keywordlist *keywords, indexdata *idx);
+ xref_dest *dest, keywordlist *keywords, indexdata *idx,
+ paper_conf *conf);
static void render_para(para_data *pdata, paper_conf *conf,
keywordlist *keywords, indexdata *idx,
paragraph *index_placeholder, page_data *index_page);
-static int paper_width_simple(para_data *pdata, word *text);
+static int string_width(font_data *font, wchar_t const *string, int *errs);
+static int paper_width_simple(para_data *pdata, word *text, paper_conf *conf);
static para_data *code_paragraph(int indent, word *words, paper_conf *conf);
static para_data *rule_paragraph(int indent, paper_conf *conf);
static void add_rect_to_page(page_data *page, int x, int y, int w, int h);
word *second);
static word *fake_word(wchar_t *text);
static word *fake_space_word(void);
+static word *fake_page_ref(page_data *page);
+static word *fake_end_ref(void);
static word *prepare_contents_title(word *first, wchar_t *separator,
word *second);
static void fold_into_page(page_data *dest, page_data *src, int right_shift);
+static int fonts_ok(wchar_t *string, ...)
+{
+ font_data *font;
+ va_list ap;
+ int ret = TRUE;
+
+ va_start(ap, string);
+ while ( (font = va_arg(ap, font_data *)) != NULL) {
+ int errs;
+ (void) string_width(font, string, &errs);
+ if (errs) {
+ ret = FALSE;
+ break;
+ }
+ }
+ va_end(ap);
+
+ return ret;
+}
+
+static paper_conf paper_configure(paragraph *source, font_list *fontlist) {
+ paragraph *p;
+ paper_conf ret;
+
+ /*
+ * Defaults.
+ */
+ ret.paper_width = 595 * 4096;
+ ret.paper_height = 841 * 4096;
+ ret.left_margin = 72 * 4096;
+ ret.top_margin = 72 * 4096;
+ ret.right_margin = 72 * 4096;
+ ret.bottom_margin = 108 * 4096;
+ ret.indent_list_bullet = 6 * 4096;
+ ret.indent_list_after = 18 * 4096;
+ ret.indent_quote = 18 * 4096;
+ ret.base_leading = 4096;
+ ret.base_para_spacing = 10 * 4096;
+ ret.chapter_top_space = 72 * 4096;
+ ret.sect_num_left_space = 12 * 4096;
+ ret.chapter_underline_depth = 14 * 4096;
+ ret.chapter_underline_thickness = 3 * 4096;
+ ret.rule_thickness = 1 * 4096;
+ ret.base_font_size = 12;
+ ret.contents_indent_step = 24 * 4096;
+ ret.contents_margin = 84 * 4096;
+ ret.leader_separation = 12 * 4096;
+ ret.index_gutter = 36 * 4096;
+ ret.index_cols = 2;
+ ret.index_minsep = 18 * 4096;
+ ret.pagenum_fontsize = 12;
+ ret.footer_distance = 32 * 4096;
+ ret.lquote = L"\x2018\0\x2019\0'\0'\0\0";
+ ret.rquote = uadv(ret.lquote);
+ ret.bullet = L"\x2022\0-\0\0";
+
+ /*
+ * Two-pass configuration so that we can pick up global config
+ * (e.g. `quotes') before having it overridden by specific
+ * config (`paper-quotes'), irrespective of the order in which
+ * they occur.
+ */
+ for (p = source; p; p = p->next) {
+ if (p->type == para_Config) {
+ if (!ustricmp(p->keyword, L"quotes")) {
+ if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
+ ret.lquote = uadv(p->keyword);
+ ret.rquote = uadv(ret.lquote);
+ }
+ }
+ }
+ }
+
+ for (p = source; p; p = p->next) {
+ p->private_data = NULL;
+ if (p->type == para_Config) {
+ if (!ustricmp(p->keyword, L"paper-quotes")) {
+ if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
+ ret.lquote = uadv(p->keyword);
+ ret.rquote = uadv(ret.lquote);
+ }
+ } else if (!ustricmp(p->keyword, L"paper-bullet")) {
+ ret.bullet = uadv(p->keyword);
+ } else if (!ustricmp(p->keyword, L"paper-page-width")) {
+ ret.paper_width =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-page-height")) {
+ ret.paper_height =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-left-margin")) {
+ ret.left_margin =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-top-margin")) {
+ ret.top_margin =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-right-margin")) {
+ ret.right_margin =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-bottom-margin")) {
+ ret.bottom_margin =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-list-indent")) {
+ ret.indent_list_bullet =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-listitem-indent")) {
+ ret.indent_list =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-quote-indent")) {
+ ret.indent_quote =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-base-leading")) {
+ ret.base_leading =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-base-para-spacing")) {
+ ret.base_para_spacing =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-chapter-top-space")) {
+ ret.chapter_top_space =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-sect-num-left-space")) {
+ ret.sect_num_left_space =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-chapter-underline-depth")) {
+ ret.chapter_underline_depth =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-chapter-underline-thickness")) {
+ ret.chapter_underline_thickness =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-rule-thickness")) {
+ ret.rule_thickness =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-contents-indent-step")) {
+ ret.contents_indent_step =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-contents-margin")) {
+ ret.contents_margin =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-leader-separation")) {
+ ret.leader_separation =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-index-gutter")) {
+ ret.index_gutter =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-index-minsep")) {
+ ret.index_minsep =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-footer-distance")) {
+ ret.footer_distance =
+ (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-base-font-size")) {
+ ret.base_font_size =
+ utoi(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-index-columns")) {
+ ret.index_cols =
+ utoi(uadv(p->keyword));
+ } else if (!ustricmp(p->keyword, L"paper-pagenum-font-size")) {
+ ret.pagenum_fontsize =
+ utoi(uadv(p->keyword));
+ }
+ }
+ }
+
+ /*
+ * Set up the derived fields in the conf structure.
+ */
+
+ ret.base_width =
+ ret.paper_width - ret.left_margin - ret.right_margin;
+ ret.page_height =
+ ret.paper_height - ret.top_margin - ret.bottom_margin;
+ ret.indent_list = ret.indent_list_bullet + ret.indent_list_after;
+ ret.index_colwidth =
+ (ret.base_width - (ret.index_cols-1) * ret.index_gutter)
+ / ret.index_cols;
+
+ /*
+ * Set up the font structures.
+ */
+ ret.tr = make_std_font(fontlist, "Times-Roman");
+ ret.ti = make_std_font(fontlist, "Times-Italic");
+ ret.hr = make_std_font(fontlist, "Helvetica-Bold");
+ ret.hi = make_std_font(fontlist, "Helvetica-BoldOblique");
+ ret.cr = make_std_font(fontlist, "Courier");
+ ret.co = make_std_font(fontlist, "Courier-Oblique");
+ ret.cb = make_std_font(fontlist, "Courier-Bold");
+
+ /*
+ * Now process fallbacks on quote characters and bullets. We
+ * use string_width() to determine whether all of the relevant
+ * fonts contain the same character, and fall back whenever we
+ * find a character which not all of them support.
+ */
+
+ /* Quote characters need not be supported in the fixed code fonts,
+ * but must be in the title and body fonts. */
+ while (*uadv(ret.rquote) && *uadv(uadv(ret.rquote)) &&
+ (!fonts_ok(ret.lquote, ret.tr, ret.ti, ret.hr, ret.hi, NULL) ||
+ !fonts_ok(ret.rquote, ret.tr, ret.ti, ret.hr, ret.hi, NULL))) {
+ ret.lquote = uadv(ret.rquote);
+ ret.rquote = uadv(ret.lquote);
+ }
+
+ /* The bullet character only needs to be supported in the normal body
+ * font (not even in italics). */
+ while (*ret.bullet && *uadv(ret.bullet) &&
+ !fonts_ok(ret.bullet, ret.tr, NULL))
+ ret.bullet = uadv(ret.bullet);
+
+ return ret;
+}
+
void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
indexdata *idx) {
paragraph *p;
line_data *firstline, *lastline, *firstcontline, *lastcontline;
page_data *pages;
font_list *fontlist;
- paper_conf *conf;
+ paper_conf *conf, ourconf;
int has_index;
int pagenum;
paragraph index_placeholder_para;
page_data *first_index_page;
- /*
- * FIXME: All these things ought to become configurable.
- */
- conf = mknew(paper_conf);
- conf->paper_width = 595 * 4096;
- conf->paper_height = 841 * 4096;
- conf->left_margin = 72 * 4096;
- conf->top_margin = 72 * 4096;
- conf->right_margin = 72 * 4096;
- conf->bottom_margin = 108 * 4096;
- conf->indent_list_bullet = 6 * 4096;
- conf->indent_list = 24 * 4096;
- conf->indent_quote = 18 * 4096;
- conf->base_leading = 4096;
- conf->base_para_spacing = 10 * 4096;
- conf->chapter_top_space = 72 * 4096;
- conf->sect_num_left_space = 12 * 4096;
- conf->chapter_underline_depth = 14 * 4096;
- conf->chapter_underline_thickness = 3 * 4096;
- conf->rule_thickness = 1 * 4096;
- conf->base_font_size = 12;
- conf->contents_indent_step = 24 * 4096;
- conf->contents_margin = 84 * 4096;
- conf->leader_separation = 12 * 4096;
- conf->index_gutter = 36 * 4096;
- conf->index_cols = 2;
- conf->index_minsep = 18 * 4096;
-
- conf->base_width =
- conf->paper_width - conf->left_margin - conf->right_margin;
- conf->page_height =
- conf->paper_height - conf->top_margin - conf->bottom_margin;
- conf->index_colwidth =
- (conf->base_width - (conf->index_cols-1) * conf->index_gutter)
- / conf->index_cols;
-
- IGNORE(idx); /* FIXME */
-
- /*
- * First, set up some font structures.
- */
- fontlist = mknew(font_list);
+ fontlist = snew(font_list);
fontlist->head = fontlist->tail = NULL;
- conf->tr = make_std_font(fontlist, "Times-Roman");
- conf->ti = make_std_font(fontlist, "Times-Italic");
- conf->hr = make_std_font(fontlist, "Helvetica-Bold");
- conf->hi = make_std_font(fontlist, "Helvetica-BoldOblique");
- conf->cr = make_std_font(fontlist, "Courier");
- conf->co = make_std_font(fontlist, "Courier-Oblique");
- conf->cb = make_std_font(fontlist, "Courier-Bold");
+
+ ourconf = paper_configure(sourceform, fontlist);
+ conf = &ourconf;
/*
* Set up a data structure to collect page numbers for each
has_index = FALSE;
for (i = 0; (entry = index234(idx->entries, i)) != NULL; i++) {
- paper_idx *pi = mknew(paper_idx);
+ paper_idx *pi = snew(paper_idx);
has_index = TRUE;
for (page = pages; page; page = page->next) {
sprintf(buf, "%d", ++pagenum);
- page->number = ufroma_dup(buf);
+ page->number = ufroma_dup(buf, CS_ASCII);
}
if (has_index) {
- first_index_page = mknew(page_data);
+ first_index_page = snew(page_data);
first_index_page->next = first_index_page->prev = NULL;
first_index_page->first_line = NULL;
first_index_page->last_line = NULL;
/* And don't forget the as-yet-uncreated index. */
sprintf(buf, "%d", ++pagenum);
- first_index_page->number = ufroma_dup(buf);
+ first_index_page->number = ufroma_dup(buf, CS_ASCII);
}
}
paper_idx *pi = (paper_idx *)entry->backend_data;
para_data *text, *pages;
+ if (!pi->words)
+ continue;
+
text = make_para_data(para_Normal, 0, 0,
conf->base_width - conf->index_colwidth,
NULL, NULL, entry->text, conf);
for (page = ipages->next; page; page = page->next) {
char buf[40];
sprintf(buf, "%d", ++pagenum);
- page->number = ufroma_dup(buf);
+ page->number = ufroma_dup(buf, CS_ASCII);
}
/*
}
/*
+ * Draw the headers and footers.
+ *
+ * FIXME: this should be fully configurable, but for the moment
+ * I'm just going to put in page numbers in the centre of a
+ * footer and leave it at that.
+ */
+ {
+ page_data *page;
+
+ for (page = pages; page; page = page->next) {
+ int width;
+
+ width = conf->pagenum_fontsize *
+ string_width(conf->tr, page->number, NULL);
+
+ render_string(page, conf->tr, conf->pagenum_fontsize,
+ conf->left_margin + (conf->base_width - width)/2,
+ conf->bottom_margin - conf->footer_distance,
+ page->number);
+ }
+ }
+
+ /*
* Start putting together the overall document structure we're
* going to return.
*/
- doc = mknew(document);
+ doc = snew(document);
doc->fonts = fontlist;
doc->pages = pages;
doc->paper_width = conf->paper_width;
{
int osize = 20;
- doc->outline_elements = mknewa(outline_element, osize);
+ doc->outline_elements = snewn(osize, outline_element);
doc->n_outline_elements = 0;
/* First find the title. */
if (doc->n_outline_elements >= osize) {
osize += 20;
doc->outline_elements =
- resize(doc->outline_elements, osize);
+ sresize(doc->outline_elements, osize, outline_element);
}
doc->outline_elements[doc->n_outline_elements].level =
}
}
- sfree(conf);
-
return doc;
}
int extra_indent, firstline_indent, aux_indent;
word *aux, *aux2;
- pdata = mknew(para_data);
+ pdata = snew(para_data);
pdata->outline_level = -1;
pdata->outline_title = NULL;
pdata->rect_type = RECT_NONE;
int len;
aux = pkwtext2;
- len = paper_width_simple(pdata, pkwtext2);
+ len = paper_width_simple(pdata, pkwtext2, conf);
aux_indent = -len - conf->sect_num_left_space;
pdata->outline_title =
aux2 = fake_word(L": ");
aux_indent = 0;
- firstline_indent += paper_width_simple(pdata, aux);
- firstline_indent += paper_width_simple(pdata, aux2);
+ firstline_indent += paper_width_simple(pdata, aux, conf);
+ firstline_indent += paper_width_simple(pdata, aux2, conf);
pdata->outline_title =
prepare_outline_title(pkwtext, L": ", pwords);
case para_Bullet:
/*
- * Auxiliary text consisting of a bullet. (FIXME:
- * configurable bullet.)
+ * Auxiliary text consisting of a bullet.
*/
- aux = fake_word(L"\x2022");
+ aux = fake_word(conf->bullet);
aux_indent = indent + conf->indent_list_bullet;
break;
aux = pkwtext;
aux2 = fake_word(L" ");
aux_indent = indent;
- firstline_indent += paper_width_simple(pdata, aux);
- firstline_indent += paper_width_simple(pdata, aux2);
+ firstline_indent += paper_width_simple(pdata, aux, conf);
+ firstline_indent += paper_width_simple(pdata, aux2, conf);
break;
}
wrap_paragraph(pdata, pwords, conf->base_width - rmargin,
indent + firstline_indent,
- indent + extra_indent);
+ indent + extra_indent, conf);
pdata->first->aux_text = aux;
pdata->first->aux_text_2 = aux2;
font_encoding *fe;
int i;
- fe = mknew(font_encoding);
+ fe = snew(font_encoding);
fe->next = NULL;
if (font->list->tail)
for (nglyphs = 0; ps_std_glyphs[nglyphs] != NULL; nglyphs++);
- f = mknew(font_data);
+ f = snew(font_data);
f->list = fontlist;
f->name = name;
f->nglyphs = nglyphs;
f->glyphs = ps_std_glyphs;
f->widths = widths;
- f->subfont_map = mknewa(subfont_map_entry, nglyphs);
+ f->subfont_map = snewn(nglyphs, subfont_map_entry);
/*
* Our first subfont will contain all of US-ASCII. This isn't
struct paper_width_ctx {
int minspacewidth;
para_data *pdata;
+ paper_conf *conf;
};
static int paper_width_list(void *vctx, word *text, word *end, int *nspaces) {
case word_HyperEnd:
case word_UpperXref:
case word_LowerXref:
+ case word_PageXref:
case word_XrefEnd:
case word_IndexRef:
return 0;
str = L" ";
} else /* if (type == word_Quote) */ {
if (word->aux == quote_Open)
- str = L"\x2018"; /* FIXME: configurability! */
+ str = ctx->conf->lquote;
else
- str = L"\x2019"; /* FIXME: configurability! */
+ str = ctx->conf->rquote;
}
width = string_width(ctx->pdata->fonts[findex], str, &errs);
return paper_width_internal(vctx, word, NULL);
}
-static int paper_width_simple(para_data *pdata, word *text)
+static int paper_width_simple(para_data *pdata, word *text, paper_conf *conf)
{
struct paper_width_ctx ctx;
ctx.minspacewidth =
(pdata->sizes[FONT_NORMAL] *
string_width(pdata->fonts[FONT_NORMAL], L" ", NULL));
+ ctx.conf = conf;
return paper_width_list(&ctx, text, NULL, NULL);
}
static void wrap_paragraph(para_data *pdata, word *words,
- int w, int i1, int i2)
+ int w, int i1, int i2, paper_conf *conf)
{
wrappedline *wrapping, *p;
int spacewidth;
*/
ctx.minspacewidth = spacewidth * 3 / 5;
ctx.pdata = pdata;
+ ctx.conf = conf;
wrapping = wrap_para(words, w - i1, w - i2, paper_width, &ctx, spacewidth);
word *wd;
int len, wid, spaces;
- ldata = mknew(line_data);
+ ldata = snew(line_data);
ldata->pdata = pdata;
ldata->first = p->begin;
*/
for (l = last; l; l = l->prev) {
- l->bestcost = mknewa(int, ncols+1);
- l->vshortfall = mknewa(int, ncols+1);
- l->text = mknewa(int, ncols+1);
- l->space = mknewa(int, ncols+1);
- l->page_last = mknewa(line_data *, ncols+1);
+ l->bestcost = snewn(ncols+1, int);
+ l->vshortfall = snewn(ncols+1, int);
+ l->text = snewn(ncols+1, int);
+ l->space = snewn(ncols+1, int);
+ l->page_last = snewn(ncols+1, line_data *);
for (n = 0; n <= ncols; n++) {
int minheight, text = 0, space = 0;
page_data *page;
int text, space, head;
- page = mknew(page_data);
+ page = snew(page_data);
page->next = NULL;
page->prev = pt;
if (pt)
static void add_rect_to_page(page_data *page, int x, int y, int w, int h)
{
- rect *r = mknew(rect);
+ rect *r = snew(rect);
r->next = NULL;
if (page->last_rect)
}
static void add_string_to_page(page_data *page, int x, int y,
- font_encoding *fe, int size, char *text)
+ font_encoding *fe, int size, char *text,
+ int width)
{
text_fragment *frag;
- frag = mknew(text_fragment);
+ frag = snew(text_fragment);
frag->next = NULL;
if (page->last_text)
frag->fe = fe;
frag->fontsize = size;
frag->text = dupstr(text);
+ frag->width = width;
}
/*
int textpos, textwid, glyph;
font_encoding *subfont = NULL, *sf;
- text = mknewa(char, 1 + ustrlen(str));
+ text = snewn(1 + ustrlen(str), char);
textpos = textwid = 0;
while (*str) {
glyph = font->bmp[*str];
- if (glyph == 0xFFFF)
+ if (glyph == 0xFFFF) {
+ str++;
continue; /* nothing more we can do here */
+ }
/*
* Find which subfont this character is going in.
if (!subfont || sf != subfont) {
if (subfont) {
text[textpos] = '\0';
- add_string_to_page(page, x, y, subfont, fontsize, text);
+ add_string_to_page(page, x, y, subfont, fontsize, text,
+ textwid);
x += textwid;
} else {
assert(textpos == 0);
if (textpos > 0) {
text[textpos] = '\0';
- add_string_to_page(page, x, y, subfont, fontsize, text);
+ add_string_to_page(page, x, y, subfont, fontsize, text, textwid);
x += textwid;
}
static int render_text(page_data *page, para_data *pdata, line_data *ldata,
int x, int y, word *text, word *text_end, xref **xr,
int shortfall, int nspaces, int *nspace,
- keywordlist *keywords, indexdata *idx)
+ keywordlist *keywords, indexdata *idx, paper_conf *conf)
{
while (text && text != text_end) {
int style, type, findex, errs;
case word_HyperLink:
case word_UpperXref:
case word_LowerXref:
+ case word_PageXref:
if (text->type == word_HyperLink) {
dest.type = URL;
- dest.url = utoa_dup(text->text);
+ dest.url = utoa_dup(text->text, CS_ASCII);
dest.page = NULL;
+ } else if (text->type == word_PageXref) {
+ dest.type = PAGE;
+ dest.url = NULL;
+ dest.page = (page_data *)text->private_data;
} else {
keyword *kwl = kw_lookup(keywords, text->text);
para_data *pdata;
}
}
if (dest.type != NONE) {
- *xr = mknew(xref);
+ *xr = snew(xref);
(*xr)->dest = dest; /* structure copy */
if (page->last_xref)
page->last_xref->next = *xr;
* referenced by an index entry.
*/
case word_IndexRef:
- {
+ /*
+ * We don't create index references in contents entries.
+ */
+ if (!pdata->contents_entry) {
indextag *tag;
int i;
* mention it once in the index.
*/
if (pi->lastpage != page) {
+ word **wp;
+
if (pi->lastword) {
pi->lastword = pi->lastword->next =
fake_word(L",");
pi->lastword = pi->lastword->next =
fake_space_word();
- pi->lastword = pi->lastword->next =
- fake_word(page->number);
- } else {
- pi->lastword = pi->words =
- fake_word(page->number);
- }
+ wp = &pi->lastword->next;
+ } else
+ wp = &pi->words;
+
+ pi->lastword = *wp =
+ fake_page_ref(page);
+ pi->lastword = pi->lastword->next =
+ fake_word(page->number);
+ pi->lastword = pi->lastword->next =
+ fake_end_ref();
}
pi->lastpage = page;
goto nextword;
} else /* if (type == word_Quote) */ {
if (text->aux == quote_Open)
- str = L"\x2018"; /* FIXME: configurability! */
+ str = conf->lquote;
else
- str = L"\x2019"; /* FIXME: configurability! */
+ str = conf->rquote;
}
(void) string_width(pdata->fonts[findex], str, &errs);
if (errs && text->alt)
x = render_text(page, pdata, ldata, x, y, text->alt, NULL,
- xr, shortfall, nspaces, nspace, keywords, idx);
+ xr, shortfall, nspaces, nspace, keywords, idx,
+ conf);
else
x = render_string(page, pdata->fonts[findex],
pdata->sizes[findex], x, y, str);
* Returns the last x position used on the line.
*/
static int render_line(line_data *ldata, int left_x, int top_y,
- xref_dest *dest, keywordlist *keywords, indexdata *idx)
+ xref_dest *dest, keywordlist *keywords, indexdata *idx,
+ paper_conf *conf)
{
int nspace;
xref *xr;
left_x + ldata->aux_left_indent,
top_y - ldata->ypos,
ldata->aux_text, NULL, &xr, 0, 0, &nspace,
- keywords, idx);
+ keywords, idx, conf);
if (ldata->aux_text_2)
render_text(ldata->page, ldata->pdata, ldata,
x, top_y - ldata->ypos,
ldata->aux_text_2, NULL, &xr, 0, 0, &nspace,
- keywords, idx);
+ keywords, idx, conf);
}
nspace = 0;
* previous line.
*/
if (dest->type != NONE) {
- xr = mknew(xref);
+ xr = snew(xref);
xr->next = NULL;
xr->dest = *dest; /* structure copy */
if (ldata->page->last_xref)
left_x + ldata->xpos + extra_indent,
top_y - ldata->ypos, ldata->first, ldata->end,
&xr, shortfall, spaces, &nspace,
- keywords, idx);
+ keywords, idx, conf);
}
if (xr) {
*/
if (pdata->contents_entry && ldata->page != cxref_page) {
cxref_page = ldata->page;
- cxref = mknew(xref);
+ cxref = snew(xref);
cxref->next = NULL;
cxref->dest.type = PAGE;
if (pdata->contents_entry == index_placeholder) {
last_x = render_line(ldata, conf->left_margin,
conf->paper_height - conf->top_margin,
- &dest, keywords, idx);
+ &dest, keywords, idx, conf);
if (ldata == pdata->last)
break;
}
}
w = fake_word(num);
- wid = paper_width_simple(pdata, w);
+ wid = paper_width_simple(pdata, w, conf);
sfree(w);
- render_string(pdata->last->page,
- pdata->fonts[FONT_NORMAL],
- pdata->sizes[FONT_NORMAL],
- conf->paper_width - conf->right_margin - wid,
- (conf->paper_height - conf->top_margin -
- pdata->last->ypos), num);
-
for (x = 0; x < conf->base_width; x += conf->leader_separation)
if (x - conf->leader_separation > last_x - conf->left_margin &&
x + conf->leader_separation < conf->base_width - wid)
conf->left_margin + x,
(conf->paper_height - conf->top_margin -
pdata->last->ypos), L".");
+
+ render_string(pdata->last->page,
+ pdata->fonts[FONT_NORMAL],
+ pdata->sizes[FONT_NORMAL],
+ conf->paper_width - conf->right_margin - wid,
+ (conf->paper_height - conf->top_margin -
+ pdata->last->ypos), num);
}
/*
static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
{
- para_data *pdata = mknew(para_data);
+ para_data *pdata = snew(para_data);
/*
* For code paragraphs, I'm going to hack grievously and
* which has the same emphasis. Form it into a word
* structure.
*/
- w = mknew(word);
+ w = snew(word);
w->next = NULL;
w->alt = NULL;
w->type = (prev == 0 ? word_WeakCode :
prev == 1 ? word_Emph : word_Normal);
- w->text = mknewa(wchar_t, t-start+1);
+ w->text = snewn(t-start+1, wchar_t);
memcpy(w->text, start, (t-start) * sizeof(wchar_t));
w->text[t-start] = '\0';
w->breaks = FALSE;
prev = -1;
}
- ldata = mknew(line_data);
+ ldata = snew(line_data);
ldata->pdata = pdata;
ldata->first = lhead;
static para_data *rule_paragraph(int indent, paper_conf *conf)
{
- para_data *pdata = mknew(para_data);
+ para_data *pdata = snew(para_data);
line_data *ldata;
- ldata = mknew(line_data);
+ ldata = snew(line_data);
ldata->pdata = pdata;
ldata->first = NULL;
static word *fake_word(wchar_t *text)
{
- word *ret = mknew(word);
+ word *ret = snew(word);
ret->next = NULL;
ret->alt = NULL;
ret->type = word_Normal;
static word *fake_space_word(void)
{
- word *ret = mknew(word);
+ word *ret = snew(word);
ret->next = NULL;
ret->alt = NULL;
ret->type = word_WhiteSpace;
return ret;
}
+static word *fake_page_ref(page_data *page)
+{
+ word *ret = snew(word);
+ ret->next = NULL;
+ ret->alt = NULL;
+ ret->type = word_PageXref;
+ ret->text = NULL;
+ ret->breaks = FALSE;
+ ret->aux = 0;
+ ret->private_data = page;
+ return ret;
+}
+
+static word *fake_end_ref(void)
+{
+ word *ret = snew(word);
+ ret->next = NULL;
+ ret->alt = NULL;
+ ret->type = word_XrefEnd;
+ ret->text = NULL;
+ ret->breaks = FALSE;
+ ret->aux = 0;
+ return ret;
+}
+
static word *prepare_contents_title(word *first, wchar_t *separator,
word *second)
{
~mdw / sgt / halibut / blobdiff