[BACK]Return to tbl_term.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/tbl_term.c, Revision 1.50

1.50    ! schwarze    1: /*     $Id: tbl_term.c,v 1.49 2017/06/12 20:45:18 schwarze Exp $ */
1.1       kristaps    2: /*
1.20      kristaps    3:  * Copyright (c) 2009, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.44      schwarze    4:  * Copyright (c) 2011,2012,2014,2015,2017 Ingo Schwarze <schwarze@openbsd.org>
1.1       kristaps    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"
1.28      schwarze   19:
                     20: #include <sys/types.h>
1.1       kristaps   21:
                     22: #include <assert.h>
                     23: #include <stdio.h>
                     24: #include <stdlib.h>
                     25: #include <string.h>
                     26:
                     27: #include "mandoc.h"
                     28: #include "out.h"
                     29: #include "term.h"
                     30:
1.11      kristaps   31: static size_t  term_tbl_len(size_t, void *);
                     32: static size_t  term_tbl_strlen(const char *, void *);
1.46      schwarze   33: static size_t  term_tbl_sulen(const struct roffsu *, void *);
1.12      kristaps   34: static void    tbl_char(struct termp *, char, size_t);
1.25      schwarze   35: static void    tbl_data(struct termp *, const struct tbl_opts *,
1.27      schwarze   36:                        const struct tbl_dat *,
1.11      kristaps   37:                        const struct roffcol *);
1.27      schwarze   38: static void    tbl_literal(struct termp *, const struct tbl_dat *,
1.11      kristaps   39:                        const struct roffcol *);
1.27      schwarze   40: static void    tbl_number(struct termp *, const struct tbl_opts *,
                     41:                        const struct tbl_dat *,
1.11      kristaps   42:                        const struct roffcol *);
1.33      schwarze   43: static void    tbl_hrule(struct termp *, const struct tbl_span *, int);
1.29      schwarze   44: static void    tbl_word(struct termp *, const struct tbl_dat *);
1.11      kristaps   45:
                     46:
                     47: static size_t
1.46      schwarze   48: term_tbl_sulen(const struct roffsu *su, void *arg)
                     49: {
                     50:        return term_hspan((const struct termp *)arg, su) / 24;
                     51: }
                     52:
                     53: static size_t
1.11      kristaps   54: term_tbl_strlen(const char *p, void *arg)
                     55: {
1.42      schwarze   56:        return term_strlen((const struct termp *)arg, p);
1.11      kristaps   57: }
                     58:
                     59: static size_t
                     60: term_tbl_len(size_t sz, void *arg)
                     61: {
1.42      schwarze   62:        return term_len((const struct termp *)arg, sz);
1.11      kristaps   63: }
1.1       kristaps   64:
                     65: void
                     66: term_tbl(struct termp *tp, const struct tbl_span *sp)
                     67: {
1.33      schwarze   68:        const struct tbl_cell   *cp;
1.11      kristaps   69:        const struct tbl_dat    *dp;
1.34      schwarze   70:        static size_t            offset;
1.47      schwarze   71:        size_t                   coloff, tsz;
                     72:        int                      ic, horiz, spans, vert, more;
                     73:        char                     fc;
1.39      schwarze   74:
1.4       kristaps   75:        /* Inhibit printing of spaces: we do padding ourselves. */
                     76:
1.47      schwarze   77:        tp->flags |= TERMP_NOSPACE | TERMP_NONOSPACE;
1.4       kristaps   78:
                     79:        /*
1.11      kristaps   80:         * The first time we're invoked for a given table block,
                     81:         * calculate the table widths and decimal positions.
1.4       kristaps   82:         */
                     83:
