-;;; org-list.el --- Plain lists for Org-mode

-;; This file contains the code dealing with plain lists in Org-mode.

-(eval-when-compile

- (require 'cl))

-(defvar org-drawers)

-(declare-function outline-invisible-p "outline" (&optional pos))

-(declare-function outline-flag-region "outline" (from to flag))

-(declare-function outline-next-heading "outline" ())

-(declare-function outline-previous-heading "outline" ())

-

-(declare-function org-at-heading-p "org" (&optional ignored))

-(declare-function org-before-first-heading-p "org" ())

-(declare-function org-count "org" (cl-item cl-seq))

-(declare-function org-icompleting-read "org" (&rest args))

-(declare-function org-at-heading-p "org" (&optional invisible-ok))

-(declare-function org-previous-line-empty-p "org" (&optional next))

-(declare-function org-remove-if "org" (predicate seq))

-(declare-function org-trim "org" (s))

-

-(declare-function org-inlinetask-goto-beginning "org-inlinetask" ())

-(declare-function org-inlinetask-goto-end "org-inlinetask" ())

-(declare-function org-inlinetask-in-task-p "org-inlinetask" ())

-(declare-function org-inlinetask-outline-regexp "org-inlinetask" ())

-

-(declare-function org-export-string-as "ox"

- (string backend &optional body-only ext-plist))

-

- "Options concerning plain lists in Org-mode."

-Valid values are ?. and ?\). To get both terminators, use t."

- (const :tag "both" t)))

