X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Ftable.c;h=8f717ead5679359b4f5c8529811e7b731d9c307d;hb=078b003b3171c6158a3419a01189b9658896f470;hp=7f37479984274dc357d50da44f03423d2ea891bd;hpb=395cd4395449dbdff7c9ba0d56ba14529063d350;p=pspp

diff --git a/src/output/table.c b/src/output/table.c
index 7f37479984..8f717ead56 100644
--- a/src/output/table.c
+++ b/src/output/table.c
@@ -20,12 +20,17 @@
 #include "output/table-provider.h"
 
 #include <assert.h>
+#include <inttypes.h>
 #include <stdlib.h>
 
+#include "data/format.h"
+#include "libpspp/assertion.h"
 #include "libpspp/cast.h"
 #include "libpspp/compiler.h"
+#include "libpspp/pool.h"
 #include "libpspp/str.h"
 #include "output/table-item.h"
+#include "output/tab.h"
 
 #include "gl/xalloc.h"
 
@@ -129,6 +134,26 @@ table_set_nr (struct table *table, int nr)
   table->n[TABLE_VERT] = nr;
 }
 
+struct area_style *
+area_style_clone (struct pool *pool, const struct area_style *old)
+{
+  struct area_style *new = pool_malloc (pool, sizeof *new);
+  *new = *old;
+  if (new->font_style.typeface)
+    new->font_style.typeface = pool_strdup (pool, new->font_style.typeface);
+  return new;
+}
+
+void
+area_style_free (struct area_style *style)
+{
+  if (style)
+    {
+      free (style->font_style.typeface);
+      free (style);
+    }
+}
+
 /* Initializes CELL with the contents of the table cell at column X and row Y
    within TABLE.  When CELL is no longer needed, the caller is responsible for
    freeing it by calling table_cell_free(CELL).
@@ -140,6 +165,10 @@ table_get_cell (const struct table *table, int x, int y,
 {
   assert (x >= 0 && x < table->n[TABLE_HORZ]);
   assert (y >= 0 && y < table->n[TABLE_VERT]);
+
+  static const struct area_style default_style = AREA_STYLE_INITIALIZER;
+  cell->style = &default_style;
+
   table->klass->get_cell (table, x, y, cell);
 }
 
@@ -190,22 +219,24 @@ table_cell_free (struct table_cell *cell)
    between that cell and cell (0,1); and so on, up to (0,NR), which runs
    horizontally below cell (0,NR-1). */
 int
-table_get_rule (const struct table *table, enum table_axis axis, int x, int y)
+table_get_rule (const struct table *table, enum table_axis axis, int x, int y,
+                struct cell_color *color)
 {
   assert (x >= 0 && x < table->n[TABLE_HORZ] + (axis == TABLE_HORZ));
   assert (y >= 0 && y < table->n[TABLE_VERT] + (axis == TABLE_VERT));
-  return table->klass->get_rule (table, axis, x, y);
+  *color = (struct cell_color) CELL_COLOR_BLACK;
+  return table->klass->get_rule (table, axis, x, y, color);
 }
 
 void
-cell_contents_format_footnote_markers (const struct cell_contents *c,
-                                       struct string *s)
+table_cell_format_footnote_markers (const struct table_cell *cell,
+                                    struct string *s)
 {
-  for (size_t i = 0; i < c->n_footnotes; i++)
+  for (size_t i = 0; i < cell->n_footnotes; i++)
     {
       if (i)
         ds_put_byte (s, ',');
-      ds_put_cstr (s, c->footnotes[i]->marker);
+      ds_put_cstr (s, cell->footnotes[i]->marker);
     }
 }
 
@@ -247,12 +278,8 @@ table_collect_footnotes (const struct table_item *item,
           table_get_cell (t, x, y, &cell);
 
           if (x == cell.d[TABLE_HORZ][0] && y == cell.d[TABLE_VERT][0])
-            for (size_t i = 0; i < cell.n_contents; i++)
-              {
-                const struct cell_contents *c = &cell.contents[i];
-                footnotes = add_footnotes (c->footnotes, c->n_footnotes,
-                                           footnotes, &allocated, &n);
-              }
+            footnotes = add_footnotes (cell.footnotes, cell.n_footnotes,
+                                       footnotes, &allocated, &n);
           table_cell_free (&cell);
         }
     }
@@ -271,148 +298,148 @@ table_collect_footnotes (const struct table_item *item,
   return n;
 }
 