1.37      schwarze   84:        if (tp->tbl.cols == NULL) {
1.11      kristaps   85:                tp->tbl.len = term_tbl_len;
                     86:                tp->tbl.slen = term_tbl_strlen;
1.46      schwarze   87:                tp->tbl.sulen = term_tbl_sulen;
1.11      kristaps   88:                tp->tbl.arg = tp;
1.4       kristaps   89:
1.48      schwarze   90:                tblcalc(&tp->tbl, sp, tp->tcol->offset, tp->tcol->rmargin);
1.1       kristaps   91:
1.34      schwarze   92:                /* Center the table as a whole. */
                     93:
1.45      schwarze   94:                offset = tp->tcol->offset;
1.34      schwarze   95:                if (sp->opts->opts & TBL_OPT_CENTRE) {
                     96:                        tsz = sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX)
                     97:                            ? 2 : !!sp->opts->lvert + !!sp->opts->rvert;
1.36      schwarze   98:                        for (ic = 0; ic < sp->opts->cols; ic++)
                     99:                                tsz += tp->tbl.cols[ic].width + 3;
1.34      schwarze  100:                        tsz -= 3;
1.45      schwarze  101:                        if (offset + tsz > tp->tcol->rmargin)
1.34      schwarze  102:                                tsz -= 1;
1.45      schwarze  103:                        tp->tcol->offset = offset + tp->tcol->rmargin > tsz ?
                    104:                            (offset + tp->tcol->rmargin - tsz) / 2 : 0;
1.34      schwarze  105:                }
                    106:
1.33      schwarze  107:                /* Horizontal frame at the start of boxed tables. */
1.4       kristaps  108:
1.33      schwarze  109:                if (sp->opts->opts & TBL_OPT_DBOX)
                    110:                        tbl_hrule(tp, sp, 2);
                    111:                if (sp->opts->opts & (TBL_OPT_DBOX | TBL_OPT_BOX))
                    112:                        tbl_hrule(tp, sp, 1);
1.21      schwarze  113:        }
1.1       kristaps  114:
1.47      schwarze  115:        /* Set up the columns. */
1.1       kristaps  116:
1.47      schwarze  117:        tp->flags |= TERMP_MULTICOL;
                    118:        horiz = 0;
                    119:        switch (sp->pos) {
                    120:        case TBL_SPAN_HORIZ:
                    121:        case TBL_SPAN_DHORIZ:
                    122:                horiz = 1;
                    123:                term_setcol(tp, 1);
                    124:                break;
                    125:        case TBL_SPAN_DATA:
                    126:                term_setcol(tp, sp->opts->cols + 2);
                    127:                coloff = tp->tcol->offset;
                    128:
                    129:                /* Set up a column for a left vertical frame. */
                    130:
                    131:                if (sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ||
                    132:                    sp->opts->lvert)
                    133:                        coloff++;
                    134:                tp->tcol->rmargin = coloff;
1.33      schwarze  135:
1.47      schwarze  136:                /* Set up the data columns. */
1.1       kristaps  137:
1.47      schwarze  138:                dp = sp->first;
                    139:                spans = 0;
                    140:                for (ic = 0; ic < sp->opts->cols; ic++) {
                    141:                        if (spans == 0) {
                    142:                                tp->tcol++;
                    143:                                tp->tcol->offset = coloff;
                    144:                        }
                    145:                        coloff += tp->tbl.cols[ic].width;
                    146:                        tp->tcol->rmargin = coloff;
                    147:                        coloff++;
                    148:                        if (ic + 1 < sp->opts->cols)
                    149:                                coloff += 2;
                    150:                        if (spans) {
                    151:                                spans--;
                    152:                                continue;
                    153:                        }
                    154:                        if (dp == NULL)
                    155:                                continue;
                    156:                        spans = dp->spans;
                    157:                        dp = dp->next;
                    158:                }
                    159:
                    160:                /* Set up a column for a right vertical frame. */
                    161:
                    162:                tp->tcol++;
                    163:                tp->tcol->offset = coloff;
                    164:                if (sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ||
                    165:                    sp->opts->rvert)
                    166:                        coloff++;
                    167:                tp->tcol->rmargin = coloff;
                    168:
                    169:                /* Spans may have reduced the number of columns. */
                    170:
                    171:                tp->lasttcol = tp->tcol - tp->tcols;
                    172:
                    173:                /* Fill the buffers for all data columns. */
1.4       kristaps  174:
1.47      schwarze  175:                tp->tcol = tp->tcols;
1.4       kristaps  176:                dp = sp->first;
1.16      kristaps  177:                spans = 0;
1.36      schwarze  178:                for (ic = 0; ic < sp->opts->cols; ic++) {
1.47      schwarze  179:                        if (spans) {
                    180:                                spans--;
                    181:                                continue;
                    182:                        }
                    183:                        tp->tcol++;
                    184:                        tp->col = 0;
                    185:                        tbl_data(tp, sp->opts, dp, tp->tbl.cols + ic);
                    186:                        if (dp == NULL)
                    187:                                continue;
                    188:                        spans = dp->spans;
                    189:                        dp = dp->next;
                    190:                }
                    191:                break;
                    192:        }
                    193:
                    194:        do {
                    195:                /* Print the vertical frame at the start of each row. */
                    196:
                    197:                tp->tcol = tp->tcols;
                    198:                fc = '\0';
                    199:                if (sp->layout->vert ||
                    200:                    (sp->prev != NULL && sp->prev->layout->vert) ||
                    201:                    sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX))
                    202:                        fc = horiz ? '+' : '|';
                    203:                else if (horiz && sp->opts->lvert)
                    204:                        fc = '-';
                    205:                if (fc != '\0') {
                    206:                        (*tp->advance)(tp, tp->tcols->offset);
                    207:                        (*tp->letter)(tp, fc);
                    208:                        tp->viscol = tp->tcol->offset + 1;
                    209:                }
