#include <stddef.h>
#include "output/table-provider.h"
-struct table;
+struct table_item;
enum render_line_style
{
- RENDER_LINE_NONE, /* No line. */
- RENDER_LINE_SINGLE, /* Single line. */
- RENDER_LINE_DOUBLE, /* Double line. */
+ RENDER_LINE_NONE,
+ RENDER_LINE_SINGLE,
+ RENDER_LINE_DASHED,
+ RENDER_LINE_THICK,
+ RENDER_LINE_THIN,
+ RENDER_LINE_DOUBLE,
RENDER_N_LINES
};
+/* Parameters for rendering a table_item to a device.
+
+
+ Coordinate system
+ =================
+
+ The rendering code assumes that larger 'x' is to the right and larger 'y'
+ toward the bottom of the page.
+
+ The rendering code assumes that the table being rendered has its upper left
+ corner at (0,0) in device coordinates. This is usually not the case from
+ the driver's perspective, so the driver should expect to apply its own
+ offset to coordinates passed to callback functions.
+*/
struct render_params
+ {
+ /* Functional parameters and auxiliary data to pass to them. */
+ const struct render_ops *ops;
+ void *aux;
+
+ /* Page size to try to fit the rendering into. Some tables will, of
+ course, overflow this size. */
+ int size[TABLE_N_AXES];
+
+ /* Nominal size of a character in the most common font:
+ font_size[TABLE_HORZ]: Em width.
+ font_size[TABLE_VERT]: Line spacing. */
+ int font_size[TABLE_N_AXES];
+
+ /* Width of different kinds of lines. */
+ const int *line_widths; /* RENDER_N_LINES members. */
+
+ /* Minimum cell width or height before allowing the cell to be broken
+ across two pages. (Joined cells may always be broken at join
+ points.) */
+ int min_break[TABLE_N_AXES];
+
+ /* True if the driver supports cell margins. (If false, the rendering
+ engine will insert a small space betweeen adjacent cells that don't have
+ an intervening rule.) */
+ bool supports_margins;
+
+ /* True if the local language has a right-to-left direction, otherwise
+ false. (Use render_direction_rtl() to find out.) */
+ bool rtl;
+
+ /* True if the table is being rendered for printing (as opposed to
+ on-screen display). */
+ bool printing;
+ };
+
+struct render_ops
{
/* Measures CELL's width. Stores in *MIN_WIDTH the minimum width required
to avoid splitting a single word across multiple lines (normally, this
is the width of the longest word in the cell) and in *MAX_WIDTH the
- minimum width required to avoid line breaks other than at new-lines. */
+ minimum width required to avoid line breaks other than at new-lines.
+ */
void (*measure_cell_width) (void *aux, const struct table_cell *cell,
int *min_width, int *max_width);
STYLES[TABLE_VERT][0]: style of line from left of BB to its center.
STYLES[TABLE_VERT][1]: style of line from right of BB to its center. */
void (*draw_line) (void *aux, int bb[TABLE_N_AXES][2],
- enum render_line_style styles[TABLE_N_AXES][2]);
+ enum render_line_style styles[TABLE_N_AXES][2],
+ struct cell_color colors[TABLE_N_AXES][2]);
/* Draws CELL within bounding box BB. CLIP is the same as BB (the common
case) or a subregion enclosed by BB. In the latter case only the part
of the cell that lies within CLIP should actually be drawn, although BB
- should used to determine the layout of the cell. */
- void (*draw_cell) (void *aux, const struct table_cell *cell,
- int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2]);
-
- /* Auxiliary data passed to each of the above functions. */
- void *aux;
-
- /* Page size to try to fit the rendering into. Some tables will, of
- course, overflow this size. */
- int size[TABLE_N_AXES];
-
- /* Nominal size of a character in the most common font:
- font_size[TABLE_HORZ]: Em width.
- font_size[TABLE_VERT]: Line spacing. */
- int font_size[TABLE_N_AXES];
-
- /* Width of different kinds of lines. */
- int line_widths[TABLE_N_AXES][RENDER_N_LINES];
-
- /* Minimum cell width or height before allowing the cell to be broken
- across two pages. (Joined cells may always be broken at join
- points.) */
- int min_break[TABLE_N_AXES];
+ should used to determine the layout of the cell.
+
+ The text in the cell needs to be vertically offset VALIGN_OFFSET units
+ from the top of the bounding box. This handles vertical alignment with
+ the cell. (The caller doesn't just reduce the bounding box size because
+ that would prevent the implementation from filling the entire cell with
+ the background color.) The implementation must handle horizontal
+ alignment itself. */
+ void (*draw_cell) (void *aux, const struct table_cell *cell, int color_idx,
+ int bb[TABLE_N_AXES][2], int valign_offset,
+ int spill[TABLE_N_AXES][2],
+ int clip[TABLE_N_AXES][2]);
+
+ /* Scales all output by FACTOR, e.g. a FACTOR of 0.5 would cause everything
+ subsequent to be drawn half-size. FACTOR will be greater than 0 and
+ less than or equal to 1.
+
+ Optional. If NULL, the rendering engine won't try to scale output. */
+ void (*scale) (void *aux, double factor);
};
-\f
-/* A "page" of content that is ready to be rendered.
-
- A page's size is not limited to the size passed in as part of render_params.
- Use render_pager (see below) to break a render_page into smaller
- render_pages that will fit in the available space. */
-struct render_page *render_page_create (const struct render_params *,
- const struct table *);
-
-struct render_page *render_page_ref (const struct render_page *);
-void render_page_unref (struct render_page *);
-\f
-/* An iterator for breaking render_pages into smaller chunks. */
-struct render_pager *render_pager_create (struct render_page *);
+/* An iterator for breaking render_pages into smaller chunks. */
+struct render_pager *render_pager_create (const struct render_params *,
+ const struct pivot_table *,
+ const size_t *layer_indexes);
void render_pager_destroy (struct render_pager *);
bool render_pager_has_next (const struct render_pager *);
void render_pager_draw (const struct render_pager *);
void render_pager_draw_region (const struct render_pager *,
int x, int y, int w, int h);
+
int render_pager_get_size (const struct render_pager *, enum table_axis);
int render_pager_get_best_breakpoint (const struct render_pager *, int height);
+bool render_direction_rtl (void);
+
+
#endif /* output/render.h */