Fix further problems with quoted file names in Tramp
[emacs.git] / lisp / emacs-lisp / tabulated-list.el
blob9523d5e89e31d5cba2d34ac3c3e56c6a970a974e
1 ;;; tabulated-list.el --- generic major mode for tabulated lists -*- lexical-binding: t -*-
3 ;; Copyright (C) 2011-2016 Free Software Foundation, Inc.
5 ;; Author: Chong Yidong <cyd@stupidchicken.com>
6 ;; Keywords: extensions, lisp
7 ;; Version: 1.0
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
24 ;;; Commentary:
26 ;; This file defines Tabulated List mode, a generic major mode for
27 ;; displaying lists of tabulated data, intended for other major modes
28 ;; to inherit from. It provides several utility routines, e.g. for
29 ;; pretty-printing lines of tabulated data to fit into the appropriate
30 ;; columns.
32 ;; For usage information, see the documentation of `tabulated-list-mode'.
34 ;; This package originated from Tom Tromey's Package Menu mode,
35 ;; extended and generalized to be used by other modes.
37 ;;; Code:
39 ;; The reason `tabulated-list-format' and other variables are
40 ;; permanent-local is to make it convenient to switch to a different
41 ;; major mode, switch back, and have the original Tabulated List data
42 ;; still valid. See, for example, ebuff-menu.el.
44 (defvar-local tabulated-list-format nil
45 "The format of the current Tabulated List mode buffer.
46 This should be a vector of elements (NAME WIDTH SORT . PROPS),
47 where:
48 - NAME is a string describing the column.
49 This is the label for the column in the header line.
50 Different columns must have non-`equal' names.
51 - WIDTH is the width to reserve for the column.
52 For the final element, its numerical value is ignored.
53 - SORT specifies how to sort entries by this column.
54 If nil, this column cannot be used for sorting.
55 If t, sort by comparing the string value printed in the column.
56 Otherwise, it should be a predicate function suitable for
57 `sort', accepting arguments with the same form as the elements
58 of `tabulated-list-entries'.
59 - PROPS is a plist of additional column properties.
60 Currently supported properties are:
61 - `:right-align': If non-nil, the column should be right-aligned.
62 - `:pad-right': Number of additional padding spaces to the
63 right of the column (defaults to 1 if omitted).")
64 (put 'tabulated-list-format 'permanent-local t)
66 (defvar-local tabulated-list-use-header-line t
67 "Whether the Tabulated List buffer should use a header line.")
69 (defvar-local tabulated-list-entries nil
70 "Entries displayed in the current Tabulated List buffer.
71 This should be either a function, or a list.
72 If a list, each element has the form (ID [DESC1 ... DESCN]),
73 where:
74 - ID is nil, or a Lisp object uniquely identifying this entry,
75 which is used to keep the cursor on the \"same\" entry when
76 rearranging the list. Comparison is done with `equal'.
78 - Each DESC is a column descriptor, one for each column
79 specified in `tabulated-list-format'. A descriptor is either
80 a string, which is printed as-is, or a list (LABEL . PROPS),
81 which means to use `insert-text-button' to insert a text
82 button with label LABEL and button properties PROPS.
83 The string, or button label, must not contain any newline.
85 If `tabulated-list-entries' is a function, it is called with no
86 arguments and must return a list of the above form.")
87 (put 'tabulated-list-entries 'permanent-local t)
89 (defvar-local tabulated-list-padding 0
90 "Number of characters preceding each Tabulated List mode entry.
91 By default, lines are padded with spaces, but you can use the
92 function `tabulated-list-put-tag' to change this.")
93 (put 'tabulated-list-padding 'permanent-local t)
95 (defvar tabulated-list-revert-hook nil
96 "Hook run before reverting a Tabulated List buffer.
97 This is commonly used to recompute `tabulated-list-entries'.")
99 (defvar-local tabulated-list-printer 'tabulated-list-print-entry
100 "Function for inserting a Tabulated List entry at point.
101 It is called with two arguments, ID and COLS. ID is a Lisp
102 object identifying the entry, and COLS is a vector of column
103 descriptors, as documented in `tabulated-list-entries'.")
105 (defvar tabulated-list--near-rows)
107 (defvar-local tabulated-list-sort-key nil
108 "Sort key for the current Tabulated List mode buffer.
109 If nil, no additional sorting is performed.
110 Otherwise, this should be a cons cell (NAME . FLIP).
111 NAME is a string matching one of the column names in
112 `tabulated-list-format' (the corresponding SORT entry in
113 `tabulated-list-format' then specifies how to sort). FLIP, if
114 non-nil, means to invert the resulting sort.")
115 (put 'tabulated-list-sort-key 'permanent-local t)
117 (defsubst tabulated-list-get-id (&optional pos)
118 "Return the entry ID of the Tabulated List entry at POS.
119 The value is an ID object from `tabulated-list-entries', or nil.
120 POS, if omitted or nil, defaults to point."
121 (get-text-property (or pos (point)) 'tabulated-list-id))
123 (defsubst tabulated-list-get-entry (&optional pos)
124 "Return the Tabulated List entry at POS.
125 The value is a vector of column descriptors, or nil if there is
126 no entry at POS. POS, if omitted or nil, defaults to point."
127 (get-text-property (or pos (point)) 'tabulated-list-entry))
129 (defun tabulated-list-put-tag (tag &optional advance)
130 "Put TAG in the padding area of the current line.
131 TAG should be a string, with length <= `tabulated-list-padding'.
132 If ADVANCE is non-nil, move forward by one line afterwards."
133 (unless (stringp tag)
134 (error "Invalid argument to `tabulated-list-put-tag'"))
135 (unless (> tabulated-list-padding 0)
136 (error "Unable to tag the current line"))
137 (save-excursion
138 (beginning-of-line)
139 (when (tabulated-list-get-entry)
140 (let ((beg (point))
141 (inhibit-read-only t))
142 (forward-char tabulated-list-padding)
143 (insert-and-inherit
144 (let ((width (string-width tag)))
145 (if (<= width tabulated-list-padding)
146 (concat tag
147 (make-string (- tabulated-list-padding width) ?\s))
148 (truncate-string-to-width tag tabulated-list-padding))))
149 (delete-region beg (+ beg tabulated-list-padding)))))
150 (if advance
151 (forward-line)))
153 (defvar tabulated-list-mode-map
154 (let ((map (copy-keymap special-mode-map)))
155 (set-keymap-parent map button-buffer-map)
156 (define-key map "n" 'next-line)
157 (define-key map "p" 'previous-line)
158 (define-key map "S" 'tabulated-list-sort)
159 (define-key map [follow-link] 'mouse-face)
160 (define-key map [mouse-2] 'mouse-select-window)
161 map)
162 "Local keymap for `tabulated-list-mode' buffers.")
164 (defvar tabulated-list-sort-button-map
165 (let ((map (make-sparse-keymap)))
166 (define-key map [header-line mouse-1] 'tabulated-list-col-sort)
167 (define-key map [header-line mouse-2] 'tabulated-list-col-sort)
168 (define-key map [mouse-1] 'tabulated-list-col-sort)
169 (define-key map [mouse-2] 'tabulated-list-col-sort)
170 (define-key map "\C-m" 'tabulated-list-sort)
171 (define-key map [follow-link] 'mouse-face)
172 map)
173 "Local keymap for `tabulated-list-mode' sort buttons.")
175 (defvar tabulated-list-glyphless-char-display
176 (let ((table (make-char-table 'glyphless-char-display nil)))
177 (set-char-table-parent table glyphless-char-display)
178 ;; Some text terminals can't display the Unicode arrows; be safe.
179 (aset table 9650 (cons nil "^"))
180 (aset table 9660 (cons nil "v"))
181 table)
182 "The `glyphless-char-display' table in Tabulated List buffers.")
184 (defvar tabulated-list--header-string nil
185 "Holds the header if `tabulated-list-use-header-line' is nil.
186 Populated by `tabulated-list-init-header'.")
187 (defvar tabulated-list--header-overlay nil)
189 (defun tabulated-list-init-header ()
190 "Set up header line for the Tabulated List buffer."
191 ;; FIXME: Should share code with tabulated-list-print-col!
192 (let ((x (max tabulated-list-padding 0))
193 (button-props `(help-echo "Click to sort by column"
194 mouse-face highlight
195 keymap ,tabulated-list-sort-button-map))
196 (cols nil))
197 (push (propertize " " 'display `(space :align-to ,x)) cols)
198 (dotimes (n (length tabulated-list-format))
199 (let* ((col (aref tabulated-list-format n))
200 (label (nth 0 col))
201 (width (nth 1 col))
202 (props (nthcdr 3 col))
203 (pad-right (or (plist-get props :pad-right) 1))
204 (right-align (plist-get props :right-align))
205 (next-x (+ x pad-right width)))
206 (push
207 (cond
208 ;; An unsortable column
209 ((not (nth 2 col))
210 (propertize label 'tabulated-list-column-name label))
211 ;; The selected sort column
212 ((equal (car col) (car tabulated-list-sort-key))
213 (apply 'propertize
214 (concat label
215 (cond
216 ((> (+ 2 (length label)) width) "")
217 ((cdr tabulated-list-sort-key) " ▲")
218 (t " ▼")))
219 'face 'bold
220 'tabulated-list-column-name label
221 button-props))
222 ;; Unselected sortable column.
223 (t (apply 'propertize label
224 'tabulated-list-column-name label
225 button-props)))
226 cols)
227 (when right-align
228 (let ((shift (- width (string-width (car cols)))))
229 (when (> shift 0)
230 (setq cols
231 (cons (car cols)
232 (cons (propertize (make-string shift ?\s)
233 'display
234 `(space :align-to ,(+ x shift)))
235 (cdr cols))))
236 (setq x (+ x shift)))))
237 (if (>= pad-right 0)
238 (push (propertize " "
239 'display `(space :align-to ,next-x)
240 'face 'fixed-pitch)
241 cols))
242 (setq x next-x)))
243 (setq cols (apply 'concat (nreverse cols)))
244 (if tabulated-list-use-header-line
245 (setq header-line-format cols)
246 (setq header-line-format nil)
247 (setq-local tabulated-list--header-string cols))))
249 (defun tabulated-list-print-fake-header ()
250 "Insert a fake Tabulated List \"header line\" at the start of the buffer.
251 Do nothing if `tabulated-list--header-string' is nil."
252 (when tabulated-list--header-string
253 (goto-char (point-min))
254 (let ((inhibit-read-only t))
255 (insert tabulated-list--header-string "\n")
256 (if tabulated-list--header-overlay
257 (move-overlay tabulated-list--header-overlay (point-min) (point))
258 (setq-local tabulated-list--header-overlay
259 (make-overlay (point-min) (point))))
260 (overlay-put tabulated-list--header-overlay 'face 'underline))))
262 (defsubst tabulated-list-header-overlay-p (&optional pos)
263 "Return non-nil if there is a fake header.
264 Optional arg POS is a buffer position where to look for a fake header;
265 defaults to `point-min'."
266 (overlays-at (or pos (point-min))))
268 (defun tabulated-list-revert (&rest ignored)
269 "The `revert-buffer-function' for `tabulated-list-mode'.
270 It runs `tabulated-list-revert-hook', then calls `tabulated-list-print'."
271 (interactive)
272 (unless (derived-mode-p 'tabulated-list-mode)
273 (error "The current buffer is not in Tabulated List mode"))
274 (run-hooks 'tabulated-list-revert-hook)
275 (tabulated-list-print t))
277 (defun tabulated-list--column-number (name)
278 (let ((len (length tabulated-list-format))
279 (n 0)
280 found)
281 (while (and (< n len) (null found))
282 (if (equal (car (aref tabulated-list-format n)) name)
283 (setq found n))
284 (setq n (1+ n)))
285 (or found
286 (error "No column named %s" name))))
288 (defun tabulated-list--get-sorter ()
289 "Return a sorting predicate for the current tabulated-list.
290 Return nil if `tabulated-list-sort-key' specifies an unsortable
291 column. Negate the predicate that would be returned if
292 `tabulated-list-sort-key' has a non-nil cdr."
293 (when (and tabulated-list-sort-key
294 (car tabulated-list-sort-key))
295 (let* ((sort-column (car tabulated-list-sort-key))
296 (n (tabulated-list--column-number sort-column))
297 (sorter (nth 2 (aref tabulated-list-format n))))
298 (when (eq sorter t); Default sorter checks column N:
299 (setq sorter (lambda (A B)
300 (let ((a (aref (cadr A) n))
301 (b (aref (cadr B) n)))
302 (string< (if (stringp a) a (car a))
303 (if (stringp b) b (car b)))))))
304 ;; Reversed order.
305 (if (cdr tabulated-list-sort-key)
306 (lambda (a b) (not (funcall sorter a b)))
307 sorter))))
309 (defsubst tabulated-list--col-local-max-widths (col)
310 "Return maximum entry widths at column COL around current row.
311 Check the current row, the previous one and the next row."
312 (apply #'max (mapcar (lambda (x)
313 (let ((nt (elt x col)))
314 (string-width (if (stringp nt) nt (car nt)))))
315 tabulated-list--near-rows)))
317 (defun tabulated-list-print (&optional remember-pos update)
318 "Populate the current Tabulated List mode buffer.
319 This sorts the `tabulated-list-entries' list if sorting is
320 specified by `tabulated-list-sort-key'. It then erases the
321 buffer and inserts the entries with `tabulated-list-printer'.
323 Optional argument REMEMBER-POS, if non-nil, means to move point
324 to the entry with the same ID element as the current line and
325 recenter window line accordingly.
327 Non-nil UPDATE argument means to use an alternative printing
328 method which is faster if most entries haven't changed since the
329 last print. The only difference in outcome is that tags will not
330 be removed from entries that haven't changed (see
331 `tabulated-list-put-tag'). Don't use this immediately after
332 changing `tabulated-list-sort-key'."
333 (let ((inhibit-read-only t)
334 (entries (if (functionp tabulated-list-entries)
335 (funcall tabulated-list-entries)
336 tabulated-list-entries))
337 (sorter (tabulated-list--get-sorter))
338 entry-id saved-pt saved-col window-line)
339 (and remember-pos
340 (setq entry-id (tabulated-list-get-id))
341 (setq saved-col (current-column))
342 (when (eq (window-buffer) (current-buffer))
343 (setq window-line
344 (count-screen-lines (window-start) (point)))))
345 ;; Sort the entries, if necessary.
346 (when sorter
347 (setq entries (sort entries sorter)))
348 (unless (functionp tabulated-list-entries)
349 (setq tabulated-list-entries entries))
350 ;; Without a sorter, we have no way to just update.
351 (when (and update (not sorter))
352 (setq update nil))
353 (if update (goto-char (point-min))
354 ;; Redo the buffer, unless we're just updating.
355 (erase-buffer)
356 (unless tabulated-list-use-header-line
357 (tabulated-list-print-fake-header)))
358 ;; Finally, print the resulting list.
359 (while entries
360 (let* ((elt (car entries))
361 (tabulated-list--near-rows
362 (list
363 (or (tabulated-list-get-entry (point-at-bol 0)) (cadr elt))
364 (cadr elt)
365 (or (cadr (cadr entries)) (cadr elt))))
366 (id (car elt)))
367 (and entry-id
368 (equal entry-id id)
369 (setq entry-id nil
370 saved-pt (point)))
371 ;; If the buffer this empty, simply print each elt.
372 (if (or (not update) (eobp))
373 (apply tabulated-list-printer elt)
374 (while (let ((local-id (tabulated-list-get-id)))
375 ;; If we find id, then nothing to update.
376 (cond ((equal id local-id)
377 (forward-line 1)
378 nil)
379 ;; If this entry sorts after id (or it's the
380 ;; end), then just insert id and move on.
381 ((or (not local-id)
382 (funcall sorter elt
383 ;; FIXME: Might be faster if
384 ;; don't construct this list.
385 (list local-id (tabulated-list-get-entry))))
386 (apply tabulated-list-printer elt)
387 nil)
388 ;; We find an entry that sorts before id,
389 ;; it needs to be deleted.
390 (t t)))
391 (let ((old (point)))
392 (forward-line 1)
393 (delete-region old (point))))))
394 (setq entries (cdr entries)))
395 (set-buffer-modified-p nil)
396 ;; If REMEMBER-POS was specified, move to the "old" location.
397 (if saved-pt
398 (progn (goto-char saved-pt)
399 (move-to-column saved-col)
400 (when window-line
401 (recenter window-line)))
402 (goto-char (point-min)))))
404 (defun tabulated-list-print-entry (id cols)
405 "Insert a Tabulated List entry at point.
406 This is the default `tabulated-list-printer' function. ID is a
407 Lisp object identifying the entry to print, and COLS is a vector
408 of column descriptors."
409 (let ((beg (point))
410 (x (max tabulated-list-padding 0))
411 (ncols (length tabulated-list-format))
412 (inhibit-read-only t))
413 (if (> tabulated-list-padding 0)
414 (insert (make-string x ?\s)))
415 (dotimes (n ncols)
416 (setq x (tabulated-list-print-col n (aref cols n) x)))
417 (insert ?\n)
418 ;; Ever so slightly faster than calling `put-text-property' twice.
419 (add-text-properties
420 beg (point)
421 `(tabulated-list-id ,id tabulated-list-entry ,cols))))
423 (defun tabulated-list-print-col (n col-desc x)
424 "Insert a specified Tabulated List entry at point.
425 N is the column number, COL-DESC is a column descriptor (see
426 `tabulated-list-entries'), and X is the column number at point.
427 Return the column number after insertion."
428 (let* ((format (aref tabulated-list-format n))
429 (name (nth 0 format))
430 (width (nth 1 format))
431 (props (nthcdr 3 format))
432 (pad-right (or (plist-get props :pad-right) 1))
433 (right-align (plist-get props :right-align))
434 (label (if (stringp col-desc) col-desc (car col-desc)))
435 (label-width (string-width label))
436 (help-echo (concat (car format) ": " label))
437 (opoint (point))
438 (not-last-col (< (1+ n) (length tabulated-list-format)))
439 available-space)
440 (when not-last-col
441 (let* ((next-col-format (aref tabulated-list-format (1+ n)))
442 (next-col-right-align (plist-get (nthcdr 3 next-col-format)
443 :right-align))
444 (next-col-width (nth 1 next-col-format)))
445 (setq available-space
446 (if (and (not right-align)
447 next-col-right-align)
449 (+ width next-col-width)
450 (min next-col-width
451 (tabulated-list--col-local-max-widths (1+ n))))
452 width))))
453 ;; Truncate labels if necessary (except last column).
454 ;; Don't truncate to `width' if the next column is align-right
455 ;; and has some space left, truncate to `available-space' instead.
456 (when (and not-last-col
457 (> label-width available-space)
458 (setq label (truncate-string-to-width
459 label available-space nil nil t)
460 label-width available-space)))
461 (setq label (bidi-string-mark-left-to-right label))
462 (when (and right-align (> width label-width))
463 (let ((shift (- width label-width)))
464 (insert (propertize (make-string shift ?\s)
465 'display `(space :align-to ,(+ x shift))))
466 (setq width (- width shift))
467 (setq x (+ x shift))))
468 (if (stringp col-desc)
469 (insert (if (get-text-property 0 'help-echo label)
470 label
471 (propertize label 'help-echo help-echo)))
472 (apply 'insert-text-button label (cdr col-desc)))
473 (let ((next-x (+ x pad-right width)))
474 ;; No need to append any spaces if this is the last column.
475 (when not-last-col
476 (when (> pad-right 0) (insert (make-string pad-right ?\s)))
477 (insert (propertize
478 (make-string (- width (min width label-width)) ?\s)
479 'display `(space :align-to ,next-x))))
480 (put-text-property opoint (point) 'tabulated-list-column-name name)
481 next-x)))
483 (defun tabulated-list-delete-entry ()
484 "Delete the Tabulated List entry at point.
485 Return a list (ID COLS), where ID is the ID of the deleted entry
486 and COLS is a vector of its column descriptors. Move point to
487 the beginning of the deleted entry. Return nil if there is no
488 entry at point.
490 This function only changes the buffer contents; it does not alter
491 `tabulated-list-entries'."
492 ;; Assume that each entry occupies one line.
493 (let* ((id (tabulated-list-get-id))
494 (cols (tabulated-list-get-entry))
495 (inhibit-read-only t))
496 (when cols
497 (delete-region (line-beginning-position) (1+ (line-end-position)))
498 (list id cols))))
500 (defun tabulated-list-set-col (col desc &optional change-entry-data)
501 "Change the Tabulated List entry at point, setting COL to DESC.
502 COL is the column number to change, or the name of the column to change.
503 DESC is the new column descriptor, which is inserted via
504 `tabulated-list-print-col'.
506 If CHANGE-ENTRY-DATA is non-nil, modify the underlying entry data
507 by setting the appropriate slot of the vector originally used to
508 print this entry. If `tabulated-list-entries' has a list value,
509 this is the vector stored within it."
510 (let* ((opoint (point))
511 (eol (line-end-position))
512 (pos (line-beginning-position))
513 (id (tabulated-list-get-id pos))
514 (entry (tabulated-list-get-entry pos))
515 (prop 'tabulated-list-column-name)
516 (inhibit-read-only t)
517 name)
518 (cond ((numberp col)
519 (setq name (car (aref tabulated-list-format col))))
520 ((stringp col)
521 (setq name col
522 col (tabulated-list--column-number col)))
524 (error "Invalid column %s" col)))
525 (unless entry
526 (error "No Tabulated List entry at position %s" opoint))
527 (unless (equal (get-text-property pos prop) name)
528 (while (and (setq pos
529 (next-single-property-change pos prop nil eol))
530 (< pos eol)
531 (not (equal (get-text-property pos prop) name)))))
532 (when (< pos eol)
533 (delete-region pos (next-single-property-change pos prop nil eol))
534 (goto-char pos)
535 (let ((tabulated-list--near-rows
536 (list
537 (tabulated-list-get-entry (point-at-bol 0))
538 entry
539 (or (tabulated-list-get-entry (point-at-bol 2)) entry))))
540 (tabulated-list-print-col col desc (current-column)))
541 (if change-entry-data
542 (aset entry col desc))
543 (put-text-property pos (point) 'tabulated-list-id id)
544 (put-text-property pos (point) 'tabulated-list-entry entry)
545 (goto-char opoint))))
547 (defun tabulated-list-col-sort (&optional e)
548 "Sort Tabulated List entries by the column of the mouse click E."
549 (interactive "e")
550 (let* ((pos (event-start e))
551 (obj (posn-object pos)))
552 (with-current-buffer (window-buffer (posn-window pos))
553 (tabulated-list--sort-by-column-name
554 (get-text-property (if obj (cdr obj) (posn-point pos))
555 'tabulated-list-column-name
556 (car obj))))))
558 (defun tabulated-list-sort (&optional n)
559 "Sort Tabulated List entries by the column at point.
560 With a numeric prefix argument N, sort the Nth column."
561 (interactive "P")
562 (let ((name (if n
563 (car (aref tabulated-list-format n))
564 (get-text-property (point)
565 'tabulated-list-column-name))))
566 (if (nth 2 (assoc name (append tabulated-list-format nil)))
567 (tabulated-list--sort-by-column-name name)
568 (user-error "Cannot sort by %s" name))))
570 (defun tabulated-list--sort-by-column-name (name)
571 (when (and name (derived-mode-p 'tabulated-list-mode))
572 ;; Flip the sort order on a second click.
573 (if (equal name (car tabulated-list-sort-key))
574 (setcdr tabulated-list-sort-key
575 (not (cdr tabulated-list-sort-key)))
576 (setq tabulated-list-sort-key (cons name nil)))
577 (tabulated-list-init-header)
578 (tabulated-list-print t)))
580 ;;; The mode definition:
582 (define-derived-mode tabulated-list-mode special-mode "Tabulated"
583 "Generic major mode for browsing a list of items.
584 This mode is usually not used directly; instead, other major
585 modes are derived from it, using `define-derived-mode'.
587 In this major mode, the buffer is divided into multiple columns,
588 which are labeled using the header line. Each non-empty line
589 belongs to one \"entry\", and the entries can be sorted according
590 to their column values.
592 An inheriting mode should usually do the following in their body:
594 - Set `tabulated-list-format', specifying the column format.
595 - Set `tabulated-list-revert-hook', if the buffer contents need
596 to be specially recomputed prior to `revert-buffer'.
597 - Maybe set a `tabulated-list-entries' function (see below).
598 - Maybe set `tabulated-list-printer' (see below).
599 - Maybe set `tabulated-list-padding'.
600 - Call `tabulated-list-init-header' to initialize `header-line-format'
601 according to `tabulated-list-format'.
603 An inheriting mode is usually accompanied by a \"list-FOO\"
604 command (e.g. `list-packages', `list-processes'). This command
605 creates or switches to a buffer and enables the major mode in
606 that buffer. If `tabulated-list-entries' is not a function, the
607 command should initialize it to a list of entries for displaying.
608 Finally, it should call `tabulated-list-print'.
610 `tabulated-list-print' calls the printer function specified by
611 `tabulated-list-printer', once for each entry. The default
612 printer is `tabulated-list-print-entry', but a mode that keeps
613 data in an ewoc may instead specify a printer function (e.g., one
614 that calls `ewoc-enter-last'), with `tabulated-list-print-entry'
615 as the ewoc pretty-printer."
616 (setq-local truncate-lines t)
617 (setq-local buffer-undo-list t)
618 (setq-local revert-buffer-function #'tabulated-list-revert)
619 (setq-local glyphless-char-display tabulated-list-glyphless-char-display)
620 ;; Avoid messing up the entries' display just because the first
621 ;; column of the first entry happens to begin with a R2L letter.
622 (setq bidi-paragraph-direction 'left-to-right))
624 (put 'tabulated-list-mode 'mode-class 'special)
626 (provide 'tabulated-list)
628 ;;; tabulated-list.el ends here