tbl_html.c

   1 /*      $Id: tbl_html.c,v 1.33 2019/03/17 18:21:45 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2014, 2015, 2017, 2018 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include "config.h"
  19
  20 #include <sys/types.h>
  21
  22 #include <assert.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "mandoc.h"
  28 #include "roff.h"
  29 #include "tbl.h"
  30 #include "out.h"
  31 #include "html.h"
  32
  33 static  void     html_tblopen(struct html *, const struct tbl_span *);
  34 static  size_t   html_tbl_len(size_t, void *);
  35 static  size_t   html_tbl_strlen(const char *, void *);
  36 static  size_t   html_tbl_sulen(const struct roffsu *, void *);
  37
  38
  39 static size_t
  40 html_tbl_len(size_t sz, void *arg)
  41 {
  42         return sz;
  43 }
  44
  45 static size_t
  46 html_tbl_strlen(const char *p, void *arg)
  47 {
  48         return strlen(p);
  49 }
  50
  51 static size_t
  52 html_tbl_sulen(const struct roffsu *su, void *arg)
  53 {
  54         if (su->scale < 0.0)
  55                 return 0;
  56
  57         switch (su->unit) {
  58         case SCALE_FS:  /* 2^16 basic units */
  59                 return su->scale * 65536.0 / 24.0;
  60         case SCALE_IN:  /* 10 characters per inch */
  61                 return su->scale * 10.0;
  62         case SCALE_CM:  /* 2.54 cm per inch */
  63                 return su->scale * 10.0 / 2.54;
  64         case SCALE_PC:  /* 6 pica per inch */
  65         case SCALE_VS:
  66                 return su->scale * 10.0 / 6.0;
  67         case SCALE_EN:
  68         case SCALE_EM:
  69                 return su->scale;
  70         case SCALE_PT:  /* 12 points per pica */
  71                 return su->scale * 10.0 / 6.0 / 12.0;
  72         case SCALE_BU:  /* 24 basic units per character */
  73                 return su->scale / 24.0;
  74         case SCALE_MM:  /* 1/1000 inch */
  75                 return su->scale / 100.0;
  76         default:
  77                 abort();
  78         }
  79 }
  80
  81 static void
  82 html_tblopen(struct html *h, const struct tbl_span *sp)
  83 {
  84         html_close_paragraph(h);
  85         if (h->tbl.cols == NULL) {
  86                 h->tbl.len = html_tbl_len;
  87                 h->tbl.slen = html_tbl_strlen;
  88                 h->tbl.sulen = html_tbl_sulen;
  89                 tblcalc(&h->tbl, sp, 0, 0);
  90         }
  91         assert(NULL == h->tblt);
  92         h->tblt = print_otag(h, TAG_TABLE, "c?ss", "tbl",
  93             "border",
  94                 sp->opts->opts & TBL_OPT_ALLBOX ? "1" : NULL,
  95             "border-style",
  96                 sp->opts->opts & TBL_OPT_DBOX ? "double" :
  97                 sp->opts->opts & TBL_OPT_BOX ? "solid" : NULL,
  98             "border-top-style",
  99                 sp->pos == TBL_SPAN_DHORIZ ? "double" :
 100                 sp->pos == TBL_SPAN_HORIZ ? "solid" : NULL);
 101 }
 102
 103 void
 104 print_tblclose(struct html *h)
 105 {
 106
 107         assert(h->tblt);
 108         print_tagq(h, h->tblt);
 109         h->tblt = NULL;
 110 }
 111
 112 void
 113 print_tbl(struct html *h, const struct tbl_span *sp)
 114 {
 115         const struct tbl_dat    *dp;
 116         const struct tbl_cell   *cp;
 117         const struct tbl_span   *psp;
 118         struct tag              *tt;
 119         const char              *hspans, *vspans, *halign, *valign;
 120         const char              *bborder, *lborder, *rborder;
 121         char                     hbuf[4], vbuf[4];
 122         int                      i;
 123
 124         if (h->tblt == NULL)
 125                 html_tblopen(h, sp);
 126
 127         /*
 128          * Horizontal lines spanning the whole table
 129          * are handled by previous or following table rows.
 130          */
 131
 132         if (sp->pos != TBL_SPAN_DATA)
 133                 return;
 134
 135         /* Inhibit printing of spaces: we do padding ourselves. */
 136
 137         h->flags |= HTML_NONOSPACE;
 138         h->flags |= HTML_NOSPACE;
 139
 140         /* Draw a vertical line left of this row? */
 141
 142         switch (sp->layout->vert) {
 143         case 2:
 144                 lborder = "double";
 145                 break;
 146         case 1:
 147                 lborder = "solid";
 148                 break;
 149         default:
 150                 lborder = NULL;
 151                 break;
 152         }
 153
 154         /* Draw a horizontal line below this row? */
 155
 156         bborder = NULL;
 157         if ((psp = sp->next) != NULL) {
 158                 switch (psp->pos) {
 159                 case TBL_SPAN_DHORIZ:
 160                         bborder = "double";
 161                         break;
 162                 case TBL_SPAN_HORIZ:
 163                         bborder = "solid";
 164                         break;
 165                 default:
 166                         break;
 167                 }
 168         }
 169
 170         tt = print_otag(h, TAG_TR, "ss",
 171             "border-left-style", lborder,
 172             "border-bottom-style", bborder);
 173
 174         for (dp = sp->first; dp != NULL; dp = dp->next) {
 175                 print_stagq(h, tt);
 176
 177                 /*
 178                  * Do not generate <td> elements for continuations
 179                  * of spanned cells.  Larger <td> elements covering
 180                  * this space were already generated earlier.
 181                  */
 182
 183                 cp = dp->layout;
 184                 if (cp->pos == TBL_CELL_SPAN || cp->pos == TBL_CELL_DOWN ||
 185                     (dp->string != NULL && strcmp(dp->string, "\\^") == 0))
 186                         continue;
 187
 188                 /* Determine the attribute values. */
 189
 190                 if (dp->hspans > 0) {
 191                         (void)snprintf(hbuf, sizeof(hbuf),
 192                             "%d", dp->hspans + 1);
 193                         hspans = hbuf;
 194                 } else
 195                         hspans = NULL;
 196                 if (dp->vspans > 0) {
 197                         (void)snprintf(vbuf, sizeof(vbuf),
 198                             "%d", dp->vspans + 1);
 199                         vspans = vbuf;
 200                 } else
 201                         vspans = NULL;
 202
 203                 switch (cp->pos) {
 204                 case TBL_CELL_CENTRE:
 205                         halign = "center";
 206                         break;
 207                 case TBL_CELL_RIGHT:
 208                 case TBL_CELL_NUMBER:
 209                         halign = "right";
 210                         break;
 211                 default:
 212                         halign = NULL;
 213                         break;
 214                 }
 215                 if (cp->flags & TBL_CELL_TALIGN)
 216                         valign = "top";
 217                 else if (cp->flags & TBL_CELL_BALIGN)
 218                         valign = "bottom";
 219                 else
 220                         valign = NULL;
 221
 222                 for (i = dp->hspans; i > 0; i--)
 223                         cp = cp->next;
 224                 switch (cp->vert) {
 225                 case 2:
 226                         rborder = "double";
 227                         break;
 228                 case 1:
 229                         rborder = "solid";
 230                         break;
 231                 default:
 232                         rborder = NULL;
 233                         break;
 234                 }
 235
 236                 /* Print the element and the attributes. */
 237
 238                 print_otag(h, TAG_TD, "??sss",
 239                     "colspan", hspans, "rowspan", vspans,
 240                     "vertical-align", valign,
 241                     "text-align", halign,
 242                     "border-right-style", rborder);
 243                 if (dp->string != NULL)
 244                         print_text(h, dp->string);
 245         }
 246
 247         print_tagq(h, tt);
 248
 249         h->flags &= ~HTML_NONOSPACE;
 250
 251         if (sp->next == NULL) {
 252                 assert(h->tbl.cols);
 253                 free(h->tbl.cols);
 254                 h->tbl.cols = NULL;
 255                 print_tblclose(h);
 256         }
 257 }