1.22      schwarze  210:
1.47      schwarze  211:                /* Print the data cells. */
1.21      schwarze  212:
1.47      schwarze  213:                more = 0;
                    214:                if (horiz) {
                    215:                        tbl_hrule(tp, sp, 0);
                    216:                        term_flushln(tp);
                    217:                } else {
                    218:                        cp = sp->layout->first;
                    219:                        dp = sp->first;
                    220:                        spans = 0;
                    221:                        for (ic = 0; ic < sp->opts->cols; ic++) {
                    222:                                if (spans == 0) {
                    223:                                        tp->tcol++;
                    224:                                        if (dp != NULL) {
                    225:                                                spans = dp->spans;
                    226:                                                dp = dp->next;
                    227:                                        }
                    228:                                        if (tp->tcol->col < tp->tcol->lastcol)
                    229:                                                term_flushln(tp);
                    230:                                        if (tp->tcol->col < tp->tcol->lastcol)
                    231:                                                more = 1;
                    232:                                        if (tp->tcol + 1 ==
                    233:                                            tp->tcols + tp->lasttcol)
                    234:                                                continue;
                    235:                                } else
                    236:                                        spans--;
                    237:
                    238:                                /* Vertical frames between data cells. */
                    239:
                    240:                                if (cp != NULL) {
                    241:                                        vert = cp->vert;
                    242:                                        cp = cp->next;
                    243:                                } else
                    244:                                        vert = 0;
1.50    ! schwarze  245:                                if (vert == 0 &&
        !           246:                                    sp->opts->opts & TBL_OPT_ALLBOX)
1.49      schwarze  247:                                        vert = 1;
1.47      schwarze  248:                                if (vert == 0)
                    249:                                        continue;
                    250:
                    251:                                if (tp->tcol->rmargin + 1 > tp->viscol) {
                    252:                                        (*tp->advance)(tp, tp->tcol->rmargin
                    253:                                           + 1 - tp->viscol);
                    254:                                        tp->viscol = tp->tcol->rmargin + 1;
                    255:                                }
                    256:                                while (vert--) {
                    257:                                        (*tp->letter)(tp, '|');
                    258:                                        tp->viscol++;
1.33      schwarze  259:                                }
1.47      schwarze  260:                        }
                    261:                }
1.1       kristaps  262:
1.47      schwarze  263:                /* Print the vertical frame at the end of each row. */
1.16      kristaps  264:
1.47      schwarze  265:                fc = '\0';
                    266:                if (sp->layout->last->vert ||
                    267:                    (sp->prev != NULL && sp->prev->layout->last->vert) ||
                    268:                    (sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX)))
                    269:                        fc = horiz ? '+' : '|';
                    270:                else if (horiz && sp->opts->rvert)
                    271:                        fc = '-';
                    272:                if (fc != '\0') {
                    273:                        if (horiz == 0) {
                    274:                                tp->tcol++;
                    275:                                (*tp->advance)(tp,
                    276:                                    tp->tcol->offset > tp->viscol ?
                    277:                                    tp->tcol->offset - tp->viscol : 1);
                    278:                        }
                    279:                        (*tp->letter)(tp, fc);
                    280:                }
                    281:                (*tp->endline)(tp);
                    282:                tp->viscol = 0;
                    283:        } while (more);
