pintos-os.org Git - pspp/blob - src/output/table.h

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2009, 2013, 2014 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #ifndef OUTPUT_TABLE_H
  18 #define OUTPUT_TABLE_H 1
  19
  20 /* Tables.
  21
  22 .  A table is a rectangular grid of cells.  Cells can be joined to form larger
  23    cells.  Rows and columns can be separated by rules of various types.  Rows
  24    at the top and bottom of a table and columns at the left and right edges of
  25    a table can be designated as headers, which means that if the table must be
  26    broken across more than one page, those rows or columns are repeated on each
  27    page.
  28
  29    A table is not itself an output_item, and thus a table cannot by itself be
  30    used for output, but they can be embedded inside struct table_item (see
  31    table-item.h) for that purpose. */
  32
  33 #include <stdbool.h>
  34 #include <stdint.h>
  35 #include <stddef.h>
  36 #include "libpspp/compiler.h"
  37
  38 struct casereader;
  39 struct fmt_spec;
  40 struct pool;
  41 struct table_item;
  42 struct variable;
  43
  44 /* A table axis.
  45
  46    Many table-related declarations use 2-element arrays in place of "x" and "y"
  47    variables.  This reduces code duplication significantly, because much table
  48    code treats rows and columns the same way.
  49
  50    A lot of code that uses these enumerations assumes that the two values are 0
  51    and 1, so don't change them to other values. */
  52 enum table_axis
  53   {
  54     TABLE_HORZ,
  55     TABLE_VERT
  56 #define TABLE_N_AXES 2
  57   };
  58
  59 struct cell_color
  60   {
  61     uint8_t alpha, r, g, b;
  62   };
  63
  64 #define CELL_COLOR(r, g, b) { 255, r, g, b }
  65 #define CELL_COLOR_BLACK CELL_COLOR (0, 0, 0)
  66 #define CELL_COLOR_WHITE CELL_COLOR (255, 255, 255)
  67
  68 static inline bool
  69 cell_color_equal (const struct cell_color *a, const struct cell_color *b)
  70 {
  71   return a->alpha == b->alpha && a->r == b->r && a->g == b->g && a->b == b->b;
  72 }
  73
  74 void cell_color_dump (const struct cell_color *);
  75
  76 enum table_stroke
  77   {
  78     TABLE_STROKE_NONE,
  79     TABLE_STROKE_SOLID,
  80     TABLE_STROKE_DASHED,
  81     TABLE_STROKE_THICK,
  82     TABLE_STROKE_THIN,
  83     TABLE_STROKE_DOUBLE,
  84     TABLE_N_STROKES,
  85   };
  86
  87 const char *table_stroke_to_string (enum table_stroke);
  88
  89 struct table_border_style
  90   {
  91     enum table_stroke stroke;
  92     struct cell_color color;
  93   };
  94
  95 #define TABLE_BORDER_STYLE_INITIALIZER { TABLE_STROKE_SOLID, CELL_COLOR_BLACK }
  96
  97 enum table_halign
  98   {
  99     TABLE_HALIGN_RIGHT,
 100     TABLE_HALIGN_LEFT,
 101     TABLE_HALIGN_CENTER,
 102     TABLE_HALIGN_MIXED,
 103     TABLE_HALIGN_DECIMAL
 104   };
 105
 106 const char *table_halign_to_string (enum table_halign);
 107
 108 enum table_valign
 109   {
 110     TABLE_VALIGN_TOP,
 111     TABLE_VALIGN_CENTER,
 112     TABLE_VALIGN_BOTTOM,
 113   };
 114
 115 const char *table_valign_to_string (enum table_valign);
 116
 117 struct cell_style
 118   {
 119     enum table_halign halign;
 120     enum table_valign valign;
 121     double decimal_offset;       /* In 1/96" units. */
 122     char decimal_char;           /* Either '.' or ','. */
 123     int margin[TABLE_N_AXES][2]; /* In 1/96" units. */
 124   };
 125
 126 #define CELL_STYLE_INITIALIZER { CELL_STYLE_INITIALIZER__ }
 127 #define CELL_STYLE_INITIALIZER__                                \
 128         .margin = { [TABLE_HORZ][0] = 8, [TABLE_HORZ][1] = 11,  \
 129                     [TABLE_VERT][0] = 1, [TABLE_VERT][1] = 1 }
 130
 131 void cell_style_dump (const struct cell_style *);
 132
 133 struct font_style
 134   {
 135     bool bold, italic, underline, markup;
 136     struct cell_color fg[2], bg[2];
 137     char *typeface;
 138     int size;
 139   };
 140
 141 #define FONT_STYLE_INITIALIZER { FONT_STYLE_INITIALIZER__ }
 142 #define FONT_STYLE_INITIALIZER__                                        \
 143         .fg = { [0] = CELL_COLOR_BLACK, [1] = CELL_COLOR_BLACK},        \
 144         .bg = { [0] = CELL_COLOR_WHITE, [1] = CELL_COLOR_WHITE},
 145
 146 void font_style_copy (struct pool *,
 147                       struct font_style *, const struct font_style *);
 148 void font_style_uninit (struct font_style *);
 149 void font_style_dump (const struct font_style *);
 150
 151 struct area_style
 152   {
 153     struct cell_style cell_style;
 154     struct font_style font_style;
 155   };
 156
 157 #define AREA_STYLE_INITIALIZER { AREA_STYLE_INITIALIZER__ }
 158 #define AREA_STYLE_INITIALIZER__                \
 159        .cell_style = CELL_STYLE_INITIALIZER,    \
 160        .font_style = FONT_STYLE_INITIALIZER
 161
 162 struct area_style *area_style_clone (struct pool *, const struct area_style *);
 163 void area_style_copy (struct pool *,
 164                       struct area_style *, const struct area_style *);
 165 void area_style_uninit (struct area_style *);
 166 void area_style_free (struct area_style *);
 167
 168 /* Properties of a table cell. */
 169 enum
 170   {
 171     TAB_NONE = 0,
 172     TAB_FIX        = 1 << 1,    /* Use fixed font. */
 173     TAB_MARKUP     = 1 << 2,    /* Text contains Pango markup. */
 174     TAB_NUMERIC    = 1 << 3,    /* Cell contents are numeric. */
 175     TAB_ROTATE     = 1 << 4,    /* Rotate cell contents 90 degrees. */
 176
 177     TAB_STYLE_SHIFT = 5,
 178     TAB_STYLE_MASK = 7 << TAB_STYLE_SHIFT,
 179
 180     /* Horizontal alignment of cell contents. */
 181     TAB_RIGHT      = 0 << 10,
 182     TAB_LEFT       = 1 << 10,
 183     TAB_CENTER     = 2 << 10,
 184     TAB_HALIGN     = 3 << 10, /* Alignment mask. */
 185
 186     /* Vertical alignment of cell contents. */
 187     TAB_TOP        = 0 << 12,
 188     TAB_MIDDLE     = 1 << 12,
 189     TAB_BOTTOM     = 2 << 12,
 190     TAB_VALIGN     = 3 << 12, /* Alignment mask. */
 191
 192     /* Internal use by tab.c only. */
 193     TAB_JOIN = 1 << 14,
 194   };
 195
 196 /* Styles for the rules around table cells. */
 197 enum
 198   {
 199     TAL_NONE = TABLE_STROKE_NONE,
 200 #define TAL_0 TAL_NONE
 201     TAL_SOLID = TABLE_STROKE_SOLID,
 202 #define TAL_1 TAL_SOLID
 203     TAL_DASHED = TABLE_STROKE_DASHED,
 204     TAL_THICK = TABLE_STROKE_THICK,
 205     TAL_THIN = TABLE_STROKE_THIN,
 206     TAL_DOUBLE = TABLE_STROKE_DOUBLE,
 207 #define TAL_2 TAL_DOUBLE
 208   };
 209
 210 /* Given line styles A and B (each one of the TAL_* enumeration constants
 211    above), returns a line style that "combines" them, that is, that gives a
 212    reasonable line style choice for a rule for different reasons should have
 213    both styles A and B. */
 214 static inline int table_rule_combine (int a, int b)
 215 {
 216   return a > b ? a : b;
 217 }
 218
 219 /* A table. */
 220 struct table
 221   {
 222     struct pool *container;
 223
 224     /* Table size.
 225
 226        n[TABLE_HORZ]: Number of columns.
 227        n[TABLE_VERT]: Number of rows. */
 228     int n[TABLE_N_AXES];
 229
 230     /* Table headers.
 231
 232        Rows at the top and bottom of a table and columns at the left and right
 233        edges of a table can be designated as headers.  If the table must be
 234        broken across more than one page for output, headers rows and columns
 235        are repeated on each page.
 236
 237        h[TABLE_HORZ][0]: Left header columns.
 238        h[TABLE_HORZ][1]: Right header columns.
 239        h[TABLE_VERT][0]: Top header rows.
 240        h[TABLE_VERT][1]: Bottom header rows. */
 241     int h[TABLE_N_AXES][2];
 242
 243     /* Reference count.  A table may be shared between multiple owners,
 244        indicated by a reference count greater than 1.  When this is the case,
 245        the table must not be modified. */
 246     int ref_cnt;
 247
 248     /* Table contents.
 249
 250        Each array element in cc[] is ordinarily a "char *" pointer to a
 251        string.  If TAB_JOIN (defined in tab.c) is set in ct[] for the element,
 252        however, it is a joined cell and the corresponding element of cc[]
 253        points to a struct tab_joined_cell. */
 254     void **cc;                  /* Cell contents; void *[nr][nc]. */
 255     unsigned short *ct;         /* Cell types; unsigned short[nr][nc]. */
 256     struct area_style *styles[8];
 257
 258     /* Rules. */
 259     unsigned char *rh;          /* Horiz rules; unsigned char[nr+1][nc]. */
 260     unsigned char *rv;          /* Vert rules; unsigned char[nr][nc+1]. */
 261     struct cell_color *rule_colors[32];
 262   };
 263
 264 /* Reference counting. */
 265 struct table *table_ref (const struct table *);
 266 void table_unref (struct table *);
 267 bool table_is_shared (const struct table *);
 268
 269 /* Returns the number of columns or rows, respectively, in T. */
 270 static inline int table_nc (const struct table *t)
 271         { return t->n[TABLE_HORZ]; }
 272 static inline int table_nr (const struct table *t)
 273         { return t->n[TABLE_VERT]; }
 274
 275 /* Returns the number of left, right, top, or bottom headers, respectively, in
 276    T.  */
 277 static inline int table_hl (const struct table *t)
 278         { return t->h[TABLE_HORZ][0]; }
 279 static inline int table_hr (const struct table *t)
 280         { return t->h[TABLE_HORZ][1]; }
 281 static inline int table_ht (const struct table *t)
 282         { return t->h[TABLE_VERT][0]; }
 283 static inline int table_hb (const struct table *t)
 284         { return t->h[TABLE_VERT][1]; }
 285
 286 /* Simple kinds of output. */
 287 struct table *table_from_string (const char *);
 288 void table_output_text (int options, const char *string);
 289 void table_output_text_format (int options, const char *, ...)
 290   PRINTF_FORMAT (2, 3);
 291
 292 /* Rule masks. */
 293 #define TAB_RULE_TYPE_MASK   7
 294 #define TAB_RULE_TYPE_SHIFT  0
 295 #define TAB_RULE_STYLE_MASK  (31 << TAB_RULE_STYLE_SHIFT)
 296 #define TAB_RULE_STYLE_SHIFT 3
 297
 298 /* Tables. */
 299 struct table *table_create (int nc, int nr, int hl, int hr, int ht, int hb);
 300
 301 /* Rules. */
 302 void table_hline (struct table *, int style, int x1, int x2, int y);
 303 void table_vline (struct table *, int style, int x, int y1, int y2);
 304 void table_box (struct table *, int f_h, int f_v, int i_h, int i_v,
 305                 int x1, int y1, int x2, int y2);
 306
 307 /* Cells. */
 308 void table_text (struct table *, int c, int r, unsigned opt, const char *);
 309 void table_text_format (struct table *, int c, int r, unsigned opt,
 310                         const char *, ...)
 311   PRINTF_FORMAT (5, 6);
 312
 313 void table_joint_text (struct table *, int x1, int y1, int x2, int y2,
 314                        unsigned opt, const char *);
 315
 316 struct footnote *table_create_footnote (struct table *, size_t idx,
 317                                         const char *content,
 318                                         const char *marker,
 319                                         struct area_style *);
 320 void table_add_footnote (struct table *, int x, int y,
 321                          const struct footnote *);
 322
 323 void table_add_style (struct table *, int x, int y,
 324                       const struct area_style *);
 325
 326 bool table_cell_is_empty (const struct table *, int c, int r);
 327
 328 #endif /* output/table.h */