{
return page->cp[axis][page->n[axis] * 2 + 1];
}
+
+int
+render_page_get_best_breakpoint (const struct render_page *page, int height)
+{
+ int y;
+
+ /* If there's no room for at least the top row and the rules above and below
+ it, don't include any of the table. */
+ if (page->cp[V][3] > height)
+ return 0;
+
+ /* Otherwise include as many rows and rules as we can. */
+ for (y = 5; y <= 2 * page->n[V] + 1; y += 2)
+ if (page->cp[V][y] > height)
+ return page->cp[V][y - 2];
+ return height;
+}
\f
/* Drawing render_pages. */
struct table_cell cell;
table_get_cell (page->table, x / 2, y / 2, &cell);
- if (y == bb[V][0] || y / 2 == cell.d[V][0])
+ if (y / 2 == bb[V][0] / 2 || y / 2 == cell.d[V][0])
render_cell (page, &cell);
x = rule_ofs (cell.d[H][1]);
table_cell_free (&cell);
return best;
}
-/* Returns the least value i, 0 <= i < n, such that cp[i + 1] >= x1. */
+/* Returns the least value i, 0 <= i < n, such that cp[i] >= x1. */
static int
get_clip_max_extent (int x1, const int cp[], int n)
{
low = middle + 1;
}
+ while (best > 0 && cp[best - 1] == cp[best])
+ best--;
+
return best;
}
\f
/* Breaking up tables to fit on a page. */
+/* An iterator for breaking render_pages into smaller chunks. */
+struct render_break
+ {
+ struct render_page *page; /* Page being broken up. */
+ enum table_axis axis; /* Axis along which 'page' is being broken. */
+ int z; /* Next cell along 'axis'. */
+ int pixel; /* Pixel offset within cell 'z' (usually 0). */
+ int hw; /* Width of headers of 'page' along 'axis'. */
+ };
+
static int needed_size (const struct render_break *, int cell);
static bool cell_is_breakable (const struct render_break *, int cell);
static struct render_page *render_page_select (const struct render_page *,
Ownership of PAGE is transferred to B. The caller must use
render_page_ref() if it needs to keep a copy of PAGE. */
-void
+static void
render_break_init (struct render_break *b, struct render_page *page,
enum table_axis axis)
{
b->page = page;
b->axis = axis;
- b->cell = page->h[axis][0];
+ b->z = page->h[axis][0];
b->pixel = 0;
b->hw = headers_width (page, axis);
}
/* Initializes B as a render_break structure for which
render_break_has_next() always returns false. */
-void
+static void
render_break_init_empty (struct render_break *b)
{
b->page = NULL;
b->axis = TABLE_HORZ;
- b->cell = 0;
+ b->z = 0;
b->pixel = 0;
b->hw = 0;
}
/* Frees B and unrefs the render_page that it owns. */
-void
+static void
render_break_destroy (struct render_break *b)
{
if (b != NULL)
/* Returns true if B still has cells that are yet to be returned,
false if all of B's page has been processed. */
-bool
+static bool
render_break_has_next (const struct render_break *b)
{
const struct render_page *page = b->page;
enum table_axis axis = b->axis;
- return page != NULL && b->cell < page->n[axis] - page->h[axis][1];
-}
-
-/* Returns the minimum SIZE argument that, if passed to render_break_next(),
- will avoid a null return value (if cells are still left). */
-int
-render_break_next_size (const struct render_break *b)
-{
- const struct render_page *page = b->page;
- enum table_axis axis = b->axis;
-
- return (!render_break_has_next (b) ? 0
- : !cell_is_breakable (b, b->cell) ? needed_size (b, b->cell + 1)
- : b->hw + page->params->font_size[axis]);
+ return page != NULL && b->z < page->n[axis] - page->h[axis][1];
}
/* Returns a new render_page that is up to SIZE pixels wide along B's axis.
SIZE is too small to reasonably render any cells. The latter will never
happen if SIZE is at least as large as the page size passed to
render_page_create() along B's axis. */
-struct render_page *
+static struct render_page *
render_break_next (struct render_break *b, int size)
{
const struct render_page *page = b->page;
enum table_axis axis = b->axis;
struct render_page *subpage;
- int cell, pixel;
+ int z, pixel;
if (!render_break_has_next (b))
return NULL;
pixel = 0;
- for (cell = b->cell; cell < page->n[axis] - page->h[axis][1]; cell++)
+ for (z = b->z; z < page->n[axis] - page->h[axis][1]; z++)
{
- int needed = needed_size (b, cell + 1);
+ int needed = needed_size (b, z + 1);
if (needed > size)
{
- if (cell_is_breakable (b, cell))
+ if (cell_is_breakable (b, z))
{
/* If there is no right header and we render a partial cell on
the right side of the body, then we omit the rightmost rule of
This is similar to code for the left side in needed_size(). */
int rule_allowance = (page->h[axis][1]
? 0
- : rule_width (page, axis, cell));
+ : rule_width (page, axis, z));
- /* The amount that, if we added 'cell', the rendering would
+ /* The amount that, if we added cell 'z', the rendering would
overfill the allocated 'size'. */
int overhang = needed - size - rule_allowance;
- /* The width of 'cell'. */
- int cell_size = cell_width (page, axis, cell);
+ /* The width of cell 'z'. */
+ int cell_size = cell_width (page, axis, z);
- /* The amount trimmed the left side of 'cell',
+ /* The amount trimmed off the left side of 'z',
and the amount left to render. */
- int cell_ofs = cell == b->cell ? b->pixel : 0;
+ int cell_ofs = z == b->z ? b->pixel : 0;
int cell_left = cell_size - cell_ofs;
/* A small but visible width. */
to make the output look a little better. */
if (pixel + em > cell_size)
pixel = MAX (pixel - em, 0);
+
+ /* If we're breaking vertically, then consider whether the cells
+ being broken have a better internal breakpoint than the exact
+ number of pixels available, which might look bad e.g. because
+ it breaks in the middle of a line of text. */
+ if (axis == TABLE_VERT && page->params->adjust_break)
+ {
+ int x;
+
+ for (x = 0; x < page->n[H]; )
+ {
+ struct table_cell cell;
+ int better_pixel;
+ int w;
+
+ table_get_cell (page->table, x, z, &cell);
+ w = joined_width (page, H, cell.d[H][0], cell.d[H][1]);
+ better_pixel = page->params->adjust_break (
+ page->params->aux, &cell, w, pixel);
+ x = cell.d[H][1];
+ table_cell_free (&cell);
+
+ if (better_pixel < pixel)
+ {
+ if (better_pixel > (z == b->z ? b->pixel : 0))
+ {
+ pixel = better_pixel;
+ break;
+ }
+ else if (better_pixel == 0 && z != b->z)
+ {
+ pixel = 0;
+ break;
+ }
+ }
+ }
+ }
}
break;
}
}
- if (cell == b->cell && !pixel)
+ if (z == b->z && !pixel)
return NULL;
- subpage = render_page_select (page, axis, b->cell, b->pixel,
- pixel ? cell + 1 : cell,
- pixel ? cell_width (page, axis, cell) - pixel
+ subpage = render_page_select (page, axis, b->z, b->pixel,
+ pixel ? z + 1 : z,
+ pixel ? cell_width (page, axis, z) - pixel
: 0);
- b->cell = cell;
+ b->z = z;
b->pixel = pixel;
return subpage;
}
invidiually. */
if (b->pixel == 0 || page->h[axis][0])
size += MAX (rule_width (page, axis, page->h[axis][0]),
- rule_width (page, axis, b->cell));
+ rule_width (page, axis, b->z));
/* Width of body, minus any pixel offset in the leftmost cell. */
- size += joined_width (page, axis, b->cell, cell) - b->pixel;
+ size += joined_width (page, axis, b->z, cell) - b->pixel;
/* Width of rightmost rule in body merged with leftmost rule in headers. */
size += MAX (rule_width_r (page, axis, page->h[axis][1]),
/* Join crossing. */
if (page->h[axis][0] && page->h[axis][1])
- size += page->join_crossing[axis][b->cell];
+ size += page->join_crossing[axis][b->z];
return size;
}
return cell_width (page, axis, cell) >= page->params->min_break[axis];
}
\f
+/* render_pager. */
+
+struct render_pager
+ {
+ int width;
+ struct render_break x_break;
+ struct render_break y_break;
+ };
+
+/* Creates and returns a new render_pager for breaking PAGE into smaller
+ chunks. Takes ownership of PAGE. */
+struct render_pager *
+render_pager_create (struct render_page *page)
+{
+ struct render_pager *p = xmalloc (sizeof *p);
+ p->width = page->params->size[H];
+ render_break_init (&p->x_break, page, H);
+ render_break_init_empty (&p->y_break);
+ return p;
+}
+
+/* Destroys P. */
+void
+render_pager_destroy (struct render_pager *p)
+{
+ if (p)
+ {
+ render_break_destroy (&p->x_break);
+ render_break_destroy (&p->y_break);
+ free (p);
+ }
+}
+
+/* Returns true if P has content remaining to render, false if rendering is
+ done. */
+bool
+render_pager_has_next (const struct render_pager *p_)
+{
+ struct render_pager *p = CONST_CAST (struct render_pager *, p_);
+
+ while (!render_break_has_next (&p->y_break))
+ {
+ render_break_destroy (&p->y_break);
+ if (render_break_has_next (&p->x_break))
+ {
+ struct render_page *x_slice;
+
+ x_slice = render_break_next (&p->x_break, p->width);
+ render_break_init (&p->y_break, x_slice, V);
+ }
+ else
+ {
+ render_break_init_empty (&p->y_break);
+ return false;
+ }
+ }
+ return true;
+}
+
+/* Returns the next render_page from P to render in a space that has vertical
+ size SPACE and the horizontal size as specified in render_params passed to
+ render_page_create(). The caller takes ownership of the returned
+ render_page. If no content remains to render, or if SPACE is too small to
+ render anything, returns NULL. */
+struct render_page *
+render_pager_next (struct render_pager *p, int space)
+{
+ return (render_pager_has_next (p)
+ ? render_break_next (&p->y_break, space)
+ : NULL);
+}
+\f
/* render_page_select() and helpers. */
struct render_page_selection