1.1       kristaps  284:
1.4       kristaps  285:        /*
                    286:         * If we're the last row, clean up after ourselves: clear the
                    287:         * existing table configuration and set it to NULL.
                    288:         */
                    289:
1.47      schwarze  290:        term_setcol(tp, 1);
                    291:        tp->flags &= ~TERMP_MULTICOL;
                    292:        tp->tcol->rmargin = tp->maxrmargin;
1.37      schwarze  293:        if (sp->next == NULL) {
1.33      schwarze  294:                if (sp->opts->opts & (TBL_OPT_DBOX | TBL_OPT_BOX)) {
                    295:                        tbl_hrule(tp, sp, 1);
1.24      schwarze  296:                        tp->skipvsp = 1;
                    297:                }
1.33      schwarze  298:                if (sp->opts->opts & TBL_OPT_DBOX) {
                    299:                        tbl_hrule(tp, sp, 2);
1.24      schwarze  300:                        tp->skipvsp = 2;
                    301:                }
1.11      kristaps  302:                assert(tp->tbl.cols);
                    303:                free(tp->tbl.cols);
                    304:                tp->tbl.cols = NULL;
1.45      schwarze  305:                tp->tcol->offset = offset;
1.50    ! schwarze  306:        } else if (horiz == 0 && sp->opts->opts & TBL_OPT_ALLBOX &&
        !           307:            (sp->next == NULL || sp->next->pos == TBL_SPAN_DATA ||
        !           308:             sp->next->next != NULL))
1.49      schwarze  309:                tbl_hrule(tp, sp, 1);
                    310:
1.47      schwarze  311:        tp->flags &= ~TERMP_NONOSPACE;
1.1       kristaps  312: }
                    313:
1.21      schwarze  314: /*
1.33      schwarze  315:  * Kinds of horizontal rulers:
                    316:  * 0: inside the table (single or double line with crossings)
                    317:  * 1: inner frame (single line with crossings and ends)
                    318:  * 2: outer frame (single line without crossings with ends)
1.21      schwarze  319:  */
1.1       kristaps  320: static void
1.33      schwarze  321: tbl_hrule(struct termp *tp, const struct tbl_span *sp, int kind)
1.1       kristaps  322: {
1.33      schwarze  323:        const struct tbl_cell *c1, *c2;
                    324:        int      vert;
                    325:        char     line, cross;
                    326:
                    327:        line = (kind == 0 && TBL_SPAN_DHORIZ == sp->pos) ? '=' : '-';
                    328:        cross = (kind < 2) ? '+' : '-';
                    329:
                    330:        if (kind)
                    331:                term_word(tp, "+");
                    332:        c1 = sp->layout->first;
                    333:        c2 = sp->prev == NULL ? NULL : sp->prev->layout->first;
                    334:        if (c2 == c1)
                    335:                c2 = NULL;
                    336:        for (;;) {
1.36      schwarze  337:                tbl_char(tp, line, tp->tbl.cols[c1->col].width + 1);
1.33      schwarze  338:                vert = c1->vert;
                    339:                if ((c1 = c1->next) == NULL)
                    340:                         break;
                    341:                if (c2 != NULL) {
                    342:                        if (vert < c2->vert)
                    343:                                vert = c2->vert;
                    344:                        c2 = c2->next;
                    345:                }
1.49      schwarze  346:                if (sp->opts->opts & TBL_OPT_ALLBOX && !vert)
                    347:                        vert = 1;
1.33      schwarze  348:                if (vert)
                    349:                        tbl_char(tp, cross, vert);
                    350:                if (vert < 2)
                    351:                        tbl_char(tp, line, 2 - vert);
1.22      schwarze  352:        }
1.33      schwarze  353:        if (kind) {
                    354:                term_word(tp, "+");
                    355:                term_flushln(tp);
1.22      schwarze  356:        }
1.1       kristaps  357: }
                    358:
                    359: static void