-struct table_unshared
-  {
-    struct table table;
-    struct table *subtable;
-  };
-
-static const struct table_class table_unshared_class;
-
-/* Takes ownership of TABLE and returns a table with the same contents but
-   which is guaranteed not to be shared (as returned by table_is_shared()).
-
-   If TABLE is unshared, just returns TABLE.
-
-   The only real use for this function is to create a copy of TABLE in which
-   the headers can be adjusted, which is a pretty specialized use case. */
+/* Returns a table that contains a single cell, whose contents are the
+   left-aligned TEXT.  */
 struct table *
-table_unshare (struct table *table)
+table_from_string (const char *text)
 {
-  if (!table_is_shared (table))
-    return table;
-  else
+  struct tab_table *t = tab_create (1, 1);
+  tab_text (t, 0, 0, TAB_LEFT, text);
+  return &t->table;
+}
+
+const char *
+table_halign_to_string (enum table_halign halign)
+{
+  switch (halign)
     {
-      struct table_unshared *tiu = xmalloc (sizeof *tiu);
-      table_init (&tiu->table, &table_unshared_class);
-      table_set_nc (&tiu->table, table_nc (table));
-      table_set_nr (&tiu->table, table_nr (table));
-      table_set_hl (&tiu->table, table_hl (table));
-      table_set_hr (&tiu->table, table_hr (table));
-      table_set_ht (&tiu->table, table_ht (table));
-      table_set_hb (&tiu->table, table_hb (table));
-      tiu->subtable = table;
-      return &tiu->table;
+    case TABLE_HALIGN_LEFT: return "left";
+    case TABLE_HALIGN_CENTER: return "center";
+    case TABLE_HALIGN_RIGHT: return "right";
+    case TABLE_HALIGN_DECIMAL: return "decimal";
+    case TABLE_HALIGN_MIXED: return "mixed";
+    default: return "**error**";
     }
 }
 
-static struct table_unshared *
-table_unshared_cast (const struct table *table)
+const char *
+table_valign_to_string (enum table_valign valign)
 {
-  assert (table->klass == &table_unshared_class);
-  return UP_CAST (table, struct table_unshared, table);
+  switch (valign)
+    {
+    case TABLE_VALIGN_TOP: return "top";
+    case TABLE_VALIGN_CENTER: return "center";
+    case TABLE_VALIGN_BOTTOM: return "bottom";
+    default: return "**error**";
+    }
 }
 
-static void
-table_unshared_destroy (struct table *tiu_)
+enum table_halign
+table_halign_interpret (enum table_halign halign, bool numeric)
 {
-  struct table_unshared *tiu = table_unshared_cast (tiu_);
-  table_unref (tiu->subtable);
-  free (tiu);
+  switch (halign)
+    {
+    case TABLE_HALIGN_LEFT:
+    case TABLE_HALIGN_CENTER:
+    case TABLE_HALIGN_RIGHT:
+      return halign;
+
+    case TABLE_HALIGN_MIXED:
+      return numeric ? TABLE_HALIGN_RIGHT : TABLE_HALIGN_LEFT;
+
+    case TABLE_HALIGN_DECIMAL:
+      return TABLE_HALIGN_DECIMAL;
+
+    default:
+      NOT_REACHED ();
+    }
 }
 
-static void
-table_unshared_get_cell (const struct table *tiu_, int x, int y,
-                              struct table_cell *cell)
+void
+font_style_copy (struct font_style *dst, const struct font_style *src)
 {
-  struct table_unshared *tiu = table_unshared_cast (tiu_);
-  table_get_cell (tiu->subtable, x, y, cell);
+  *dst = *src;
+  if (dst->typeface)
+    dst->typeface = xstrdup (dst->typeface);
 }
 
-static int
-table_unshared_get_rule (const struct table *tiu_,
-                              enum table_axis axis, int x, int y)
+void
+font_style_uninit (struct font_style *font)
 {
-  struct table_unshared *tiu = table_unshared_cast (tiu_);
-  return table_get_rule (tiu->subtable, axis, x, y);
+  if (font)
+    free (font->typeface);
 }
 
