From: Ben Pfaff Date: Sat, 8 May 2010 21:00:57 +0000 (-0700) Subject: output: Refactor Cairo output driver to make printing via GTK+ practical. X-Git-Tag: v0.7.5~32 X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=6071f2f1e380283d430a712c259ecd403f0ed410;p=pspp-builds.git output: Refactor Cairo output driver to make printing via GTK+ practical. --- diff --git a/src/output/cairo.c b/src/output/cairo.c index f049a305..a415e5bd 100644 --- a/src/output/cairo.c +++ b/src/output/cairo.c @@ -101,6 +101,18 @@ struct xr_font PangoFontMetrics *metrics; }; +/* An output item whose rendering is in progress. */ +struct xr_render_fsm + { + /* Renders as much of itself as it can on the current page. Returns true + if rendering is complete, false if the output item needs another + page. */ + bool (*render) (struct xr_render_fsm *, struct xr_driver *); + + /* Destroys the output item. */ + void (*destroy) (struct xr_render_fsm *); + }; + /* Cairo output driver. */ struct xr_driver { @@ -134,12 +146,14 @@ struct xr_driver cairo_t *cairo; int page_number; /* Current page number. */ int y; + struct xr_render_fsm *fsm; }; static const struct output_driver_class cairo_driver_class; -static void xr_show_page (struct xr_driver *); static void draw_headers (struct xr_driver *); +static void xr_driver_destroy_fsm (struct xr_driver *); +static void xr_driver_run_fsm (struct xr_driver *); static bool load_font (struct xr_driver *, struct xr_font *); static void free_font (struct xr_font *); @@ -153,8 +167,11 @@ static int xr_measure_cell_height (void *, const struct table_cell *, static void xr_draw_cell (void *, const struct table_cell *, int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2]); + +static struct xr_render_fsm *xr_render_output_item ( + struct xr_driver *, const struct output_item *); -/* Driver initialization. */ +/* Output driver basics. */ static struct xr_driver * xr_driver_cast (struct output_driver *driver) @@ -317,6 +334,8 @@ xr_create (const char *file_name, enum settings_output_devices device_type, goto error; } + draw_headers (xr); + return &xr->driver; error: @@ -351,13 +370,12 @@ xr_destroy (struct output_driver *driver) struct xr_driver *xr = xr_driver_cast (driver); size_t i; + xr_driver_destroy_fsm (xr); + if (xr->cairo != NULL) { cairo_status_t status; - if (xr->y > 0) - xr_show_page (xr); - cairo_surface_finish (cairo_get_target (xr->cairo)); status = cairo_status (xr->cairo); if (status != CAIRO_STATUS_SUCCESS) @@ -410,147 +428,83 @@ xr_render_table_item (struct xr_driver *xr, const struct table_item *item, } static void -xr_output_table_item (struct xr_driver *xr, - const struct table_item *table_item) +xr_submit (struct output_driver *driver, const struct output_item *output_item) { - struct render_break x_break; - struct render_page *page; - int caption_height; - - if (xr->y > 0) - xr->y += xr->font_height; + struct xr_driver *xr = xr_driver_cast (driver); - page = xr_render_table_item (xr, table_item, &caption_height); - xr->params->size[V] = xr->length - caption_height; - for (render_break_init (&x_break, page, H); - render_break_has_next (&x_break); ) + xr_driver_output_item (xr, output_item); + while (xr_driver_need_new_page (xr)) { - struct render_page *x_slice; - struct render_break y_break; - - x_slice = render_break_next (&x_break, xr->width); - for (render_break_init (&y_break, x_slice, V); - render_break_has_next (&y_break); ) - { - int space = xr->length - xr->y; - struct render_page *y_slice; + cairo_show_page (xr->cairo); + xr_driver_next_page (xr, xr->cairo); + } +} + +/* Functions for rendering a series of output items to a series of Cairo + contexts, with pagination, possibly including headers. - /* XXX doesn't allow for caption or space between segments */ - if (render_break_next_size (&y_break) > space) - { - assert (xr->y > 0); - xr_show_page (xr); - continue; - } + Used by PSPPIRE for printing, and by the basic Cairo output driver above as + its underlying implementation. - y_slice = render_break_next (&y_break, space); - if (caption_height) - { - struct table_cell cell; - int bb[TABLE_N_AXES][2]; + See the big comment in cairo.h for intended usage. */ - xr_init_caption_cell (table_item_get_caption (table_item), - &cell); - bb[H][0] = 0; - bb[H][1] = xr->width; - bb[V][0] = 0; - bb[V][1] = caption_height; - xr_draw_cell (xr, &cell, bb, bb); - xr->y += caption_height; - caption_height = 0; - } +/* Gives new page CAIRO to XR for output. CAIRO may be null to skip actually + rendering the page (which might be useful to find out how many pages an + output document has without actually rendering it). */ +void +xr_driver_next_page (struct xr_driver *xr, cairo_t *cairo) +{ + xr->page_number++; + xr->cairo = cairo; + xr->y = 0; + draw_headers (xr); + xr_driver_run_fsm (xr); +} - render_page_draw (y_slice); - xr->y += render_page_get_size (y_slice, V); - render_page_unref (y_slice); - } - render_break_destroy (&y_break); - } - render_break_destroy (&x_break); +/* Start rendering OUTPUT_ITEM to XR. Only valid if XR is not in the middle of + rendering a previous output item, that is, only if xr_driver_need_new_page() + returns false. */ +void +xr_driver_output_item (struct xr_driver *xr, + const struct output_item *output_item) +{ + assert (xr->fsm == NULL); + xr->fsm = xr_render_output_item (xr, output_item); + xr_driver_run_fsm (xr); } -static void -xr_output_text (struct xr_driver *xr, const char *text) +/* Returns true if XR is in the middle of rendering an output item and needs a + new page to be appended using xr_driver_next_page() to make progress, + otherwise false. */ +bool +xr_driver_need_new_page (const struct xr_driver *xr) { - struct table_item *table_item; + return xr->fsm != NULL; +} - table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL); - xr_output_table_item (xr, table_item); - table_item_unref (table_item); +/* Returns true if the current page doesn't have any content yet (besides + headers, if enabled). */ +bool +xr_driver_is_page_blank (const struct xr_driver *xr) +{ + return xr->y == 0; } static void -xr_submit (struct output_driver *driver, const struct output_item *output_item) +xr_driver_destroy_fsm (struct xr_driver *xr) { - struct xr_driver *xr = xr_driver_cast (driver); - if (is_table_item (output_item)) - xr_output_table_item (xr, to_table_item (output_item)); - else if (is_chart_item (output_item)) - { - if (xr->y > 0) - xr_show_page (xr); - xr_draw_chart (to_chart_item (output_item), xr->cairo, 0.0, 0.0, - xr_to_pt (xr->width), xr_to_pt (xr->length)); - xr_show_page (xr); - } - else if (is_text_item (output_item)) - { - const struct text_item *text_item = to_text_item (output_item); - enum text_item_type type = text_item_get_type (text_item); - const char *text = text_item_get_text (text_item); - - switch (type) - { - case TEXT_ITEM_TITLE: - free (xr->title); - xr->title = xstrdup (text); - break; - - case TEXT_ITEM_SUBTITLE: - free (xr->subtitle); - xr->subtitle = xstrdup (text); - break; - - case TEXT_ITEM_COMMAND_CLOSE: - break; - - case TEXT_ITEM_BLANK_LINE: - if (xr->y > 0) - xr->y += xr->font_height; - break; - - case TEXT_ITEM_EJECT_PAGE: - if (xr->y > 0) - xr_show_page (xr); - break; - - default: - xr_output_text (xr, text); - break; - } - } - else if (is_message_item (output_item)) + if (xr->fsm != NULL) { - const struct message_item *message_item = to_message_item (output_item); - const struct msg *msg = message_item_get_msg (message_item); - char *s = msg_to_string (msg, xr->command_name); - xr_output_text (xr, s); - free (s); + xr->fsm->destroy (xr->fsm); + xr->fsm = NULL; } } static void -xr_show_page (struct xr_driver *xr) +xr_driver_run_fsm (struct xr_driver *xr) { - if (xr->headers) - { - xr->y = 0; - draw_headers (xr); - } - cairo_show_page (xr->cairo); - - xr->page_number++; - xr->y = 0; + if (xr->fsm != NULL && !xr->fsm->render (xr->fsm, xr)) + xr_driver_destroy_fsm (xr); } static void @@ -778,9 +732,9 @@ draw_text (struct xr_driver *xr, const char *string, int x, int y, cell.contents = string; cell.options = options; bb[H][0] = x; - bb[V][0] = y; + bb[V][0] = y - xr->y; bb[H][1] = x + max_width; - bb[V][1] = xr->font_height; + bb[V][1] = xr->font_height - xr->y; xr_layout_cell (xr, &cell, bb, bb, PANGO_WRAP_WORD_CHAR, &w, &h); return w; } @@ -807,6 +761,9 @@ draw_headers (struct xr_driver *xr) int x0, x1; int y; + if (!xr->headers || xr->cairo == NULL) + return; + y = -3 * xr->font_height; x0 = xr->font_height / 2; x1 = xr->width - xr->font_height / 2; @@ -959,7 +916,7 @@ struct xr_rendering #define CHART_HEIGHT 375 struct xr_driver * -xr_create_driver (cairo_t *cairo, struct string_map *options) +xr_driver_create (cairo_t *cairo, struct string_map *options) { struct xr_driver *xr = xr_allocate ("cairo", 0, options); xr->width = INT_MAX / 8; @@ -1121,3 +1078,254 @@ xr_draw_png_chart (const struct chart_item *item, return file_name; } + +struct xr_table_state + { + struct xr_render_fsm fsm; + struct table_item *table_item; + struct render_break x_break; + struct render_break y_break; + int caption_height; + }; + +static bool +xr_table_render (struct xr_render_fsm *fsm, struct xr_driver *xr) +{ + struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm); + + for (;;) + { + struct render_page *y_slice; + int space; + + while (!render_break_has_next (&ts->y_break)) + { + struct render_page *x_slice; + + render_break_destroy (&ts->y_break); + if (!render_break_has_next (&ts->x_break)) + return false; + + x_slice = render_break_next (&ts->x_break, xr->width); + render_break_init (&ts->y_break, x_slice, V); + } + + space = xr->length - xr->y; + if (render_break_next_size (&ts->y_break) > space) + { + assert (xr->y > 0); + return true; + } + + y_slice = render_break_next (&ts->y_break, space); + if (ts->caption_height) + { + if (xr->cairo) + { + struct table_cell cell; + int bb[TABLE_N_AXES][2]; + + xr_init_caption_cell (table_item_get_caption (ts->table_item), + &cell); + bb[H][0] = 0; + bb[H][1] = xr->width; + bb[V][0] = 0; + bb[V][1] = ts->caption_height; + xr_draw_cell (xr, &cell, bb, bb); + } + xr->y += ts->caption_height; + ts->caption_height = 0; + } + + if (xr->cairo) + render_page_draw (y_slice); + xr->y += render_page_get_size (y_slice, V); + render_page_unref (y_slice); + } +} + +static void +xr_table_destroy (struct xr_render_fsm *fsm) +{ + struct xr_table_state *ts = UP_CAST (fsm, struct xr_table_state, fsm); + + table_item_unref (ts->table_item); + render_break_destroy (&ts->x_break); + render_break_destroy (&ts->y_break); + free (ts); +} + +static struct xr_render_fsm * +xr_render_table (struct xr_driver *xr, const struct table_item *table_item) +{ + struct xr_table_state *ts; + struct render_page *page; + + ts = xmalloc (sizeof *ts); + ts->fsm.render = xr_table_render; + ts->fsm.destroy = xr_table_destroy; + ts->table_item = table_item_ref (table_item); + + if (xr->y > 0) + xr->y += xr->font_height; + + page = xr_render_table_item (xr, table_item, &ts->caption_height); + xr->params->size[V] = xr->length - ts->caption_height; + + render_break_init (&ts->x_break, page, H); + render_break_init_empty (&ts->y_break); + + return &ts->fsm; +} + +struct xr_chart_state + { + struct xr_render_fsm fsm; + struct chart_item *chart_item; + }; + +static bool +xr_chart_render (struct xr_render_fsm *fsm, struct xr_driver *xr) +{ + struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm); + + if (xr->y > 0) + return true; + + if (xr->cairo != NULL) + xr_draw_chart (cs->chart_item, xr->cairo, 0.0, 0.0, + xr_to_pt (xr->width), xr_to_pt (xr->length)); + xr->y = xr->length; + + return false; +} + +static void +xr_chart_destroy (struct xr_render_fsm *fsm) +{ + struct xr_chart_state *cs = UP_CAST (fsm, struct xr_chart_state, fsm); + + chart_item_unref (cs->chart_item); + free (cs); +} + +static struct xr_render_fsm * +xr_render_chart (const struct chart_item *chart_item) +{ + struct xr_chart_state *cs; + + cs = xmalloc (sizeof *cs); + cs->fsm.render = xr_chart_render; + cs->fsm.destroy = xr_chart_destroy; + cs->chart_item = chart_item_ref (chart_item); + + return &cs->fsm; +} + +static bool +xr_eject_render (struct xr_render_fsm *fsm UNUSED, struct xr_driver *xr) +{ + return xr->y > 0; +} + +static void +xr_eject_destroy (struct xr_render_fsm *fsm UNUSED) +{ + /* Nothing to do. */ +} + +static struct xr_render_fsm * +xr_render_eject (void) +{ + static struct xr_render_fsm eject_renderer = + { + xr_eject_render, + xr_eject_destroy + }; + + return &eject_renderer; +} + +static struct xr_render_fsm * +xr_create_text_renderer (struct xr_driver *xr, const char *text) +{ + struct table_item *table_item; + struct xr_render_fsm *fsm; + + table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL); + fsm = xr_render_table (xr, table_item); + table_item_unref (table_item); + + return fsm; +} + +static struct xr_render_fsm * +xr_render_text (struct xr_driver *xr, const struct text_item *text_item) +{ + enum text_item_type type = text_item_get_type (text_item); + const char *text = text_item_get_text (text_item); + + switch (type) + { + case TEXT_ITEM_TITLE: + free (xr->title); + xr->title = xstrdup (text); + draw_headers (xr); + break; + + case TEXT_ITEM_SUBTITLE: + free (xr->subtitle); + xr->subtitle = xstrdup (text); + draw_headers (xr); + break; + + case TEXT_ITEM_COMMAND_CLOSE: + break; + + case TEXT_ITEM_BLANK_LINE: + if (xr->y > 0) + xr->y += xr->font_height; + break; + + case TEXT_ITEM_EJECT_PAGE: + if (xr->y > 0) + return xr_render_eject (); + break; + + default: + return xr_create_text_renderer (xr, text); + } + + return NULL; +} + +static struct xr_render_fsm * +xr_render_message (struct xr_driver *xr, + const struct message_item *message_item) +{ + const struct msg *msg = message_item_get_msg (message_item); + struct xr_render_fsm *fsm; + char *s; + + s = msg_to_string (msg, xr->command_name); + fsm = xr_create_text_renderer (xr, s); + free (s); + + return fsm; +} + +static struct xr_render_fsm * +xr_render_output_item (struct xr_driver *xr, + const struct output_item *output_item) +{ + if (is_table_item (output_item)) + return xr_render_table (xr, to_table_item (output_item)); + else if (is_chart_item (output_item)) + return xr_render_chart (to_chart_item (output_item)); + else if (is_text_item (output_item)) + return xr_render_text (xr, to_text_item (output_item)); + else if (is_message_item (output_item)) + return xr_render_message (xr, to_message_item (output_item)); + else + return NULL; +} diff --git a/src/output/cairo.h b/src/output/cairo.h index 6fe32733..77889d11 100644 --- a/src/output/cairo.h +++ b/src/output/cairo.h @@ -17,6 +17,8 @@ #ifndef OUTPUT_CAIRO_H #define OUTPUT_CAIRO_H 1 +#include + #ifdef HAVE_CAIRO #include @@ -25,14 +27,57 @@ struct chart_item; struct output_item; struct string_map; -/* Used by PSPPIRE to render in the GUI. */ -struct xr_driver *xr_create_driver (cairo_t *, struct string_map *options); +/* Creating and destroying Cairo output drivers. */ +struct xr_driver *xr_driver_create (cairo_t *, struct string_map *options); +void xr_driver_destroy (struct xr_driver *); + +/* Functions for rendering a single output item to a Cairo context. + Output items are never broken across multiple pages. + Used by PSPPIRE to render in the GUI. */ struct xr_rendering *xr_rendering_create (struct xr_driver *, const struct output_item *, cairo_t *); void xr_rendering_measure (struct xr_rendering *, int *w, int *h); void xr_rendering_draw (struct xr_rendering *, cairo_t *); +/* Functions for rendering a series of output items to a series of Cairo + contexts, with pagination, possibly including headers. + + The intended usage pattern is this: + + * Create an xr_driver with xr_driver_create(). The cairo_t passed in must + accurately reflect the properties of the output (e.g. for the purpose of + page size and font selection) but need not be used for rendering. + + * Call xr_driver_next_page() to set up the first real output page's + cairo_t. (You can skip this step if the cairo_t passed to + xr_driver_create() can be used.) + + * Then, for each output_item: + + - Pass the output item to xr_driver_output_item(). As much output as + fits will be rendered on the current page. + + - Then, as long as xr_driver_need_new_page() returns true, obtain a new + page for rendering and pass it to xr_driver_next_page(). As much + output as fits on the new page will be rendered on it. + + * When you're done, destroy the output driver with xr_driver_destroy(). + + These functions may also be used for counting pages without actually + rendering output. Follow the same steps, except pass NULL as the cairo_t to + xr_driver_next_page(). (But xr_driver_create() still needs a valid cairo_t + for page setup.) + + (If the cairo_t that you pass to xr_driver_create() won't remain valid, be + sure to clear it out one way or another before calling xr_driver_destroy(), + so that xr_driver_destroy() won't destroy it itself.) +*/ +void xr_driver_next_page (struct xr_driver *, cairo_t *); +void xr_driver_output_item (struct xr_driver *, const struct output_item *); +bool xr_driver_need_new_page (const struct xr_driver *); +bool xr_driver_is_page_blank (const struct xr_driver *); + /* Render charts with Cairo. */ void xr_draw_chart (const struct chart_item *, cairo_t *, double x, double y, double width, double height); diff --git a/src/output/render.c b/src/output/render.c index 05db149a..1b92b8bb 100644 --- a/src/output/render.c +++ b/src/output/render.c @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2009 Free Software Foundation, Inc. + Copyright (C) 2009, 2010 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -955,6 +955,18 @@ render_break_init (struct render_break *b, struct render_page *page, b->hw = headers_width (page, axis); } +/* Initializes B as a render_break structure for which + render_break_has_next() always returns false. */ +void +render_break_init_empty (struct render_break *b) +{ + b->page = NULL; + b->axis = TABLE_HORZ; + b->cell = 0; + b->pixel = 0; + b->hw = 0; +} + /* Frees B and unrefs the render_page that it owns. */ void render_break_destroy (struct render_break *b) @@ -971,7 +983,7 @@ render_break_has_next (const struct render_break *b) const struct render_page *page = b->page; enum table_axis axis = b->axis; - return b->cell < page->n[axis] - page->h[axis][1]; + return page != NULL && b->cell < page->n[axis] - page->h[axis][1]; } /* Returns the minimum SIZE argument that, if passed to render_break_next(), diff --git a/src/output/render.h b/src/output/render.h index cfba52e9..af779843 100644 --- a/src/output/render.h +++ b/src/output/render.h @@ -1,5 +1,5 @@ /* PSPP - a program for statistical analysis. - Copyright (C) 2009 Free Software Foundation, Inc. + Copyright (C) 2009, 2010 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -106,6 +106,7 @@ struct render_break void render_break_init (struct render_break *, struct render_page *, enum table_axis); +void render_break_init_empty (struct render_break *); void render_break_destroy (struct render_break *); bool render_break_has_next (const struct render_break *); diff --git a/src/ui/gui/psppire-output-window.c b/src/ui/gui/psppire-output-window.c index 3003fba8..440df86a 100644 --- a/src/ui/gui/psppire-output-window.c +++ b/src/ui/gui/psppire-output-window.c @@ -235,7 +235,7 @@ psppire_output_submit (struct output_driver *this, g_free (font_name); pango_font_description_free (font_desc); - pod->xr = xr_create_driver (cr, &options); + pod->xr = xr_driver_create (cr, &options); string_map_destroy (&options); }