From: Ben Pfaff Date: Wed, 19 May 2010 05:05:52 +0000 (-0700) Subject: Merge "paginate" branch into "master". X-Git-Tag: v0.7.5~25 X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=e4ef4d0f708651807d91bd92d7ab92c1b5c6d675;hp=031e760d10384ce4ad28484d1eb55e5d50496cf8;p=pspp-builds.git Merge "paginate" branch into "master". This adds printing support to the PSPPIRE output viewer on the master branch. --- diff --git a/src/output/cairo.c b/src/output/cairo.c index 977a4144..a1445bcf 100644 --- a/src/output/cairo.c +++ b/src/output/cairo.c @@ -16,31 +16,31 @@ #include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "output/cairo.h" + +#include "libpspp/assertion.h" +#include "libpspp/cast.h" +#include "libpspp/message.h" +#include "libpspp/start-date.h" +#include "libpspp/str.h" +#include "libpspp/string-map.h" +#include "libpspp/version.h" +#include "output/cairo-chart.h" +#include "output/chart-item-provider.h" +#include "output/charts/boxplot.h" +#include "output/charts/np-plot.h" +#include "output/charts/piechart.h" +#include "output/charts/plot-hist.h" +#include "output/charts/roc-chart.h" +#include "output/charts/scree.h" +#include "output/driver-provider.h" +#include "output/message-item.h" +#include "output/options.h" +#include "output/render.h" +#include "output/tab.h" +#include "output/table-item.h" +#include "output/table.h" +#include "output/text-item.h" #include #include @@ -52,10 +52,10 @@ #include #include -#include "error.h" -#include "intprops.h" -#include "minmax.h" -#include "xalloc.h" +#include "gl/error.h" +#include "gl/intprops.h" +#include "gl/minmax.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) @@ -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 { @@ -124,8 +136,6 @@ struct xr_driver int line_space; /* Space between lines. */ int line_width; /* Width of lines. */ - enum xr_output_type file_type; /* Type of output file. */ - /* Internal state. */ struct render_params *params; char *command_name; @@ -134,12 +144,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 +165,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) @@ -173,13 +188,13 @@ opt (struct output_driver *d, struct string_map *options, const char *key, static struct xr_driver * xr_allocate (const char *name, int device_type, struct string_map *o) { + int paper_width, paper_length; struct output_driver *d; struct xr_driver *xr; xr = xzalloc (sizeof *xr); d = &xr->driver; output_driver_init (d, &cairo_driver_class, name, device_type); - xr->headers = true; xr->font_height = XR_POINT * 10; xr->fonts[XR_FONT_FIXED].string = parse_string (opt (d, o, "fixed-font", "monospace")); @@ -190,7 +205,20 @@ xr_allocate (const char *name, int device_type, struct string_map *o) xr->line_gutter = XR_POINT; xr->line_space = XR_POINT; xr->line_width = XR_POINT / 2; - xr->page_number = 1; + xr->page_number = 0; + + xr->headers = parse_boolean (opt (d, o, "headers", "true")); + + parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length); + xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in")); + xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in")); + xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in")); + xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in")); + + if (xr->headers) + xr->top_margin += 3 * xr->font_height; + xr->width = paper_width - xr->left_margin - xr->right_margin; + xr->length = paper_length - xr->top_margin - xr->bottom_margin; return xr; } @@ -246,33 +274,17 @@ xr_create (const char *file_name, enum settings_output_devices device_type, cairo_surface_t *surface; cairo_status_t status; double width_pt, length_pt; - int paper_width, paper_length; xr = xr_allocate (file_name, device_type, o); d = &xr->driver; - xr->headers = parse_boolean (opt (d, o, "headers", "true")); - - xr->file_type = file_type; - - parse_paper_size (opt (d, o, "paper-size", ""), &paper_width, &paper_length); - xr->left_margin = parse_dimension (opt (d, o, "left-margin", ".5in")); - xr->right_margin = parse_dimension (opt (d, o, "right-margin", ".5in")); - xr->top_margin = parse_dimension (opt (d, o, "top-margin", ".5in")); - xr->bottom_margin = parse_dimension (opt (d, o, "bottom-margin", ".5in")); - - if (xr->headers) - xr->top_margin += 3 * xr->font_height; - xr->width = paper_width - xr->left_margin - xr->right_margin; - xr->length = paper_length - xr->top_margin - xr->bottom_margin; - - width_pt = paper_width / 1000.0; - length_pt = paper_length / 1000.0; - if (xr->file_type == XR_PDF) + width_pt = (xr->width + xr->left_margin + xr->right_margin) / 1000.0; + length_pt = (xr->length + xr->top_margin + xr->bottom_margin) / 1000.0; + if (file_type == XR_PDF) surface = cairo_pdf_surface_create (file_name, width_pt, length_pt); - else if (xr->file_type == XR_PS) + else if (file_type == XR_PS) surface = cairo_ps_surface_create (file_name, width_pt, length_pt); - else if (xr->file_type == XR_SVG) + else if (file_type == XR_SVG) surface = cairo_svg_surface_create (file_name, width_pt, length_pt); else NOT_REACHED (); @@ -289,13 +301,12 @@ xr_create (const char *file_name, enum settings_output_devices device_type, xr->cairo = cairo_create (surface); cairo_surface_destroy (surface); - cairo_translate (xr->cairo, - xr_to_pt (xr->left_margin), - xr_to_pt (xr->top_margin)); - if (!xr_set_cairo (xr, xr->cairo)) goto error; + cairo_save (xr->cairo); + xr_driver_next_page (xr, xr->cairo); + if (xr->width / (xr->font_height / 2) < MIN_WIDTH) { error (0, 0, _("The defined page is not wide enough to hold at least %d " @@ -317,6 +328,8 @@ xr_create (const char *file_name, enum settings_output_devices device_type, goto error; } + draw_headers (xr); + return &xr->driver; error: @@ -351,13 +364,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 +422,90 @@ 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; + cairo_restore (xr->cairo); + cairo_show_page (xr->cairo); + cairo_save (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. - 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; + Used by PSPPIRE for printing, and by the basic Cairo output driver above as + its underlying implementation. - /* 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; - } + See the big comment in cairo.h for intended usage. */ - y_slice = render_break_next (&y_break, space); - if (caption_height) - { - struct table_cell cell; - int bb[TABLE_N_AXES][2]; +/* 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) +{ + if (cairo != NULL) + cairo_translate (cairo, + xr_to_pt (xr->left_margin), + xr_to_pt (xr->top_margin)); - 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; - } + 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->fsm != NULL) { - 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)) - { - 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 +733,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 +762,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,11 +917,9 @@ 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; - xr->length = INT_MAX / 8; if (!xr_set_cairo (xr, cairo)) { output_driver_destroy (&xr->driver); @@ -1121,3 +1077,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/output-viewer.ui b/src/ui/gui/output-viewer.ui index e664a6d9..3325e2ab 100644 --- a/src/ui/gui/output-viewer.ui +++ b/src/ui/gui/output-viewer.ui @@ -9,6 +9,12 @@ _File + + + file_print + _Print + + file_export @@ -45,6 +51,7 @@ + diff --git a/src/ui/gui/psppire-output-window.c b/src/ui/gui/psppire-output-window.c index f78b8855..5c5610a0 100644 --- a/src/ui/gui/psppire-output-window.c +++ b/src/ui/gui/psppire-output-window.c @@ -110,6 +110,8 @@ psppire_output_window_dispose (GObject *obj) viewer->items = NULL; viewer->n_items = viewer->allocated_items = 0; + g_object_unref (viewer->print_settings); + /* Chain up to the parent class */ G_OBJECT_CLASS (parent_class)->dispose (obj); } @@ -235,7 +237,19 @@ psppire_output_submit (struct output_driver *this, g_free (font_name); pango_font_description_free (font_desc); - pod->xr = xr_create_driver (cr, &options); + /* Pretend that the "page" has a reasonable width and a very big length, + so that most tables can be conveniently viewed on-screen with vertical + scrolling only. (The length should not be increased very much because + it is already close enough to INT_MAX when expressed as thousands of a + point.) */ + string_map_insert (&options, "paper-size", "300x200000mm"); + string_map_insert (&options, "headers", "off"); + string_map_insert (&options, "left-margin", "0"); + string_map_insert (&options, "right-margin", "0"); + string_map_insert (&options, "top-margin", "0"); + string_map_insert (&options, "bottom-margin", "0"); + + pod->xr = xr_driver_create (cr, &options); string_map_destroy (&options); } @@ -396,6 +410,9 @@ on_row_activate (GtkTreeView *overview, gtk_adjustment_set_value (vadj, y); } +static void psppire_output_window_print (PsppireOutputWindow *window); + + static GtkFileFilter * add_filter (GtkFileChooser *chooser, const char *name, const char *pattern) { @@ -569,6 +586,10 @@ psppire_output_window_init (PsppireOutputWindow *window) g_signal_connect_swapped (get_action_assert (xml, "file_export"), "activate", G_CALLBACK (psppire_output_window_export), window); + + g_signal_connect_swapped (get_action_assert (xml, "file_print"), "activate", + G_CALLBACK (psppire_output_window_print), window); + g_object_unref (xml); g_signal_connect (window, "delete-event", @@ -584,3 +605,153 @@ psppire_output_window_new (void) "description", _("Output Viewer"), NULL)); } + + + +static void +create_xr_print_driver (GtkPrintContext *context, PsppireOutputWindow *window) +{ + struct string_map options; + GtkPageSetup *page_setup; + double width, height; + double left_margin; + double right_margin; + double top_margin; + double bottom_margin; + + page_setup = gtk_print_context_get_page_setup (context); + width = gtk_page_setup_get_paper_width (page_setup, GTK_UNIT_MM); + height = gtk_page_setup_get_paper_height (page_setup, GTK_UNIT_MM); + left_margin = gtk_page_setup_get_left_margin (page_setup, GTK_UNIT_MM); + right_margin = gtk_page_setup_get_right_margin (page_setup, GTK_UNIT_MM); + top_margin = gtk_page_setup_get_top_margin (page_setup, GTK_UNIT_MM); + bottom_margin = gtk_page_setup_get_bottom_margin (page_setup, GTK_UNIT_MM); + + string_map_init (&options); + string_map_insert_nocopy (&options, xstrdup ("paper-size"), + xasprintf("%.2fx%.2fmm", width, height)); + string_map_insert_nocopy (&options, xstrdup ("left-margin"), + xasprintf ("%.2fmm", left_margin)); + string_map_insert_nocopy (&options, xstrdup ("right-margin"), + xasprintf ("%.2fmm", right_margin)); + string_map_insert_nocopy (&options, xstrdup ("top-margin"), + xasprintf ("%.2fmm", top_margin)); + string_map_insert_nocopy (&options, xstrdup ("bottom-margin"), + xasprintf ("%.2fmm", bottom_margin)); + + window->print_xrd = + xr_driver_create (gtk_print_context_get_cairo_context (context), &options); + + string_map_destroy (&options); +} + +static gboolean +paginate (GtkPrintOperation *operation, + GtkPrintContext *context, + PsppireOutputWindow *window) +{ + g_print ("%s\n", __FUNCTION__); + + if ( window->print_item < window->n_items ) + { + g_print ("Passing item %d\n", window->print_item); + xr_driver_output_item (window->print_xrd, window->items[window->print_item++]); + bool x = xr_driver_need_new_page (window->print_xrd); + if ( x ) + { + g_print ("Need new page: %d\n", x); + xr_driver_next_page (window->print_xrd, NULL); + window->print_n_pages ++; + } + return FALSE; + } + else + { + g_print ("Number of pages is %d\n", window->print_n_pages); + gtk_print_operation_set_n_pages (operation, window->print_n_pages); + window->print_item = 0; + + create_xr_print_driver (context, window); + + return TRUE; + } +} + +static void +begin_print (GtkPrintOperation *operation, + GtkPrintContext *context, + PsppireOutputWindow *window) +{ + g_print ("%s\n", __FUNCTION__); + + create_xr_print_driver (context, window); + + window->print_item = 0; + window->print_n_pages = 1; +} + +static void +end_print (GtkPrintOperation *operation, + GtkPrintContext *context, + PsppireOutputWindow *window) +{ + g_print ("%s\n", __FUNCTION__); + // xr_driver_destroy (window->print_xrd); +} + +static void +done (GtkPrintOperation *operation, + GtkPrintOperationResult result, + gpointer user_data) +{ + g_print ("%s %d\n", __FUNCTION__, result); +} + + +static void +draw_page (GtkPrintOperation *operation, + GtkPrintContext *context, + gint page_number, + PsppireOutputWindow *window) +{ + g_print ("%s: %d\n", __FUNCTION__, page_number); + + xr_driver_next_page (window->print_xrd, gtk_print_context_get_cairo_context (context)); + while ( window->print_item < window->n_items) + { + xr_driver_output_item (window->print_xrd, window->items [window->print_item++]); + if ( xr_driver_need_new_page (window->print_xrd) ) + break; + } +} + + +static void +psppire_output_window_print (PsppireOutputWindow *window) +{ + GtkPrintOperationResult res; + + GtkPrintOperation *print = gtk_print_operation_new (); + + if (window->print_settings != NULL) + gtk_print_operation_set_print_settings (print, window->print_settings); + + g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), window); + g_signal_connect (print, "end_print", G_CALLBACK (end_print), window); + g_signal_connect (print, "paginate", G_CALLBACK (paginate), window); + g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), window); + g_signal_connect (print, "done", G_CALLBACK (done), window); + + res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG, + GTK_WINDOW (window), NULL); + + if (res == GTK_PRINT_OPERATION_RESULT_APPLY) + { + if (window->print_settings != NULL) + g_object_unref (window->print_settings); + window->print_settings = g_object_ref (gtk_print_operation_get_print_settings (print)); + + } + + g_object_unref (print); +} diff --git a/src/ui/gui/psppire-output-window.h b/src/ui/gui/psppire-output-window.h index 95deed93..c242e732 100644 --- a/src/ui/gui/psppire-output-window.h +++ b/src/ui/gui/psppire-output-window.h @@ -63,6 +63,12 @@ struct _PsppireOutputWindow struct output_item **items; size_t n_items, allocated_items; + + /* Variables pertaining to printing */ + GtkPrintSettings *print_settings; + struct xr_driver *print_xrd; + int print_item; + int print_n_pages; }; struct _PsppireOutputWindowClass