1.25      schwarze  360: tbl_data(struct termp *tp, const struct tbl_opts *opts,
1.27      schwarze  361:        const struct tbl_dat *dp,
                    362:        const struct roffcol *col)
1.1       kristaps  363: {
                    364:
1.35      schwarze  365:        if (dp == NULL) {
1.11      kristaps  366:                tbl_char(tp, ASCII_NBRSP, col->width);
1.1       kristaps  367:                return;
                    368:        }
                    369:
                    370:        switch (dp->pos) {
1.27      schwarze  371:        case TBL_DATA_NONE:
1.11      kristaps  372:                tbl_char(tp, ASCII_NBRSP, col->width);
1.10      kristaps  373:                return;
1.27      schwarze  374:        case TBL_DATA_HORIZ:
                    375:        case TBL_DATA_NHORIZ:
1.11      kristaps  376:                tbl_char(tp, '-', col->width);
1.7       kristaps  377:                return;
1.27      schwarze  378:        case TBL_DATA_NDHORIZ:
                    379:        case TBL_DATA_DHORIZ:
1.11      kristaps  380:                tbl_char(tp, '=', col->width);
1.1       kristaps  381:                return;
                    382:        default:
                    383:                break;
                    384:        }
1.27      schwarze  385:
1.16      kristaps  386:        switch (dp->layout->pos) {
1.27      schwarze  387:        case TBL_CELL_HORIZ:
1.11      kristaps  388:                tbl_char(tp, '-', col->width);
1.7       kristaps  389:                break;
1.27      schwarze  390:        case TBL_CELL_DHORIZ:
1.11      kristaps  391:                tbl_char(tp, '=', col->width);
1.1       kristaps  392:                break;
1.27      schwarze  393:        case TBL_CELL_LONG:
                    394:        case TBL_CELL_CENTRE:
                    395:        case TBL_CELL_LEFT:
                    396:        case TBL_CELL_RIGHT:
1.11      kristaps  397:                tbl_literal(tp, dp, col);
1.1       kristaps  398:                break;
1.27      schwarze  399:        case TBL_CELL_NUMBER:
1.25      schwarze  400:                tbl_number(tp, opts, dp, col);
1.18      kristaps  401:                break;
1.27      schwarze  402:        case TBL_CELL_DOWN:
1.18      kristaps  403:                tbl_char(tp, ASCII_NBRSP, col->width);
1.1       kristaps  404:                break;
                    405:        default:
                    406:                abort();
                    407:        }
                    408: }
                    409:
                    410: static void
1.12      kristaps  411: tbl_char(struct termp *tp, char c, size_t len)
1.1       kristaps  412: {
1.12      kristaps  413:        size_t          i, sz;
                    414:        char            cp[2];
                    415:
                    416:        cp[0] = c;
                    417:        cp[1] = '\0';
1.1       kristaps  418:
1.3       kristaps  419:        sz = term_strlen(tp, cp);
                    420:
                    421:        for (i = 0; i < len; i += sz)
1.1       kristaps  422:                term_word(tp, cp);
                    423: }
                    424:
                    425: static void