-(define-obsolete-variable-alias 'org-alphabetical-lists

- 'org-list-allow-alphabetical "24.4") ; Since 8.0

- (when (featurep \\='org-element) (load \"org-element\" t t))"

- :set (lambda (var val)

- (when (featurep 'org-element) (load "org-element" t t))

- (set var val)))

-(define-obsolete-variable-alias 'org-empty-line-terminates-plain-lists

- 'org-list-empty-line-terminates-plain-lists "24.4") ;; Since 8.0

-(defcustom org-list-empty-line-terminates-plain-lists nil

- "Non-nil means an empty line ends all plain list levels.

-Otherwise, two of them will be necessary."

- :group 'org-plain-lists

- :type 'boolean)

-

- \\[org-meta-return], \\[org-metaright], \\[org-metaleft],

- \\[org-shiftmetaright], \\[org-shiftmetaleft],

- \\[org-ctrl-c-minus], \\[org-toggle-checkbox] or

- \\[org-insert-todo-heading]. You can disable individually these

- rules by setting them to nil. Valid rules are:

-

-This affects the behavior of \\[org-move-item-up],

- \\[org-move-item-down], \\[org-next-item] and

- \\[org-previous-item]."

-(define-obsolete-variable-alias 'org-hierarchical-checkbox-statistics

- 'org-checkbox-hierarchical-statistics "24.4") ;; Since 8.0

-(org-defvaralias 'org-description-max-indent

- 'org-list-description-max-indent) ;; Since 8.0

-(defvar org-list-forbidden-blocks '("example" "verse" "src" "ascii" "beamer"

- "html" "latex" "odt")

-(defconst org-list-end-re (if org-list-empty-line-terminates-plain-lists "^[ \t]*\n"

- "^[ \t]*\n[ \t]*\n")

- "Regex corresponding to the end of a list.

-It depends on `org-list-empty-line-terminates-plain-lists'.")

- (drawers-re (concat "^[ \t]*:\\("

- (mapconcat #'regexp-quote org-drawers "\\|")

- "\\):[ \t]*$"))

- (re-search-backward drawers-re lim-up t))

- ;; Can't use org-drawers-regexp as this function might

- ;; be called in buffers not in Org mode.

- (beg-re (concat "^[ \t]*:\\("

- (mapconcat #'regexp-quote org-drawers "\\|")

- "\\):[ \t]*$")))

- (drawers-re (concat "^[ \t]*:\\("

- (mapconcat #'regexp-quote org-drawers "\\|")

- "\\):[ \t]*$"))

- (and (save-match-data (string-match "[-+*]" bullet))

- (re-search-backward drawers-re lim-up t))

- ((and (looking-at drawers-re)

- ((string-match "[[:alnum:]]" (org-list-get-bullet first struct)) 'ordered)

- (incf seq))

- (overlays (cons

- (mapcar (lambda (ov)

- (list ov (overlay-start ov) (overlay-end ov)))

- (overlays-in beg-A end-A))

- (mapcar (lambda (ov)

- (list ov (overlay-start ov) (overlay-end ov)))

- (overlays-in beg-B end-B)))))

- (mapc (lambda (e)

- (let ((pos (car e)))

- (cond

- ((< pos beg-A))

- ((memq pos sub-A)

- (let ((end-e (nth 6 e)))

- (setcar e (+ pos (- end-B-no-blank end-A-no-blank)))

- (setcar (nthcdr 6 e)

- (+ end-e (- end-B-no-blank end-A-no-blank)))

- (when (= end-e end-A) (setcar (nthcdr 6 e) end-B))))

- ((memq pos sub-B)

- (let ((end-e (nth 6 e)))

- (setcar e (- (+ pos beg-A) beg-B))

- (setcar (nthcdr 6 e) (+ end-e (- beg-A beg-B)))

- (when (= end-e end-B)

- (setcar (nthcdr 6 e)

- (+ beg-A size-B (- end-A end-A-no-blank))))))

- ((< pos beg-B)

- (let ((end-e (nth 6 e)))

- (setcar e (+ pos (- size-B size-A)))

- (setcar (nthcdr 6 e) (+ end-e (- size-B size-A))))))))

- struct)

- (setq struct (sort struct (lambda (e1 e2) (< (car e1) (car e2)))))

- (mapc (lambda (ov)

- (move-overlay

- (car ov)

- (+ (nth 1 ov) (- (+ beg-B (- size-B size-A)) beg-A))

- (+ (nth 2 ov) (- (+ beg-B (- size-B size-A)) beg-A))))

- (car overlays))

- (mapc (lambda (ov)

- (move-overlay (car ov)

- (+ (nth 1 ov) (- beg-A beg-B))

- (+ (nth 2 ov) (- beg-A beg-B))))

- (cdr overlays))

- ((or org-list-empty-line-terminates-plain-lists (not insert-blank-p)) 0)

- ;; Do not count tag in a non-descriptive list.

- (<= pos (if (and (match-beginning 4)

- (save-match-data

- (string-match "[.)]" (match-string 1))))

- (match-beginning 4)

- (match-end 0)))))

- (org-indent-to-column ind)

- ((string-match "\\`[0-9]+\\'" dest)

- ;; Store visibility.

- (visibility (overlays-in item item-end)))

- (lambda (e1 e2) (< (car e1) (car e2))))))

- ;; 2. Restore visibility.

- (mapc (lambda (ov)

- (move-overlay ov

- (+ (overlay-start ov) (- (point) item))

- (+ (overlay-end ov) (- (point) item))))

- visibility)

- (if (and count (string-match "[a-zA-Z]" count))

- ;; Shift the indentation between END and BEG by DELTA. If

- ;; MAX-IND is non-nil, ensure that no line will be indented

- ;; more than that number. Start from the line before END.

- (lambda (end beg delta max-ind)

- ((org-looking-at-p "^[ \t]*\\S-")

- (let ((i (org-get-indentation)))

- (org-indent-line-to

- (if max-ind (min (+ i delta) max-ind) (+ i delta))))))

- (let ((item-up (assoc-default end-pos acc-end '>)))

- ;; (END BEG DELTA MAX-IND-OR-NIL). Slices are returned in

- ;; reverse order.

- '<))

- (item (if itemp up (cdr (assq up end-list))))

- (ind (cdr (assq item itm-shift)))

- ;; If we're not at an item, there's a child of the item

- ;; point belongs to above. Make sure this slice isn't

- ;; moved within that child by specifying a maximum

- ;; indentation.

- (max-ind (and (not itemp)

- (+ (org-list-get-ind item struct)

- (length (org-list-get-bullet item struct))

- org-list-indent-offset))))

- (push (list down up ind max-ind) sliced-struct)))

- (unless (and (zerop (nth 2 e)) (not (nth 3 e)))

- (apply shift-body-ind e))

- (let (bpos bcol tpos tcol)

- (save-excursion

- (goto-char item)

- (looking-at "[ \t]*\\(\\S-+\\)\\(.*[ \t]+::\\)?\\([ \t]+\\|$\\)")

- (setq bpos (match-beginning 1) tpos (match-end 0)

- bcol (progn (goto-char bpos) (current-column))

- tcol (progn (goto-char tpos) (current-column)))

- (when (> tcol (+ bcol org-description-max-indent))

- (setq tcol (+ bcol 5))))

- tcol))

- (outline-invisible-p)))

- (drawer-re (concat "^[ \t]*:\\("

- (mapconcat #'regexp-quote org-drawers "\\|")

- "\\):[ \t]*$"))

- (while (or (looking-at drawer-re) (looking-at keyword-re))

- (items-to-toggle (org-remove-if

- (save-excursion

- (let ((cookie-re "\\(\\(\\[[0-9]*%\\]\\)\\|\\(\\[[0-9]*/[0-9]*\\]\\)\\)")

- (box-re "^[ \t]*\\([-+*]\\|\\([0-9]+\\|[A-Za-z]\\)[.)]\\)[ \t]+\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ \t]*\\)?\\(\\[[- X]\\]\\)")

- (bounds (if all

- (cons (point-min) (point-max))

- (cons (or (ignore-errors (org-back-to-heading t) (point))

- (point-min))

- (save-excursion (outline-next-heading) (point)))))

- (function

- ;; Return number of checked boxes and boxes of all types

- ;; in all structures in STRUCTS. If RECURSIVEP is

- ;; non-nil, also count boxes in sub-lists. If ITEM is

- ;; nil, count across the whole structure, else count only

- ;; across subtree whose ancestor is ITEM.

- (lambda (item structs recursivep)

- (let ((c-on 0) (c-all 0))

- (mapc

- (lambda (s)

- (let* ((pre (org-list-prevs-alist s))

- (par (org-list-parents-alist s))

- (items

- (cond

- ((and recursivep item) (org-list-get-subtree item s))

- (recursivep (mapcar #'car s))

- (item (org-list-get-children item s par))

- (t (org-list-get-all-items

- (org-list-get-top-point s) s pre))))

- (cookies (delq nil (mapcar

- (lambda (e)

- (org-list-get-checkbox e s))

- items))))

- (setq c-all (+ (length cookies) c-all)

- c-on (+ (org-count "[X]" cookies) c-on))))

- structs)

- (cons c-on c-all)))))

- (backup-end 1)

- cookies-list structs-bak)

- (goto-char (car bounds))

- ;; 1. Build an alist for each cookie found within BOUNDS. The

- ;; key will be position at beginning of cookie and values

- ;; ending position, format of cookie, and a cell whose car is

- ;; number of checked boxes to report, and cdr total number of

- ;; boxes.

- (while (re-search-forward cookie-re (cdr bounds) t)

- (catch 'skip

- (save-excursion

- (push

- (list

- (match-beginning 1) ; cookie start

- (match-end 1) ; cookie end

- (match-string 2) ; percent?

- (cond ; boxes count

- ;; Cookie is at an heading, but specifically for todo,

- ;; not for checkboxes: skip it.

- ((and (org-at-heading-p)

- (string-match "\\<todo\\>"

- (downcase

- (or (org-entry-get nil "COOKIE_DATA") ""))))

- (throw 'skip nil))

- ;; Cookie is at an heading, but all lists before next

- ;; heading already have been read. Use data collected

- ;; in STRUCTS-BAK. This should only happen when

- ;; heading has more than one cookie on it.

- ((and (org-at-heading-p)

- (<= (save-excursion (outline-next-heading) (point))

- backup-end))

- (funcall count-boxes nil structs-bak recursivep))

- ;; Cookie is at a fresh heading. Grab structure of

- ;; every list containing a checkbox between point and

- ;; next headline, and save them in STRUCTS-BAK.

- ((org-at-heading-p)

- (setq backup-end (save-excursion

- (outline-next-heading) (point))

- structs-bak nil)

- (while (org-list-search-forward box-re backup-end 'move)

- (let* ((struct (org-list-struct))

- (bottom (org-list-get-bottom-point struct)))

- (push struct structs-bak)

- (goto-char bottom)))

- (funcall count-boxes nil structs-bak recursivep))

- ;; Cookie is at an item, and we already have list

- ;; structure stored in STRUCTS-BAK.

- ((and (org-at-item-p)

- (< (point-at-bol) backup-end)

- ;; Only lists in no special context are stored.

- (not (nth 2 (org-list-context))))

- (funcall count-boxes (point-at-bol) structs-bak recursivep))

- ;; Cookie is at an item, but we need to compute list

- ;; structure.

- ((org-at-item-p)

- (let ((struct (org-list-struct)))

- (setq backup-end (org-list-get-bottom-point struct)

- structs-bak (list struct)))

- (funcall count-boxes (point-at-bol) structs-bak recursivep))

- ;; Else, cookie found is at a wrong place. Skip it.

- (t (throw 'skip nil))))

- cookies-list))))

- ;; 2. Apply alist to buffer, in reverse order so positions stay

- ;; unchanged after cookie modifications.

- (mapc (lambda (cookie)

- (let* ((beg (car cookie))

- (end (nth 1 cookie))

- (percentp (nth 2 cookie))

- (checked (car (nth 3 cookie)))

- (total (cdr (nth 3 cookie)))

- (new (if percentp

- (format "[%d%%]" (floor (* 100.0 checked)

- (max 1 total)))

- (format "[%d/%d]" checked total))))

- (goto-char beg)

- (insert new)

- (delete-region (point) (+ (point) (- end beg)))

- (when org-auto-align-tags (org-fix-tags-on-the-fly))))

- (org-remove-if

- (org-indent-to-column (car org-tab-ind-state))

-(defun org-sort-list (&optional with-case sorting-type getkey-func compare-func)

-record. It must return either a string or a number that should

-serve as the sorting key for that record. It will then use

-COMPARE-FUNC to compare entries.

-ignores hidden links."

- (interactive "P")

- (or getkey-func

- (and (= (downcase sorting-type) ?f)

- (intern (org-icompleting-read "Sort using function: "

- obarray 'fboundp t nil nil))))))

- (let* ((dcst (downcase sorting-type))

- (case-fold-search nil)

- (sort-func (cond

- ((= dcst ?a) 'string<)

- ((= dcst ?f) compare-func)

- ((= dcst ?t) '<)

- ((= dcst ?x) 'string<)))

-(defun org-list-parse-list (&optional delete)

-a list whose car is counter, and cdr are strings and other

-sub-lists. Inside strings, check-boxes are replaced by

-\"[CBON]\", \"[CBOFF]\" and \"[CBTRANS]\".

-1. first item

- + sub-item one

- + [X] sub-item two

- more text in first item

-2. [@3] last item

-will be parsed as:

- (nil \"first item\"

- (unordered

- (nil \"sub-item one\")

- (nil \"[CBON] sub-item two\"))

- \"more text in first item\")

- (3 \"last item\"))

-

-Point is left at list end."

- (defvar parse-item) ;FIXME: Or use `cl-labels' or `letrec'.

- (let* ((struct (org-list-struct))

- (prevs (org-list-prevs-alist struct))

- (parents (org-list-parents-alist struct))

- (top (org-list-get-top-point struct))

- (bottom (org-list-get-bottom-point struct))

- out

- (get-text

- (function

- ;; Return text between BEG and END, trimmed, with

- ;; checkboxes replaced.

- (lambda (beg end)

- (let ((text (org-trim (buffer-substring beg end))))

- (if (string-match "\\`\\[\\([-X ]\\)\\]" text)

- (replace-match

- (let ((box (match-string 1 text)))

- (cond

- ((equal box " ") "CBOFF")

- ((equal box "-") "CBTRANS")

- (t "CBON")))

- t nil text 1)

- text)))))

- (parse-sublist

- (function

- ;; Return a list whose car is list type and cdr a list of

- ;; items' body.

- (lambda (e)

- (cons (org-list-get-list-type (car e) struct prevs)

- (mapcar parse-item e)))))

- (parse-item

- (function

- ;; Return a list containing counter of item, if any, text

- ;; and any sublist inside it.

- (lambda (e)

- (let ((start (save-excursion

- (goto-char e)

- (looking-at "[ \t]*\\S-+\\([ \t]+\\[@\\(start:\\)?\\([0-9]+\\|[a-zA-Z]\\)\\]\\)?[ \t]*")

- (match-end 0)))

- ;; Get counter number. For alphabetic counter, get

- ;; its position in the alphabet.

- (counter (let ((c (org-list-get-counter e struct)))

- (cond

- ((not c) nil)

- ((string-match "[A-Za-z]" c)

- (- (string-to-char (upcase (match-string 0 c)))

- 64))

- ((string-match "[0-9]+" c)

- (string-to-number (match-string 0 c))))))

- (childp (org-list-has-child-p e struct))

- (end (org-list-get-item-end e struct)))

- ;; If item has a child, store text between bullet and

- ;; next child, then recursively parse all sublists. At

- ;; the end of each sublist, check for the presence of

- ;; text belonging to the original item.

- (if childp

- (let* ((children (org-list-get-children e struct parents))

- (body (list (funcall get-text start childp))))

- (while children

- (let* ((first (car children))

- (sub (org-list-get-all-items first struct prevs))

- (last-c (car (last sub)))

- (last-end (org-list-get-item-end last-c struct)))

- (push (funcall parse-sublist sub) body)

- ;; Remove children from the list just parsed.

- (setq children (cdr (member last-c children)))

- ;; There is a chunk of text belonging to the

- ;; item if last child doesn't end where next

- ;; child starts or where item ends.

- (unless (= (or (car children) end) last-end)

- (push (funcall get-text

- last-end (or (car children) end))

- body))))

- (cons counter (nreverse body)))

- (list counter (funcall get-text start end))))))))

- (setq out (funcall parse-sublist (org-list-get-all-items top struct prevs)))

- (goto-char top)

- (when delete

- (delete-region top bottom)

- (when (and (not (looking-at "[ \t]*$")) (looking-at org-list-end-re))

- (replace-match "")))

- out))

- (let ((list (save-excursion (org-list-parse-list t))))

- (re-search-backward "#\\+ORGLST" nil t)

- (unless (looking-at "#\\+ORGLST:[ \t]+SEND[ \t]+\\(\\S-+\\)[ \t]+\\(\\S-+\\)")

- (if maybe (throw 'exit nil)

- (error "Don't know how to transform this list"))))

- (let* ((name (match-string 1))

- (plain-list (buffer-substring-no-properties top-point bottom-point))

- beg)

- ;; Find the insertion place

- (unless (re-search-forward

- (concat "BEGIN RECEIVE ORGLST +"

- name

- "\\([ \t]\\|$\\)")

- nil t)

- (error "Don't know where to insert translated list"))

- (goto-char (match-beginning 0))

- (beginning-of-line 2)

- (setq beg (point))

- (unless (re-search-forward (concat "END RECEIVE ORGLST +" name) nil t)

- (error "Cannot find end of insertion region"))

- (delete-region beg (point-at-bol))

- (goto-char beg)

- (insert txt "\n")))

- (message "List converted and installed at receiver location"))))

-

-(defsubst org-list-item-trim-br (item)

- "Trim line breaks in a list ITEM."

- (setq item (replace-regexp-in-string "\n +" " " item)))

- "Convert a LIST parsed through `org-list-parse-list' to other formats.

-Valid parameters PARAMS are:

-

-:ustart String to start an unordered list

-:uend String to end an unordered list

-

-:ostart String to start an ordered list

-:oend String to end an ordered list

-

-:dstart String to start a descriptive list

-:dend String to end a descriptive list

-:dtstart String to start a descriptive term

-:dtend String to end a descriptive term

-:ddstart String to start a description

-:ddend String to end a description

-

-:splice When set to t, return only list body lines, don't wrap

- them into :[u/o]start and :[u/o]end. Default is nil.

-

-:istart String to start a list item.

-:icount String to start an item with a counter.

-:iend String to end a list item

-:isep String to separate items

-:lsep String to separate sublists

-:csep String to separate text from a sub-list

-

-:cboff String to insert for an unchecked check-box

-:cbon String to insert for a checked check-box

-:cbtrans String to insert for a check-box in transitional state

-

-:nobr Non-nil means remove line breaks in lists items.

-

-Alternatively, each parameter can also be a form returning

-a string. These sexp can use keywords `counter' and `depth',

-representing respectively counter associated to the current

-item, and depth of the current sub-list, starting at 0.

-Obviously, `counter' is only available for parameters applying to

-items."

- (interactive)

- (let* ((p params)

- (splicep (plist-get p :splice))

- (ostart (plist-get p :ostart))

- (oend (plist-get p :oend))

- (ustart (plist-get p :ustart))

- (uend (plist-get p :uend))

- (dstart (plist-get p :dstart))

- (dend (plist-get p :dend))

- (dtstart (plist-get p :dtstart))

- (dtend (plist-get p :dtend))

- (ddstart (plist-get p :ddstart))

- (ddend (plist-get p :ddend))

- (istart (plist-get p :istart))

- (icount (plist-get p :icount))

- (iend (plist-get p :iend))

- (isep (plist-get p :isep))

- (lsep (plist-get p :lsep))

- (csep (plist-get p :csep))

- (cbon (plist-get p :cbon))

- (cboff (plist-get p :cboff))

- (cbtrans (plist-get p :cbtrans))

- (nobr (plist-get p :nobr))

- export-sublist ; for byte-compiler

- (export-item

- (function

- ;; Export an item ITEM of type TYPE, at DEPTH. First

- ;; string in item is treated in a special way as it can

- ;; bring extra information that needs to be processed.

- (lambda (item type depth)

- (let* ((counter (pop item))

- (fmt (concat

- (cond

- ((eq type 'descriptive)

- ;; Stick DTSTART to ISTART by

- ;; left-trimming the latter.

- (concat (let ((s (eval istart)))

- (or (and (string-match "[ \t\n\r]+\\'" s)

- (replace-match "" t t s))

- istart))

- "%s" (eval ddend)))

- ((and counter (eq type 'ordered))

- (concat (eval icount) "%s"))

- (t (concat (eval istart) "%s")))

- (eval iend)))

- (first (car item)))

- ;; Replace checkbox if any is found.

- (cond

- ((string-match "\\[CBON\\]" first)

- (setq first (replace-match cbon t t first)))

- ((string-match "\\[CBOFF\\]" first)

- (setq first (replace-match cboff t t first)))

- ((string-match "\\[CBTRANS\\]" first)

- (setq first (replace-match cbtrans t t first))))

- ;; Replace line breaks if required

- (when nobr (setq first (org-list-item-trim-br first)))

- ;; Insert descriptive term if TYPE is `descriptive'.

- (when (eq type 'descriptive)

- (let* ((complete (string-match "^\\(.*\\)[ \t]+::" first))

- (term (if complete

- (save-match-data

- (org-trim (match-string 1 first)))

- "???"))

- (desc (if complete

- (org-trim (substring first (match-end 0)))

- first)))

- (setq first (concat (eval dtstart) term (eval dtend)

- (eval ddstart) desc))))

- (setcar item first)

- (format fmt

- (mapconcat (lambda (e)

- (if (stringp e) e

- (funcall export-sublist e (1+ depth))))

- item (or (eval csep) "")))))))

- (export-sublist

- (function

- ;; Export sublist SUB at DEPTH.

- (lambda (sub depth)

- (let* ((type (car sub))

- (items (cdr sub))

- (fmt (concat (cond

- (splicep "%s")

- ((eq type 'ordered)

- (concat (eval ostart) "%s" (eval oend)))

- ((eq type 'descriptive)

- (concat (eval dstart) "%s" (eval dend)))

- (t (concat (eval ustart) "%s" (eval uend))))

- (eval lsep))))

- (format fmt (mapconcat (lambda (e)

- (funcall export-item e type depth))

- items (or (eval isep) ""))))))))

- (concat (funcall export-sublist list 0) "\n")))

-

-(defun org-list-to-latex (list &optional _params)

-LIST is as string representing the list to transform, as Org

-syntax. Return converted list as a string."

- (org-export-string-as list 'latex t))

-(defun org-list-to-html (list)

-LIST is as string representing the list to transform, as Org

-syntax. Return converted list as a string."

- (org-export-string-as list 'html t))

-(defun org-list-to-texinfo (list &optional _params)

-LIST is as string representing the list to transform, as Org

-syntax. Return converted list as a string."

- (org-export-string-as list 'texinfo t))

-LIST is as returned by `org-list-parse-list'. PARAMS is a property list

-with overruling parameters for `org-list-to-generic'."

- (defvar get-stars) (defvar org--blankp)

- (let* ((rule (cdr (assq 'heading org-blank-before-new-entry)))

- (org--blankp (or (eq rule t)

- (and (eq rule 'auto)

- (save-excursion

- (outline-previous-heading)

- (org-previous-line-empty-p)))))

- (get-stars ;FIXME: Can't rename without renaming it in org.el as well!

- (function

- ;; Return the string for the heading, depending on depth D

- ;; of current sub-list.

- (lambda (d)

- (let ((oddeven-level (+ level d 1)))

- (concat (make-string (if org-odd-levels-only

- (1- (* 2 oddeven-level))

- oddeven-level)

- ?*)

- " "))))))

- '(:splice t

- :dtstart " " :dtend " "

- :istart (funcall get-stars depth)

- :icount (funcall get-stars depth)

- :isep (if org--blankp "\n\n" "\n")

- :csep (if org--blankp "\n\n" "\n")

- :cbon "DONE" :cboff "TODO" :cbtrans "TODO")