-static const struct table_class table_unshared_class =
-  {
-    table_unshared_destroy,
-    table_unshared_get_cell,
-    table_unshared_get_rule,
-    NULL,                       /* paste */
-    NULL,                       /* select */
-  };
-
-struct table_string
-  {
-    struct table table;
-    char *string;
-    unsigned int options;
-  };
-
-static const struct table_class table_string_class;
-
-/* Returns a table that contains a single cell, whose contents are S with
-   options OPTIONS (a combination of TAB_* values).  */
-struct table *
-table_from_string (unsigned int options, const char *s)
+void
+area_style_copy (struct area_style *dst, const struct area_style *src)
 {
-  struct table_string *ts = xmalloc (sizeof *ts);
-  table_init (&ts->table, &table_string_class);
-  ts->table.n[TABLE_HORZ] = ts->table.n[TABLE_VERT] = 1;
-  ts->string = xstrdup (s);
-  ts->options = options;
-  return &ts->table;
+  font_style_copy (&dst->font_style, &src->font_style);
+  dst->cell_style = src->cell_style;
 }
 
-static struct table_string *
-table_string_cast (const struct table *table)
+void
+area_style_uninit (struct area_style *area)
 {
-  assert (table->klass == &table_string_class);
-  return UP_CAST (table, struct table_string, table);
+  if (area)
+    font_style_uninit (&area->font_style);
 }
 
-static void
-table_string_destroy (struct table *ts_)
+const char *
+table_stroke_to_string (enum table_stroke stroke)
 {
-  struct table_string *ts = table_string_cast (ts_);
-  free (ts->string);
-  free (ts);
+  switch (stroke)
+    {
+    case TABLE_STROKE_NONE: return "none";
+    case TABLE_STROKE_SOLID: return "solid";
+    case TABLE_STROKE_DASHED: return "dashed";
+    case TABLE_STROKE_THICK: return "thick";
+    case TABLE_STROKE_THIN: return "thin";
+    case TABLE_STROKE_DOUBLE: return "double";
+    default:
+      return "**error**";
+    }
 }
 
-static void
-table_string_get_cell (const struct table *ts_, int x UNUSED, int y UNUSED,
-                       struct table_cell *cell)
+void
+cell_color_dump (const struct cell_color *c)
 {
-  struct table_string *ts = table_string_cast (ts_);
-  cell->d[TABLE_HORZ][0] = 0;
-  cell->d[TABLE_HORZ][1] = 1;
-  cell->d[TABLE_VERT][0] = 0;
-  cell->d[TABLE_VERT][1] = 1;
-  cell->contents = &cell->inline_contents;
-  cell->inline_contents.options = ts->options;
-  cell->inline_contents.text = ts->string;
-  cell->inline_contents.n_footnotes = 0;
-  cell->n_contents = 1;
-  cell->destructor = NULL;
+  if (c->alpha != 255)
+    printf ("rgba(%d, %d, %d, %d)", c->r, c->g, c->b, c->alpha);
+  else
+    printf ("#%02"PRIx8"%02"PRIx8"%02"PRIx8, c->r, c->g, c->b);
 }
 
-
-static int
-table_string_get_rule (const struct table *ts UNUSED,
-                       enum table_axis axis UNUSED, int x UNUSED, int y UNUSED)
+void
+font_style_dump (const struct font_style *f)
 {
-  return TAL_0;
+  printf ("%s %dpx ", f->typeface, f->size);
+  cell_color_dump (&f->fg[0]);
+  putchar ('/');
+  cell_color_dump (&f->bg[0]);
+  if (!cell_color_equal (&f->fg[0], &f->fg[1])
+      || !cell_color_equal (&f->bg[0], &f->bg[1]))
+    {
+      printf (" alt=");
+      cell_color_dump (&f->fg[1]);
+      putchar ('/');
+      cell_color_dump (&f->bg[1]);
+    }
+  if (f->bold)
+    fputs (" bold", stdout);
+  if (f->italic)
+    fputs (" italic", stdout);
+  if (f->underline)
+    fputs (" underline", stdout);
 }
 
-static const struct table_class table_string_class =
-  {
-    table_string_destroy,
-    table_string_get_cell,
-    table_string_get_rule,
-    NULL,                       /* paste */
-    NULL,                       /* select */
-  };
+void
+cell_style_dump (const struct cell_style *c)
+{
+  fputs (table_halign_to_string (c->halign), stdout);
+  if (c->halign == TABLE_HALIGN_DECIMAL)
+    printf ("(%.2gpx)", c->decimal_offset);
+  printf (" %s", table_valign_to_string (c->valign));
+  printf (" %d,%d,%d,%dpx",
+          c->margin[TABLE_HORZ][0], c->margin[TABLE_HORZ][1],
+          c->margin[TABLE_VERT][0], c->margin[TABLE_VERT][1]);
+}