1.27      schwarze  426: tbl_literal(struct termp *tp, const struct tbl_dat *dp,
1.11      kristaps  427:                const struct roffcol *col)
1.1       kristaps  428: {
1.36      schwarze  429:        size_t           len, padl, padr, width;
                    430:        int              ic, spans;
1.1       kristaps  431:
1.17      kristaps  432:        assert(dp->string);
1.21      schwarze  433:        len = term_strlen(tp, dp->string);
1.23      schwarze  434:        width = col->width;
1.36      schwarze  435:        ic = dp->layout->col;
                    436:        spans = dp->spans;
                    437:        while (spans--)
                    438:                width += tp->tbl.cols[++ic].width + 3;
1.23      schwarze  439:
                    440:        padr = width > len ? width - len : 0;
1.21      schwarze  441:        padl = 0;
1.1       kristaps  442:
1.16      kristaps  443:        switch (dp->layout->pos) {
1.27      schwarze  444:        case TBL_CELL_LONG:
1.21      schwarze  445:                padl = term_len(tp, 1);
                    446:                padr = padr > padl ? padr - padl : 0;
1.1       kristaps  447:                break;
1.27      schwarze  448:        case TBL_CELL_CENTRE:
1.21      schwarze  449:                if (2 > padr)
1.19      schwarze  450:                        break;
1.21      schwarze  451:                padl = padr / 2;
1.19      schwarze  452:                padr -= padl;
1.1       kristaps  453:                break;
1.27      schwarze  454:        case TBL_CELL_RIGHT:
1.21      schwarze  455:                padl = padr;
                    456:                padr = 0;
1.1       kristaps  457:                break;
                    458:        default:
                    459:                break;
                    460:        }
                    461:
                    462:        tbl_char(tp, ASCII_NBRSP, padl);
1.29      schwarze  463:        tbl_word(tp, dp);
1.21      schwarze  464:        tbl_char(tp, ASCII_NBRSP, padr);
1.1       kristaps  465: }
                    466:
                    467: static void
1.25      schwarze  468: tbl_number(struct termp *tp, const struct tbl_opts *opts,
1.2       kristaps  469:                const struct tbl_dat *dp,
1.11      kristaps  470:                const struct roffcol *col)
1.1       kristaps  471: {
1.11      kristaps  472:        char            *cp;
                    473:        char             buf[2];
                    474:        size_t           sz, psz, ssz, d, padl;
                    475:        int              i;
1.1       kristaps  476:
                    477:        /*
                    478:         * See calc_data_number().  Left-pad by taking the offset of our
                    479:         * and the maximum decimal; right-pad by the remaining amount.
                    480:         */
                    481:
1.17      kristaps  482:        assert(dp->string);
1.2       kristaps  483:
1.17      kristaps  484:        sz = term_strlen(tp, dp->string);
1.2       kristaps  485:
1.25      schwarze  486:        buf[0] = opts->decimal;
1.11      kristaps  487:        buf[1] = '\0';
1.2       kristaps  488:
1.11      kristaps  489:        psz = term_strlen(tp, buf);
1.10      kristaps  490:
1.35      schwarze  491:        if ((cp = strrchr(dp->string, opts->decimal)) != NULL) {
1.17      kristaps  492:                for (ssz = 0, i = 0; cp != &dp->string[i]; i++) {
                    493:                        buf[0] = dp->string[i];
1.5       kristaps  494:                        ssz += term_strlen(tp, buf);
                    495:                }
                    496:                d = ssz + psz;
                    497:        } else
                    498:                d = sz + psz;
1.2       kristaps  499:
1.32      schwarze  500:        if (col->decimal > d && col->width > sz) {
                    501:                padl = col->decimal - d;
                    502:                if (padl + sz > col->width)
                    503:                        padl = col->width - sz;
                    504:                tbl_char(tp, ASCII_NBRSP, padl);
                    505:        } else
                    506:                padl = 0;
1.29      schwarze  507:        tbl_word(tp, dp);
1.21      schwarze  508:        if (col->width > sz + padl)
                    509:                tbl_char(tp, ASCII_NBRSP, col->width - sz - padl);
1.2       kristaps  510: }
                    511:
1.29      schwarze  512: static void
                    513: tbl_word(struct termp *tp, const struct tbl_dat *dp)
                    514: {
1.38      schwarze  515:        int              prev_font;
1.29      schwarze  516:
1.38      schwarze  517:        prev_font = tp->fonti;
1.29      schwarze  518:        if (dp->layout->flags & TBL_CELL_BOLD)
                    519:                term_fontpush(tp, TERMFONT_BOLD);
                    520:        else if (dp->layout->flags & TBL_CELL_ITALIC)
                    521:                term_fontpush(tp, TERMFONT_UNDER);
                    522:
                    523:        term_word(tp, dp->string);
                    524:
                    525:        term_fontpopq(tp, prev_font);
                    526: }

CVSweb