add cell-padding-property as a style property for table cells

Also, add a `#:pad` optional argument to `tabular`, which provides a
simple way of adding padding to cells --- especially as an alternative
to `#:sep`, which has turned out to be awkward and bad in many cases.

Padding is currently rendered for HTML, Latex/PDF, and text.

Author: mflatt

scribble-doc/scribblings/scribble/base.scrbl

@@ -269,6 +269,7 @@ Returns @racket[#t] if @racket[v] is an item produced by
 
 @defproc[(tabular [cells (listof (listof (or/c block? content? 'cont)))]
                   [#:style style (or/c style? string? symbol? #f) #f]
+                  [#:pad pad (or/c real? (list/c real? real?) (list/c real? real? real? real?)) 0]
                   [#:sep sep (or/c block? content? #f) #f]
                   [#:column-properties column-properties (listof any/c) '()]
                   [#:row-properties row-properties (listof any/c) '()]
@@ -288,8 +289,17 @@ cell in a row.
 The @racket[style] argument is handled the same as @racket[para].
 See @racket[table] for a list of recognized @tech{style names} and @tech{style properties}.
 
-The default style places no space between table columns. If
-@racket[sep] is not @racket[#f], it is inserted as a new column
+The default style places no space between table columns. Specify a
+@racket[pad] list to add padding around each cell's content, where the
+numbers in a @racket[pad] list are in ``ex'' units (roughly
+corresponding to the size of a character). If @racket[pad] is a single
+number, it is used for all sides of the cell. If @racket[pad] is a
+list of two numbers, the first is used on the left and right, and the
+last is used on the top and bottom. If @racket[pad] is a list of four
+numbers, they are used in order for left, top, right, and bottom
+padding.
+
+If @racket[sep] is not @racket[#f], it is inserted as a new column
 between every column in the table; the new column's properties are the
 same as the preceding column's, unless @racket[sep-properties]
 provides a list of @tech{style properties} to use. When @racket[sep]
@@ -351,22 +361,18 @@ redundant information. In that case, @racket[column-attributes]
 properties will be used from @racket[table-columns], while other
 properties will be used from the merger into @racket[table-cells].}
 
-@history[#:changed "1.1" @elem{Added the @racket[#:column-properties],
-                               @racket[#:row-properties],
-                               and @racket[#:cell-properties] arguments.}
-         #:changed "1.12" @elem{Changed @racket[sep] insertion before a
-                                @racket['cont].}
-         #:changed "1.28" @elem{Added @racket[sep-properties] and made
-                                the preceding column's properties used
-                                consistently if not specified.}]
-
 Examples:
 @codeblock[#:keep-lang-line? #f]|{
 #lang scribble/manual
 @tabular[#:sep @hspace[1]
          (list (list "soup" "gazpacho")
                (list "soup" "tonjiru"))]
 
+@tabular[#:pad '(1 0)
+         #:column-properties '(border)
+         (list (list "gazpacho" "cold")
+               (list "tonjiru"  "hot"))]
+
 @tabular[#:style 'boxed
          #:column-properties '(left right)
          #:row-properties '(bottom-border ())
@@ -380,13 +386,28 @@ Examples:
            (list (list "soup" "gazpacho")
                  (list "soup" "tonjiru"))]
 
+  @tabular[#:pad '(1 0)
+           #:column-properties '(border)
+           (list (list "gazpacho" "cold")
+                 (list "tonjiru"  "hot"))]
+
   @tabular[#:style 'boxed
            #:column-properties '(left right)
            #:row-properties '(bottom-border ())
            (list (list @bold{recipe}   @bold{vegetable})
                  (list "caldo verde"   "kale")
                  (list "kinpira gobō"  "burdock")
                  (list "makizushi"     'cont))]]
+
+@history[#:changed "1.1" @elem{Added the @racket[#:column-properties],
+                               @racket[#:row-properties],
+                               and @racket[#:cell-properties] arguments.}
+         #:changed "1.12" @elem{Changed @racket[sep] insertion before a
+                                @racket['cont].}
+         #:changed "1.28" @elem{Added the @racket[sep-properties] argument and made
+                                the preceding column's properties used
+                                consistently if not specified.}
+         #:changed "1.59" @elem{Added the @racket[pad] argument.}]
 }
 
 @defproc[(verbatim [#:indent indent exact-nonnegative-integer? 0] [elem content?] ...+)

scribble-doc/scribblings/scribble/core.scrbl

@@ -1355,6 +1355,9 @@ The following are recognized as cell-@tech{style properties}:
  @item{@racket[background-color-property] structure --- For HTML,
        applies a color to the background of the cell.}
 
+ @item{@racket[cell-padding-property] structure --- Specifies padding
+       to add around a cell's content.}
+
  @item{@racket[attributes] --- Provides additional HTML attributes
        for the cell's @tt{<td>} tag.}
 
@@ -1382,6 +1385,15 @@ For HTML table rendering, for each column that has a
 within the table.}
 
 
+@defstruct[cell-padding-property ([left real?] [top real?] [right real?] [bottom real?])]{
+
+When used as a cell property for a @racket[table], specifies padding
+to add around the cell content. Padding is expressed in ``ex'' units,
+which corresponds roughly to the width of a character.
+
+@history[#:added "1.58"]}
+
+
 @deftogether[(
 @defstruct[box-mode ([top-name string?]
                      [center-name string?]

scribble-lib/info.rkt

@@ -23,7 +23,7 @@
 
 (define pkg-authors '(mflatt eli))
 
-(define version "1.57")
+(define version "1.58")
 
 (define license
   '((Apache-2.0 OR MIT)

scribble-lib/scribble/base.rkt

@@ -338,6 +338,7 @@
                 compound-paragraph?)]
  [tabular (->* ((listof (listof (or/c 'cont block? content?))))
                (#:style (or/c style? string? symbol? #f)
+                #:pad (or/c real? (list/c real? real?) (list/c real? real? real? real?))
                 #:sep (or/c content? block? #f)
                 #:column-properties (listof any/c)
                 #:row-properties (listof any/c)
@@ -364,6 +365,7 @@
                            (decode-flow c)))
 
 (define (tabular #:style [style #f]
+                 #:pad [pad 0]
                  #:sep [sep #f]
                  #:sep-properties [sep-props #f]
                  #:column-properties [column-properties null]
@@ -486,7 +488,7 @@
                 (define all-column-properties
                   (and (pair? column-properties)
                        full-column-properties))
-                ;; Will werge `cell-properties` and `column-properties` into
+                ;; Will merge `cell-properties` and `column-properties` into
                 ;; `s`. Start by finding any existing `table-columns`
                 ;; and `table-cells` properties with the right number of
                 ;; styles:
@@ -510,6 +512,21 @@
                                                    (table-cells-styless tl)))
                                       tl
                                       #f))))
+                (define pad-prop
+                  (cond
+                    [(number? pad)
+                     (and (not (= 0 pad)) (cell-padding-property pad pad pad pad))]
+                    [(= 2 (length pad))
+                     (and (not (= 0 (car pad) (cadr pad)))
+                          (cell-padding-property (car pad) (cadr pad) (car pad) (cadr pad)))]
+                    [(not (= 0 (list-ref pad 0) (list-ref pad 1) (list-ref pad 2) (list-ref pad 3)))
+                     (cell-padding-property (list-ref pad 0) (list-ref pad 1)
+                                            (list-ref pad 2) (list-ref pad 3))]))
+                (define (add-padding props)
+                  (if (or (not pad-prop)
+                          (ormap cell-padding-property? props))
+                      props
+                      (cons pad-prop props)))
                 ;; Merge:
                 (define (cons-maybe v l) (if v (cons v l) l))
                 (make-style (style-name s)
@@ -520,22 +537,31 @@
                                        (for/list ([ps (in-list all-column-properties)]
                                                   [cs (in-list (table-columns-styles tc))])
                                          (make-style (style-name cs)
-                                                     (append ps (style-properties cs))))
+                                                     (add-padding
+                                                      (append ps (style-properties cs)))))
                                        (for/list ([ps (in-list all-column-properties)])
-                                         (make-style #f ps)))))
+                                         (make-style #f (add-padding ps))))))
                              (cons-maybe
-                              (and all-cell-properties
-                                   (table-cells
-                                    (if tl
-                                        (for/list ([pss (in-list all-cell-properties)]
-                                                   [css (in-list (table-cells-styless tl))])
-                                          (for/list ([ps (in-list pss)]
-                                                     [cs (in-list css)])
-                                            (make-style (style-name cs)
-                                                        (append ps (style-properties cs)))))
-                                        (for/list ([pss (in-list all-cell-properties)])
-                                          (for/list ([ps (in-list pss)])
-                                            (make-style #f ps))))))
+                              (if all-cell-properties
+                                  (table-cells
+                                   (if tl
+                                       (for/list ([pss (in-list all-cell-properties)]
+                                                  [css (in-list (table-cells-styless tl))])
+                                         (for/list ([ps (in-list pss)]
+                                                    [cs (in-list css)])
+                                           (make-style (style-name cs)
+                                                       (add-padding
+                                                        (append ps (style-properties cs))))))
+                                       (for/list ([pss (in-list all-cell-properties)])
+                                         (for/list ([ps (in-list pss)])
+                                           (make-style #f (add-padding ps))))))
+                                  (if (and pad-prop
+                                           (not all-column-properties))
+                                      (table-cells
+                                       (for/list ([row (in-list cells)])
+                                         (for/list ([cell (in-list row)])
+                                           (make-style #f (list pad-prop)))))
+                                      #f))
                               (remq tc (remq tl props))))))
               ;; Process cells:
               (map (lambda (row)

scribble-lib/scribble/core.rkt

@@ -299,6 +299,7 @@
  [color-property ([color (or/c string? (list/c byte? byte? byte?))])]
  [background-color-property ([color (or/c string? (list/c byte? byte? byte?))])]
  [numberer-property ([numberer numberer?] [argument any/c])]
+ [cell-padding-property ([left real?] [top real?] [right real?] [bottom real?])]
 
  [table-columns ([styles (listof style?)])]
  [table-cells ([styless (listof (listof style?))])]

scribble-lib/scribble/html-render.rkt

@@ -184,6 +184,13 @@
                       `((style ,(format "background-color: ~a" (color->string (background-color-property-color v)))))]
                      [(hover-property? v)
                       `((title ,(hover-property-text v)))]
+                     [(cell-padding-property? v)
+                      (define (ex n) (exact->inexact n))
+                      `((style ,(format "padding: ~aex ~aex ~aex ~aex;"
+                                        (ex (cell-padding-property-top v))
+                                        (ex (cell-padding-property-right v))
+                                        (ex (cell-padding-property-bottom v))
+                                        (ex (cell-padding-property-left v)))))]
                      [else null]))
                   (style-properties style))))])
     (let ([name (style-name style)])
@@ -1735,7 +1742,8 @@
                                                 (filter (lambda (a)
                                                           (or (attributes? a)
                                                               (color-property? a)
-                                                              (background-color-property? a)))
+                                                              (background-color-property? a)
+                                                              (cell-padding-property? a)))
                                                         (style-properties column-style)))
                                                (let ([ps (style-properties column-style)])
                                                  (cond