/* PSPP - a program for statistical analysis.
- Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 2009, 2010, 2011 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
int line_space; /* Space between lines. */
int line_width; /* Width of lines. */
+ double bg_red, bg_green, bg_blue; /* Background color */
+ double fg_red, fg_green, fg_blue; /* Foreground color */
+
/* Internal state. */
struct render_params *params;
int char_width, char_height;
return driver_option_get (d, options, key, default_value);
}
+/* Parse color information specified by KEY into {RED,GREEN,BLUE}.
+ Currently, the input string must be of the form "#RRRRGGGGBBBB"
+ Future implementations might allow things like "yellow" and
+ "sky-blue-ultra-brown"
+*/
+static void
+parse_color (struct output_driver *d, struct string_map *options,
+ const char *key, const char *default_value,
+ double *dred, double *dgreen, double *dblue)
+{
+ int red, green, blue;
+ char *string = parse_string (opt (d, options, key, default_value));
+
+ if (3 != sscanf (string, "#%04x%04x%04x", &red, &green, &blue))
+ {
+ /* If the parsed option string fails, then try the default value */
+ if ( 3 != sscanf (default_value, "#%04x%04x%04x", &red, &green, &blue))
+ {
+ /* ... and if that fails set everything to zero */
+ red = green = blue = 0;
+ }
+ }
+
+ /* Convert 16 bit ints to float */
+ *dred = red / (double) 0xFFFF;
+ *dgreen = green / (double) 0xFFFF;
+ *dblue = blue / (double) 0xFFFF;
+}
+
static PangoFontDescription *
parse_font (struct output_driver *d, struct string_map *options,
const char *key, const char *default_value,
return desc;
}
-static struct xr_driver *
-xr_allocate (const char *name, int device_type, struct string_map *o)
+
+static void
+apply_options (struct xr_driver *xr, struct string_map *o)
{
- int paper_width, paper_length;
- struct output_driver *d;
- struct xr_driver *xr;
- int font_points;
+ struct output_driver *d = &xr->driver;
- xr = xzalloc (sizeof *xr);
- d = &xr->driver;
- output_driver_init (d, &cairo_driver_class, name, device_type);
+ int paper_width, paper_length;
- font_points = parse_int (opt (d, o, "font-size", "10000"),
- 1000, 1000000);
+ int font_points = parse_int (opt (d, o, "font-size", "10000"), 1000, 1000000);
xr->fonts[XR_FONT_FIXED].desc = parse_font (d, o, "fixed-font", "monospace",
font_points);
xr->fonts[XR_FONT_PROPORTIONAL].desc = parse_font (d, o, "prop-font",
xr->line_width = XR_POINT / 2;
xr->page_number = 0;
+ parse_color (d, o, "background-color", "#FFFFFFFFFFFF", &xr->bg_red, &xr->bg_green, &xr->bg_blue);
+ parse_color (d, o, "foreground-color", "#000000000000", &xr->fg_red, &xr->fg_green, &xr->fg_blue);
+
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->width = paper_width - xr->left_margin - xr->right_margin;
xr->length = paper_length - xr->top_margin - xr->bottom_margin;
+}
+
+static struct xr_driver *
+xr_allocate (const char *name, int device_type, struct string_map *o)
+{
+ struct xr_driver *xr = xzalloc (sizeof *xr);
+ struct output_driver *d = &xr->driver;
+
+ output_driver_init (d, &cairo_driver_class, name, device_type);
+
+ apply_options (xr, o);
return xr;
}
}
}
+ cairo_set_source_rgb (xr->cairo, xr->fg_red, xr->fg_green, xr->fg_blue);
+
return true;
}
static struct render_page *
xr_render_table_item (struct xr_driver *xr, const struct table_item *item,
- int *caption_heightp)
+ int *caption_widthp, int *caption_heightp)
{
const char *caption = table_item_get_caption (item);
if (caption != NULL)
{
/* XXX doesn't do well with very large captions */
+ int min_width, max_width;
struct table_cell cell;
+
xr_init_caption_cell (caption, &cell);
- *caption_heightp = xr_measure_cell_height (xr, &cell, xr->width);
+
+ xr_measure_cell_width (xr, &cell, &min_width, &max_width);
+ *caption_widthp = MIN (max_width, xr->width);
+ *caption_heightp = xr_measure_cell_height (xr, &cell, *caption_widthp);
}
else
*caption_heightp = 0;
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));
+ {
+ cairo_save (cairo);
+ cairo_set_source_rgb (cairo, xr->bg_red, xr->bg_green, xr->bg_blue);
+ cairo_rectangle (cairo, 0, 0, xr->width, xr->length);
+ cairo_fill (cairo);
+ cairo_restore (cairo);
+
+ cairo_translate (cairo,
+ xr_to_pt (xr->left_margin),
+ xr_to_pt (xr->top_margin));
+ }
xr->page_number++;
xr->cairo = cairo;
}
static void
-xr_draw_title (struct xr_driver *xr, const char *title, int title_height)
+xr_draw_title (struct xr_driver *xr, const char *title,
+ int title_width, int title_height)
{
struct table_cell cell;
int bb[TABLE_N_AXES][2];
xr_init_caption_cell (title, &cell);
bb[H][0] = 0;
- bb[H][1] = xr->width;
+ bb[H][1] = title_width;
bb[V][0] = 0;
bb[V][1] = title_height;
xr_draw_cell (xr, &cell, bb, bb);
/* Table items. */
struct render_page *page;
struct xr_driver *xr;
+ int title_width;
int title_height;
};
#define CHART_WIDTH 500
#define CHART_HEIGHT 375
+
+
struct xr_driver *
xr_driver_create (cairo_t *cairo, struct string_map *options)
{
struct table_item *table_item;
struct xr_rendering *r;
- table_item = table_item_create (table_from_string (0, text), NULL);
+ table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL);
r = xr_rendering_create (xr, &table_item->output_item, cr);
table_item_unref (table_item);
return r;
}
+void
+xr_rendering_apply_options (struct xr_rendering *xr, struct string_map *o)
+{
+ apply_options (xr->xr, o);
+}
+
struct xr_rendering *
xr_rendering_create (struct xr_driver *xr, const struct output_item *item,
cairo_t *cr)
r->xr = xr;
xr_set_cairo (xr, cr);
r->page = xr_render_table_item (xr, to_table_item (item),
- &r->title_height);
+ &r->title_width, &r->title_height);
}
else if (is_chart_item (item))
{
r = xzalloc (sizeof *r);
r->item = output_item_ref (item);
+ r->xr = xr;
+ xr_set_cairo (xr, cr);
}
return r;
{
if (is_table_item (r->item))
{
- *w = render_page_get_size (r->page, H) / 1024;
+ int w0 = render_page_get_size (r->page, H);
+ int w1 = r->title_width;
+ *w = MAX (w0, w1) / 1024;
*h = (render_page_get_size (r->page, V) + r->title_height) / 1024;
}
else
}
}
+static void xr_draw_chart (const struct chart_item *, cairo_t *,
+ double x, double y, double width, double height);
+
/* Draws onto CR at least the region of R that is enclosed in (X,Y)-(X+W,Y+H),
and possibly some additional parts. */
void
{
xr->y = 0;
xr_draw_title (xr, table_item_get_caption (to_table_item (r->item)),
- r->title_height);
+ r->title_width, r->title_height);
}
xr->y = r->title_height;
- render_page_draw_region (r->page,
- x * 1024, y * 1024, w * 1024, h * 1024);
+ render_page_draw_region (r->page, x * 1024, (y * 1024) - r->title_height,
+ w * 1024, h * 1024);
}
else
xr_draw_chart (to_chart_item (r->item), cr,
0, 0, CHART_WIDTH, CHART_HEIGHT);
}
-void
+static void
xr_draw_chart (const struct chart_item *chart_item, cairo_t *cr,
double x, double y, double width, double height)
{
surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, length);
cr = cairo_create (surface);
- cairo_save (cr);
- cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
- cairo_rectangle (cr, 0, 0, width, length);
- cairo_fill (cr);
- cairo_restore (cr);
-
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
xr_draw_chart (item, cr, 0.0, 0.0, width, length);
{
if (xr->cairo)
xr_draw_title (xr, table_item_get_caption (ts->table_item),
- ts->caption_height);
+ xr->width, ts->caption_height);
xr->y += ts->caption_height;
ts->caption_height = 0;
{
struct xr_table_state *ts;
struct render_page *page;
+ int caption_width;
ts = xmalloc (sizeof *ts);
ts->fsm.render = xr_table_render;
if (xr->y > 0)
xr->y += xr->char_height;
- page = xr_render_table_item (xr, table_item, &ts->caption_height);
+ page = xr_render_table_item (xr, table_item,
+ &caption_width, &ts->caption_height);
xr->params->size[V] = xr->length - ts->caption_height;
render_break_init (&ts->x_break, page, H);
projects / pspp-builds.git / blobdiff