2008-09-23 06:03:13 +00:00
|
|
|
;;; org-list.el --- Plain lists for Org-mode
|
|
|
|
;;
|
2009-01-26 08:42:33 +00:00
|
|
|
;; Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
|
|
|
|
;; Free Software Foundation, Inc.
|
2008-09-23 06:03:13 +00:00
|
|
|
;;
|
|
|
|
;; Author: Carsten Dominik <carsten at orgmode dot org>
|
2008-12-16 16:17:15 +00:00
|
|
|
;; Bastien Guerry <bzg AT altern DOT org>
|
2008-09-23 06:03:13 +00:00
|
|
|
;; Keywords: outlines, hypermedia, calendar, wp
|
|
|
|
;; Homepage: http://orgmode.org
|
2009-04-19 20:31:36 +00:00
|
|
|
;; Version: 6.26a
|
2008-09-23 06:03:13 +00:00
|
|
|
;;
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;;
|
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
|
|
;; it under the terms of the GNU General Public License as published by
|
|
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
|
|
;; (at your option) any later version.
|
|
|
|
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2008-12-16 16:17:15 +00:00
|
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2008-09-23 06:03:13 +00:00
|
|
|
;; GNU General Public License for more details.
|
|
|
|
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
|
|
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;
|
|
|
|
;;; Commentary:
|
|
|
|
|
|
|
|
;; This file contains the code dealing with plain lists in Org-mode.
|
|
|
|
|
|
|
|
;;; Code:
|
|
|
|
|
|
|
|
(require 'org-macs)
|
|
|
|
(require 'org-compat)
|
|
|
|
|
|
|
|
(defvar org-blank-before-new-entry)
|
|
|
|
(defvar org-M-RET-may-split-line)
|
|
|
|
|
|
|
|
(declare-function org-invisible-p "org" ())
|
|
|
|
(declare-function org-on-heading-p "org" (&optional invisible-ok))
|
2008-11-08 21:00:03 +00:00
|
|
|
(declare-function outline-next-heading "outline" ())
|
|
|
|
(declare-function outline-back-to-heading "outline" (&optional invisible-ok))
|
2008-09-23 06:03:13 +00:00
|
|
|
(declare-function org-back-to-heading "org" (&optional invisible-ok))
|
|
|
|
(declare-function org-back-over-empty-lines "org" ())
|
|
|
|
(declare-function org-skip-whitespace "org" ())
|
|
|
|
(declare-function org-trim "org" (s))
|
|
|
|
(declare-function org-get-indentation "org" (&optional line))
|
2008-11-25 19:42:06 +00:00
|
|
|
(declare-function org-timer-item "org-timer" (&optional arg))
|
2009-01-06 16:23:36 +00:00
|
|
|
(declare-function org-combine-plists "org" (&rest plists))
|
2009-02-20 10:16:03 +00:00
|
|
|
(declare-function org-entry-get "org" (pom property &optional inherit))
|
2008-09-23 06:03:13 +00:00
|
|
|
|
|
|
|
(defgroup org-plain-lists nil
|
|
|
|
"Options concerning plain lists in Org-mode."
|
|
|
|
:tag "Org Plain lists"
|
|
|
|
:group 'org-structure)
|
|
|
|
|
|
|
|
(defcustom org-cycle-include-plain-lists nil
|
|
|
|
"Non-nil means, include plain lists into visibility cycling.
|
|
|
|
This means that during cycling, plain list items will *temporarily* be
|
|
|
|
interpreted as outline headlines with a level given by 1000+i where i is the
|
|
|
|
indentation of the bullet. In all other operations, plain list items are
|
2008-12-16 16:17:15 +00:00
|
|
|
not seen as headlines. For example, you cannot assign a TODO keyword to
|
2008-09-23 06:03:13 +00:00
|
|
|
such an item."
|
|
|
|
:group 'org-plain-lists
|
|
|
|
:type 'boolean)
|
|
|
|
|
|
|
|
(defcustom org-plain-list-ordered-item-terminator t
|
|
|
|
"The character that makes a line with leading number an ordered list item.
|
|
|
|
Valid values are ?. and ?\). To get both terminators, use t. While
|
|
|
|
?. may look nicer, it creates the danger that a line with leading
|
|
|
|
number may be incorrectly interpreted as an item. ?\) therefore is
|
|
|
|
the safe choice."
|
|
|
|
:group 'org-plain-lists
|
|
|
|
:type '(choice (const :tag "dot like in \"2.\"" ?.)
|
|
|
|
(const :tag "paren like in \"2)\"" ?\))
|
|
|
|
(const :tab "both" t)))
|
|
|
|
|
2008-11-21 05:54:46 +00:00
|
|
|
(defcustom org-list-two-spaces-after-bullet-regexp nil
|
|
|
|
"A regular expression matching bullets that should have 2 spaces after them.
|
|
|
|
When nil, no bullet will have two spaces after them.
|
2008-12-16 16:17:15 +00:00
|
|
|
When a string, it will be used as a regular expression. When the bullet
|
2008-11-21 05:54:46 +00:00
|
|
|
type of a list is changed, the new bullet type will be matched against this
|
2008-12-16 16:17:15 +00:00
|
|
|
regexp. If it matches, there will be two spaces instead of one after
|
2008-11-21 05:54:46 +00:00
|
|
|
the bullet in each item of he list."
|
|
|
|
:group 'org-plain-list
|
|
|
|
:type '(choice
|
|
|
|
(const :tag "never" nil)
|
|
|
|
(regexp)))
|
|
|
|
|
2008-09-23 06:03:13 +00:00
|
|
|
(defcustom org-empty-line-terminates-plain-lists nil
|
|
|
|
"Non-nil means, an empty line ends all plain list levels.
|
2009-01-30 21:51:17 +00:00
|
|
|
When nil, empty lines are part of the preceding item."
|
2008-09-23 06:03:13 +00:00
|
|
|
:group 'org-plain-lists
|
|
|
|
:type 'boolean)
|
|
|
|
|
|
|
|
(defcustom org-auto-renumber-ordered-lists t
|
|
|
|
"Non-nil means, automatically renumber ordered plain lists.
|
|
|
|
Renumbering happens when the sequence have been changed with
|
|
|
|
\\[org-shiftmetaup] or \\[org-shiftmetadown]. After other editing commands,
|
|
|
|
use \\[org-ctrl-c-ctrl-c] to trigger renumbering."
|
|
|
|
:group 'org-plain-lists
|
|
|
|
:type 'boolean)
|
|
|
|
|
|
|
|
(defcustom org-provide-checkbox-statistics t
|
|
|
|
"Non-nil means, update checkbox statistics after insert and toggle.
|
|
|
|
When this is set, checkbox statistics is updated each time you either insert
|
|
|
|
a new checkbox with \\[org-insert-todo-heading] or toggle a checkbox
|
|
|
|
with \\[org-ctrl-c-ctrl-c\\]."
|
|
|
|
:group 'org-plain-lists
|
|
|
|
:type 'boolean)
|
|
|
|
|
|
|
|
(defcustom org-description-max-indent 20
|
|
|
|
"Maximum indentation for the second line of a description list.
|
|
|
|
When the indentation would be larger than this, it will become
|
|
|
|
5 characters instead."
|
|
|
|
:group 'org-plain-lists
|
|
|
|
:type 'integer)
|
|
|
|
|
|
|
|
(defvar org-list-beginning-re
|
|
|
|
"^\\([ \t]*\\)\\([-+*]\\|[0-9]+[.)]\\) +\\(.*\\)$")
|
|
|
|
|
|
|
|
(defcustom org-list-radio-list-templates
|
|
|
|
'((latex-mode "% BEGIN RECEIVE ORGLST %n
|
|
|
|
% END RECEIVE ORGLST %n
|
|
|
|
\\begin{comment}
|
|
|
|
#+ORGLST: SEND %n org-list-to-latex
|
|
|
|
| | |
|
|
|
|
\\end{comment}\n")
|
|
|
|
(texinfo-mode "@c BEGIN RECEIVE ORGLST %n
|
|
|
|
@c END RECEIVE ORGLST %n
|
|
|
|
@ignore
|
|
|
|
#+ORGLST: SEND %n org-list-to-texinfo
|
|
|
|
| | |
|
|
|
|
@end ignore\n")
|
|
|
|
(html-mode "<!-- BEGIN RECEIVE ORGLST %n -->
|
|
|
|
<!-- END RECEIVE ORGLST %n -->
|
|
|
|
<!--
|
|
|
|
#+ORGLST: SEND %n org-list-to-html
|
|
|
|
| | |
|
|
|
|
-->\n"))
|
|
|
|
"Templates for radio lists in different major modes.
|
|
|
|
All occurrences of %n in a template will be replaced with the name of the
|
|
|
|
list, obtained by prompting the user."
|
|
|
|
:group 'org-plain-lists
|
|
|
|
:type '(repeat
|
|
|
|
(list (symbol :tag "Major mode")
|
|
|
|
(string :tag "Format"))))
|
|
|
|
|
|
|
|
;;;; Plain list items, including checkboxes
|
|
|
|
|
|
|
|
;;; Plain list items
|
|
|
|
|
|
|
|
(defun org-at-item-p ()
|
|
|
|
"Is point in a line starting a hand-formatted item?"
|
|
|
|
(let ((llt org-plain-list-ordered-item-terminator))
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (point-at-bol))
|
|
|
|
(looking-at
|
|
|
|
(cond
|
|
|
|
((eq llt t) "\\([ \t]*\\([-+]\\|\\([0-9]+[.)]\\)\\)\\|[ \t]+\\*\\)\\( \\|$\\)")
|
|
|
|
((= llt ?.) "\\([ \t]*\\([-+]\\|\\([0-9]+\\.\\)\\)\\|[ \t]+\\*\\)\\( \\|$\\)")
|
|
|
|
((= llt ?\)) "\\([ \t]*\\([-+]\\|\\([0-9]+))\\)\\|[ \t]+\\*\\)\\( \\|$\\)")
|
|
|
|
(t (error "Invalid value of `org-plain-list-ordered-item-terminator'")))))))
|
|
|
|
|
Support for Shift Selection
Emacs 23 introduces `shift-selection-mode', and even turns it on by
default. Therefore, it is fair to assume that users of Emacs 23 will
expect to be able to select a region by holding down shift will moving
the cursor. This conflicts with the use of shifted cursor keys in
Org-mode for other purposes, in particular to "change the item under
the cursor", like it is done for time stamps, item bullet types, TODO
keywords and priorities.
This commit tries to support `shift-selection-mode' as much as possible,
while retaining these valuable commands keys for Org-mode. The
following things are changed:
1. The range of contexts where Org's commands do act is reduced.
- S-up and S-down no longer jump to the previous and next plain list
item - you can use the paragraph commands C-up and C-down for this
quite well.
- S-left and S-right only change the bullet type of a plain list
item when the cursor is *exactly* on the bullet, not just anywhere
in the item line.
2. When a S-cursor key is used outside a special context, a region is
started or extended.
3. When a region has already been started, it will be continue to
extend even if the S-cursor keys move the cursor into a special
context.
4. If you want S-cursor selection to work in headlines as well, you
can set the variable `org-support-shift-select' to
`even-in-headlines'. Then you need to rely on `C-c C-t' to set
TODO keywords, and on `C-c ,' to set priorities.
If you want everything to behave the way it was, set
`org-support-shift-select' to nil.
2009-01-26 15:23:44 +00:00
|
|
|
(defun org-at-item-bullet-p ()
|
|
|
|
"Is point at the bullet of a plain list item?"
|
|
|
|
(and (org-at-item-p)
|
|
|
|
(not (member (char-after) '(?\ ?\t)))
|
|
|
|
(< (point) (match-end 0))))
|
|
|
|
|
2008-09-23 06:03:13 +00:00
|
|
|
(defun org-in-item-p ()
|
|
|
|
"It the cursor inside a plain list item.
|
|
|
|
Does not have to be the first line."
|
|
|
|
(save-excursion
|
|
|
|
(condition-case nil
|
|
|
|
(progn
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(org-at-item-p)
|
|
|
|
t)
|
|
|
|
(error nil))))
|
|
|
|
|
|
|
|
(defun org-insert-item (&optional checkbox)
|
|
|
|
"Insert a new item at the current level.
|
|
|
|
Return t when things worked, nil when we are not in an item."
|
|
|
|
(when (save-excursion
|
|
|
|
(condition-case nil
|
|
|
|
(progn
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(org-at-item-p)
|
|
|
|
(if (org-invisible-p) (error "Invisible item"))
|
|
|
|
t)
|
|
|
|
(error nil)))
|
|
|
|
(let* ((bul (match-string 0))
|
|
|
|
(descp (save-excursion (goto-char (match-beginning 0))
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(save-match-data
|
2008-11-25 19:20:52 +00:00
|
|
|
(and (looking-at "[ \t]*\\(.*?\\) ::")
|
|
|
|
(match-string 1)))))
|
2009-01-08 08:30:55 +00:00
|
|
|
(empty-line-p (save-excursion
|
|
|
|
(goto-char (match-beginning 0))
|
|
|
|
(and (not (bobp))
|
|
|
|
(or (beginning-of-line 0) t)
|
|
|
|
(save-match-data
|
|
|
|
(looking-at "[ \t]*$")))))
|
2008-12-04 14:33:43 +00:00
|
|
|
(timerp (and descp
|
2008-11-25 19:20:52 +00:00
|
|
|
(save-match-data
|
|
|
|
(string-match "^[-+*][ \t]+[0-9]+:[0-9]+:[0-9]+$"
|
|
|
|
descp))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(eow (save-excursion (beginning-of-line 1) (looking-at "[ \t]*")
|
|
|
|
(match-end 0)))
|
2009-02-26 21:30:23 +00:00
|
|
|
(blank-a (if org-empty-line-terminates-plain-lists
|
|
|
|
nil
|
|
|
|
(cdr (assq 'plain-list-item org-blank-before-new-entry))))
|
2009-01-08 08:30:55 +00:00
|
|
|
(blank (if (eq blank-a 'auto) empty-line-p blank-a))
|
2008-09-23 06:03:13 +00:00
|
|
|
pos)
|
|
|
|
(if descp (setq checkbox nil))
|
2008-11-25 19:20:52 +00:00
|
|
|
(if timerp
|
|
|
|
(progn (org-timer-item) t)
|
|
|
|
(cond
|
|
|
|
((and (org-at-item-p) (<= (point) eow))
|
|
|
|
;; before the bullet
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(open-line (if blank 2 1)))
|
|
|
|
((<= (point) eow)
|
|
|
|
(beginning-of-line 1))
|
|
|
|
(t
|
|
|
|
(unless (org-get-alist-option org-M-RET-may-split-line 'item)
|
|
|
|
(end-of-line 1)
|
|
|
|
(delete-horizontal-space))
|
|
|
|
(newline (if blank 2 1))))
|
|
|
|
(insert bul
|
|
|
|
(if checkbox "[ ]" "")
|
|
|
|
(if descp (concat (if checkbox " " "")
|
|
|
|
(read-string "Term: ") " :: ") ""))
|
|
|
|
(just-one-space)
|
|
|
|
(setq pos (point))
|
|
|
|
(end-of-line 1)
|
|
|
|
(unless (= (point) pos) (just-one-space) (backward-delete-char 1)))
|
|
|
|
(org-maybe-renumber-ordered-list)
|
|
|
|
(and checkbox (org-update-checkbox-count-maybe))
|
|
|
|
t)))
|
2008-09-23 06:03:13 +00:00
|
|
|
|
|
|
|
;;; Checkboxes
|
|
|
|
|
|
|
|
(defun org-at-item-checkbox-p ()
|
|
|
|
"Is point at a line starting a plain-list item with a checklet?"
|
|
|
|
(and (org-at-item-p)
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(skip-chars-forward " \t")
|
|
|
|
(looking-at "\\[[- X]\\]"))))
|
|
|
|
|
2009-01-28 11:28:21 +00:00
|
|
|
(defun org-toggle-checkbox (&optional toggle-presence)
|
|
|
|
"Toggle the checkbox in the current line.
|
|
|
|
With prefix arg TOGGLE-PRESENCE, add or remove checkboxes.
|
2009-02-15 09:00:44 +00:00
|
|
|
With double prefix, set checkbox to [-].
|
2009-01-28 11:28:21 +00:00
|
|
|
When there is an active region, toggle status or presence of the checkbox
|
|
|
|
in the first line, and make every item in the region have the same
|
2009-01-30 21:51:17 +00:00
|
|
|
status or presence, respectively.
|
2009-01-29 14:28:12 +00:00
|
|
|
If the cursor is in a headline, apply this to all checkbox items in the
|
|
|
|
text below the heading."
|
2008-09-23 06:03:13 +00:00
|
|
|
(interactive "P")
|
|
|
|
(catch 'exit
|
2009-02-19 08:13:08 +00:00
|
|
|
(let (beg end status first-present first-status blocked)
|
2008-09-23 06:03:13 +00:00
|
|
|
(cond
|
|
|
|
((org-region-active-p)
|
|
|
|
(setq beg (region-beginning) end (region-end)))
|
|
|
|
((org-on-heading-p)
|
|
|
|
(setq beg (point) end (save-excursion (outline-next-heading) (point))))
|
|
|
|
((org-at-item-checkbox-p)
|
2009-02-15 21:34:19 +00:00
|
|
|
(save-excursion
|
2009-02-15 09:00:44 +00:00
|
|
|
(if (equal toggle-presence '(4))
|
2009-01-28 11:28:21 +00:00
|
|
|
(progn
|
|
|
|
(replace-match "")
|
|
|
|
(goto-char (match-beginning 0))
|
|
|
|
(just-one-space))
|
2009-02-19 08:13:08 +00:00
|
|
|
(when (setq blocked (org-checkbox-blocked-p))
|
|
|
|
(error "Checkbox blocked because of unchecked box in line %d"
|
|
|
|
blocked))
|
2009-01-28 11:28:21 +00:00
|
|
|
(replace-match
|
2009-02-15 09:00:44 +00:00
|
|
|
(cond ((equal toggle-presence '(16)) "[-]")
|
|
|
|
((member (match-string 0) '("[ ]" "[-]")) "[X]")
|
2009-01-28 11:28:21 +00:00
|
|
|
(t "[ ]"))
|
2009-02-15 21:34:19 +00:00
|
|
|
t t)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(throw 'exit t))
|
2009-01-28 11:28:21 +00:00
|
|
|
((org-at-item-p)
|
|
|
|
;; add a checkbox
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(insert "[ ] "))
|
|
|
|
(throw 'exit t))
|
2008-09-23 06:03:13 +00:00
|
|
|
(t (error "Not at a checkbox or heading, and no active region")))
|
2009-01-28 11:28:21 +00:00
|
|
|
(setq end (move-marker (make-marker) end))
|
2008-09-23 06:03:13 +00:00
|
|
|
(save-excursion
|
|
|
|
(goto-char beg)
|
2009-01-28 11:28:21 +00:00
|
|
|
(setq first-present (org-at-item-checkbox-p)
|
2009-01-29 14:28:12 +00:00
|
|
|
first-status
|
|
|
|
(save-excursion
|
|
|
|
(and (re-search-forward "[ \t]\\(\\[[ X]\\]\\)" end t)
|
|
|
|
(equal (match-string 1) "[X]"))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(while (< (point) end)
|
2009-01-28 11:28:21 +00:00
|
|
|
(if toggle-presence
|
|
|
|
(cond
|
|
|
|
((and first-present (org-at-item-checkbox-p))
|
|
|
|
(save-excursion
|
|
|
|
(replace-match "")
|
|
|
|
(goto-char (match-beginning 0))
|
|
|
|
(just-one-space)))
|
|
|
|
((and (not first-present) (not (org-at-item-checkbox-p))
|
|
|
|
(org-at-item-p))
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(insert "[ ] "))))
|
|
|
|
(when (org-at-item-checkbox-p)
|
|
|
|
(setq status (equal (match-string 0) "[X]"))
|
|
|
|
(replace-match
|
|
|
|
(if first-status "[ ]" "[X]") t t)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(beginning-of-line 2)))))
|
|
|
|
(org-update-checkbox-count-maybe))
|
|
|
|
|
2009-02-19 08:13:08 +00:00
|
|
|
(defun org-checkbox-blocked-p ()
|
|
|
|
"Is the current checkbox blocked from for being checked now?
|
|
|
|
A checkbox is blocked if all of the following conditions are fulfilled:
|
|
|
|
|
|
|
|
1. The checkbox is not checked already.
|
|
|
|
2. The current entry has the ORDERED property set.
|
|
|
|
3. There is an unchecked checkbox in this entry before the current line."
|
|
|
|
(catch 'exit
|
|
|
|
(save-match-data
|
|
|
|
(save-excursion
|
|
|
|
(unless (org-at-item-checkbox-p) (throw 'exit nil))
|
|
|
|
(when (equal (match-string 0) "[X]")
|
|
|
|
;; the box is already checked!
|
|
|
|
(throw 'exit nil))
|
|
|
|
(let ((end (point-at-bol)))
|
|
|
|
(condition-case nil (org-back-to-heading t)
|
|
|
|
(error (throw 'exit nil)))
|
|
|
|
(unless (org-entry-get nil "ORDERED") (throw 'exit nil))
|
|
|
|
(if (re-search-forward "^[ \t]*[-+*0-9.)] \\[[- ]\\]" end t)
|
|
|
|
(org-current-line)
|
|
|
|
nil))))))
|
|
|
|
|
2008-09-23 06:03:13 +00:00
|
|
|
(defun org-update-checkbox-count-maybe ()
|
|
|
|
"Update checkbox statistics unless turned off by user."
|
|
|
|
(when org-provide-checkbox-statistics
|
|
|
|
(org-update-checkbox-count)))
|
|
|
|
|
|
|
|
(defun org-update-checkbox-count (&optional all)
|
|
|
|
"Update the checkbox statistics in the current section.
|
|
|
|
This will find all statistic cookies like [57%] and [6/12] and update them
|
|
|
|
with the current numbers. With optional prefix argument ALL, do this for
|
|
|
|
the whole buffer."
|
|
|
|
(interactive "P")
|
|
|
|
(save-excursion
|
|
|
|
(let* ((buffer-invisibility-spec (org-inhibit-invisibility)) ; Emacs 21
|
|
|
|
(beg (condition-case nil
|
2008-11-13 08:54:30 +00:00
|
|
|
(progn (org-back-to-heading) (point))
|
2008-09-23 06:03:13 +00:00
|
|
|
(error (point-min))))
|
|
|
|
(end (move-marker (make-marker)
|
|
|
|
(progn (outline-next-heading) (point))))
|
|
|
|
(re "\\(\\(\\[[0-9]*%\\]\\)\\|\\(\\[[0-9]*/[0-9]*\\]\\)\\)")
|
|
|
|
(re-box "^[ \t]*\\([-+*]\\|[0-9]+[.)]\\) +\\(\\[[- X]\\]\\)")
|
|
|
|
(re-find (concat re "\\|" re-box))
|
|
|
|
beg-cookie end-cookie is-percent c-on c-off lim
|
2008-12-16 16:17:15 +00:00
|
|
|
eline curr-ind next-ind continue-from startsearch
|
|
|
|
(cstat 0)
|
|
|
|
)
|
2008-09-23 06:03:13 +00:00
|
|
|
(when all
|
|
|
|
(goto-char (point-min))
|
|
|
|
(outline-next-heading)
|
|
|
|
(setq beg (point) end (point-max)))
|
|
|
|
(goto-char end)
|
|
|
|
;; find each statistic cookie
|
|
|
|
(while (re-search-backward re-find beg t)
|
|
|
|
(setq beg-cookie (match-beginning 1)
|
2008-12-16 16:17:15 +00:00
|
|
|
end-cookie (match-end 1)
|
2008-09-23 06:03:13 +00:00
|
|
|
cstat (+ cstat (if end-cookie 1 0))
|
|
|
|
startsearch (point-at-eol)
|
2009-01-28 16:21:15 +00:00
|
|
|
continue-from (match-beginning 0)
|
2008-12-16 16:17:15 +00:00
|
|
|
is-percent (match-beginning 2)
|
2008-09-23 06:03:13 +00:00
|
|
|
lim (cond
|
|
|
|
((org-on-heading-p) (outline-next-heading) (point))
|
|
|
|
((org-at-item-p) (org-end-of-item) (point))
|
|
|
|
(t nil))
|
2008-12-16 16:17:15 +00:00
|
|
|
c-on 0
|
|
|
|
c-off 0)
|
2008-09-23 06:03:13 +00:00
|
|
|
(when lim
|
2008-12-16 16:17:15 +00:00
|
|
|
;; find first checkbox for this cookie and gather
|
|
|
|
;; statistics from all that are at this indentation level
|
|
|
|
(goto-char startsearch)
|
|
|
|
(if (re-search-forward re-box lim t)
|
|
|
|
(progn
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq curr-ind (org-get-indentation))
|
|
|
|
(setq next-ind curr-ind)
|
|
|
|
(while (and (bolp) (org-at-item-p) (= curr-ind next-ind))
|
|
|
|
(save-excursion (end-of-line) (setq eline (point)))
|
|
|
|
(if (re-search-forward re-box eline t)
|
2008-09-23 06:03:13 +00:00
|
|
|
(if (member (match-string 2) '("[ ]" "[-]"))
|
|
|
|
(setq c-off (1+ c-off))
|
2008-12-16 16:17:15 +00:00
|
|
|
(setq c-on (1+ c-on))
|
|
|
|
)
|
|
|
|
)
|
|
|
|
(org-end-of-item)
|
|
|
|
(setq next-ind (org-get-indentation))
|
|
|
|
)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-char continue-from)
|
2008-12-16 16:17:15 +00:00
|
|
|
;; update cookie
|
2008-09-23 06:03:13 +00:00
|
|
|
(when end-cookie
|
|
|
|
(delete-region beg-cookie end-cookie)
|
|
|
|
(goto-char beg-cookie)
|
|
|
|
(insert
|
|
|
|
(if is-percent
|
|
|
|
(format "[%d%%]" (/ (* 100 c-on) (max 1 (+ c-on c-off))))
|
|
|
|
(format "[%d/%d]" c-on (+ c-on c-off)))))
|
2008-12-16 16:17:15 +00:00
|
|
|
;; update items checkbox if it has one
|
|
|
|
(when (org-at-item-p)
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(when (and (> (+ c-on c-off) 0)
|
2008-09-23 06:03:13 +00:00
|
|
|
(re-search-forward re-box (point-at-eol) t))
|
2008-12-16 16:17:15 +00:00
|
|
|
(setq beg-cookie (match-beginning 2)
|
|
|
|
end-cookie (match-end 2))
|
|
|
|
(delete-region beg-cookie end-cookie)
|
|
|
|
(goto-char beg-cookie)
|
|
|
|
(cond ((= c-off 0) (insert "[X]"))
|
|
|
|
((= c-on 0) (insert "[ ]"))
|
|
|
|
(t (insert "[-]")))
|
|
|
|
)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-char continue-from))
|
|
|
|
(when (interactive-p)
|
2008-12-16 16:20:59 +00:00
|
|
|
(message "Checkbox statistics updated %s (%d places)"
|
2008-09-23 06:03:13 +00:00
|
|
|
(if all "in entire file" "in current outline entry") cstat)))))
|
|
|
|
|
|
|
|
(defun org-get-checkbox-statistics-face ()
|
|
|
|
"Select the face for checkbox statistics.
|
|
|
|
The face will be `org-done' when all relevant boxes are checked. Otherwise
|
|
|
|
it will be `org-todo'."
|
|
|
|
(if (match-end 1)
|
|
|
|
(if (equal (match-string 1) "100%") 'org-done 'org-todo)
|
|
|
|
(if (and (> (match-end 2) (match-beginning 2))
|
|
|
|
(equal (match-string 2) (match-string 3)))
|
|
|
|
'org-done
|
|
|
|
'org-todo)))
|
|
|
|
|
|
|
|
(defun org-beginning-of-item ()
|
|
|
|
"Go to the beginning of the current hand-formatted item.
|
|
|
|
If the cursor is not in an item, throw an error."
|
|
|
|
(interactive)
|
|
|
|
(let ((pos (point))
|
|
|
|
(limit (save-excursion
|
|
|
|
(condition-case nil
|
|
|
|
(progn
|
|
|
|
(org-back-to-heading)
|
|
|
|
(beginning-of-line 2) (point))
|
|
|
|
(error (point-min)))))
|
|
|
|
(ind-empty (if org-empty-line-terminates-plain-lists 0 10000))
|
|
|
|
ind ind1)
|
|
|
|
(if (org-at-item-p)
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(skip-chars-forward " \t")
|
|
|
|
(setq ind (current-column))
|
|
|
|
(if (catch 'exit
|
|
|
|
(while t
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(if (or (bobp) (< (point) limit)) (throw 'exit nil))
|
|
|
|
|
|
|
|
(if (looking-at "[ \t]*$")
|
|
|
|
(setq ind1 ind-empty)
|
|
|
|
(skip-chars-forward " \t")
|
|
|
|
(setq ind1 (current-column)))
|
|
|
|
(if (< ind1 ind)
|
|
|
|
(progn (beginning-of-line 1) (throw 'exit (org-at-item-p))))))
|
|
|
|
nil
|
|
|
|
(goto-char pos)
|
|
|
|
(error "Not in an item")))))
|
|
|
|
|
|
|
|
(defun org-end-of-item ()
|
|
|
|
"Go to the end of the current hand-formatted item.
|
|
|
|
If the cursor is not in an item, throw an error."
|
|
|
|
(interactive)
|
|
|
|
(let* ((pos (point))
|
|
|
|
ind1
|
|
|
|
(ind-empty (if org-empty-line-terminates-plain-lists 0 10000))
|
|
|
|
(limit (save-excursion (outline-next-heading) (point)))
|
|
|
|
(ind (save-excursion
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(skip-chars-forward " \t")
|
|
|
|
(current-column)))
|
|
|
|
(end (catch 'exit
|
|
|
|
(while t
|
|
|
|
(beginning-of-line 2)
|
|
|
|
(if (eobp) (throw 'exit (point)))
|
|
|
|
(if (>= (point) limit) (throw 'exit (point-at-bol)))
|
|
|
|
(if (looking-at "[ \t]*$")
|
|
|
|
(setq ind1 ind-empty)
|
|
|
|
(skip-chars-forward " \t")
|
|
|
|
(setq ind1 (current-column)))
|
|
|
|
(if (<= ind1 ind)
|
|
|
|
(throw 'exit (point-at-bol)))))))
|
|
|
|
(if end
|
|
|
|
(goto-char end)
|
|
|
|
(goto-char pos)
|
|
|
|
(error "Not in an item"))))
|
|
|
|
|
|
|
|
(defun org-next-item ()
|
|
|
|
"Move to the beginning of the next item in the current plain list.
|
|
|
|
Error if not at a plain list, or if this is the last item in the list."
|
|
|
|
(interactive)
|
|
|
|
(let (ind ind1 (pos (point)))
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq ind (org-get-indentation))
|
|
|
|
(org-end-of-item)
|
|
|
|
(setq ind1 (org-get-indentation))
|
|
|
|
(unless (and (org-at-item-p) (= ind ind1))
|
|
|
|
(goto-char pos)
|
|
|
|
(error "On last item"))))
|
|
|
|
|
|
|
|
(defun org-previous-item ()
|
|
|
|
"Move to the beginning of the previous item in the current plain list.
|
|
|
|
Error if not at a plain list, or if this is the first item in the list."
|
|
|
|
(interactive)
|
|
|
|
(let (beg ind ind1 (pos (point)))
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq beg (point))
|
|
|
|
(setq ind (org-get-indentation))
|
|
|
|
(goto-char beg)
|
|
|
|
(catch 'exit
|
|
|
|
(while t
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(if (looking-at "[ \t]*$")
|
|
|
|
nil
|
|
|
|
(if (<= (setq ind1 (org-get-indentation)) ind)
|
|
|
|
(throw 'exit t)))))
|
|
|
|
(condition-case nil
|
|
|
|
(if (or (not (org-at-item-p))
|
|
|
|
(< ind1 (1- ind)))
|
|
|
|
(error "")
|
|
|
|
(org-beginning-of-item))
|
|
|
|
(error (goto-char pos)
|
|
|
|
(error "On first item")))))
|
|
|
|
|
|
|
|
(defun org-first-list-item-p ()
|
|
|
|
"Is this heading the item in a plain list?"
|
|
|
|
(unless (org-at-item-p)
|
|
|
|
(error "Not at a plain list item"))
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(= (point) (save-excursion (org-beginning-of-item-list))))
|
|
|
|
|
|
|
|
(defun org-move-item-down ()
|
|
|
|
"Move the plain list item at point down, i.e. swap with following item.
|
|
|
|
Subitems (items with larger indentation) are considered part of the item,
|
|
|
|
so this really moves item trees."
|
|
|
|
(interactive)
|
2008-09-29 10:46:15 +00:00
|
|
|
(let ((col (current-column))
|
|
|
|
(pos (point))
|
|
|
|
beg beg0 end end0 ind ind1 txt ne-end ne-beg)
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq beg0 (point))
|
|
|
|
(save-excursion
|
|
|
|
(setq ne-beg (org-back-over-empty-lines))
|
|
|
|
(setq beg (point)))
|
|
|
|
(goto-char beg0)
|
|
|
|
(setq ind (org-get-indentation))
|
|
|
|
(org-end-of-item)
|
|
|
|
(setq end0 (point))
|
|
|
|
(setq ind1 (org-get-indentation))
|
|
|
|
(setq ne-end (org-back-over-empty-lines))
|
|
|
|
(setq end (point))
|
|
|
|
(goto-char beg0)
|
|
|
|
(when (and (org-first-list-item-p) (< ne-end ne-beg))
|
|
|
|
;; include less whitespace
|
|
|
|
(save-excursion
|
|
|
|
(goto-char beg)
|
|
|
|
(forward-line (- ne-beg ne-end))
|
|
|
|
(setq beg (point))))
|
|
|
|
(goto-char end0)
|
|
|
|
(if (and (org-at-item-p) (= ind ind1))
|
|
|
|
(progn
|
|
|
|
(org-end-of-item)
|
|
|
|
(org-back-over-empty-lines)
|
|
|
|
(setq txt (buffer-substring beg end))
|
|
|
|
(save-excursion
|
|
|
|
(delete-region beg end))
|
|
|
|
(setq pos (point))
|
|
|
|
(insert txt)
|
|
|
|
(goto-char pos) (org-skip-whitespace)
|
2008-09-29 10:46:15 +00:00
|
|
|
(org-maybe-renumber-ordered-list)
|
|
|
|
(move-to-column col))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-char pos)
|
2008-09-29 10:46:15 +00:00
|
|
|
(move-to-column col)
|
2008-09-23 06:03:13 +00:00
|
|
|
(error "Cannot move this item further down"))))
|
|
|
|
|
|
|
|
(defun org-move-item-up (arg)
|
|
|
|
"Move the plain list item at point up, i.e. swap with previous item.
|
|
|
|
Subitems (items with larger indentation) are considered part of the item,
|
|
|
|
so this really moves item trees."
|
|
|
|
(interactive "p")
|
2008-09-29 10:46:15 +00:00
|
|
|
(let ((col (current-column)) (pos (point))
|
|
|
|
beg beg0 end ind ind1 txt
|
|
|
|
ne-beg ne-ins ins-end)
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq beg0 (point))
|
|
|
|
(setq ind (org-get-indentation))
|
|
|
|
(save-excursion
|
|
|
|
(setq ne-beg (org-back-over-empty-lines))
|
|
|
|
(setq beg (point)))
|
|
|
|
(goto-char beg0)
|
|
|
|
(org-end-of-item)
|
|
|
|
(org-back-over-empty-lines)
|
|
|
|
(setq end (point))
|
|
|
|
(goto-char beg0)
|
|
|
|
(catch 'exit
|
|
|
|
(while t
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(if (looking-at "[ \t]*$")
|
|
|
|
(if org-empty-line-terminates-plain-lists
|
|
|
|
(progn
|
|
|
|
(goto-char pos)
|
|
|
|
(error "Cannot move this item further up"))
|
|
|
|
nil)
|
|
|
|
(if (<= (setq ind1 (org-get-indentation)) ind)
|
|
|
|
(throw 'exit t)))))
|
|
|
|
(condition-case nil
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(error (goto-char beg0)
|
2008-09-29 10:46:15 +00:00
|
|
|
(move-to-column col)
|
2008-09-23 06:03:13 +00:00
|
|
|
(error "Cannot move this item further up")))
|
|
|
|
(setq ind1 (org-get-indentation))
|
|
|
|
(if (and (org-at-item-p) (= ind ind1))
|
|
|
|
(progn
|
|
|
|
(setq ne-ins (org-back-over-empty-lines))
|
|
|
|
(setq txt (buffer-substring beg end))
|
|
|
|
(save-excursion
|
|
|
|
(delete-region beg end))
|
|
|
|
(setq pos (point))
|
|
|
|
(insert txt)
|
|
|
|
(setq ins-end (point))
|
|
|
|
(goto-char pos) (org-skip-whitespace)
|
|
|
|
|
|
|
|
(when (and (org-first-list-item-p) (> ne-ins ne-beg))
|
|
|
|
;; Move whitespace back to beginning
|
|
|
|
(save-excursion
|
|
|
|
(goto-char ins-end)
|
|
|
|
(let ((kill-whole-line t))
|
|
|
|
(kill-line (- ne-ins ne-beg)) (point)))
|
|
|
|
(insert (make-string (- ne-ins ne-beg) ?\n)))
|
|
|
|
|
2008-09-29 10:46:15 +00:00
|
|
|
(org-maybe-renumber-ordered-list)
|
|
|
|
(move-to-column col))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-char pos)
|
2008-09-29 10:46:15 +00:00
|
|
|
(move-to-column col)
|
2008-09-23 06:03:13 +00:00
|
|
|
(error "Cannot move this item further up"))))
|
|
|
|
|
|
|
|
(defun org-maybe-renumber-ordered-list ()
|
|
|
|
"Renumber the ordered list at point if setup allows it.
|
|
|
|
This tests the user option `org-auto-renumber-ordered-lists' before
|
|
|
|
doing the renumbering."
|
|
|
|
(interactive)
|
|
|
|
(when (and org-auto-renumber-ordered-lists
|
|
|
|
(org-at-item-p))
|
|
|
|
(if (match-beginning 3)
|
|
|
|
(org-renumber-ordered-list 1)
|
|
|
|
(org-fix-bullet-type))))
|
|
|
|
|
|
|
|
(defun org-maybe-renumber-ordered-list-safe ()
|
|
|
|
(condition-case nil
|
|
|
|
(save-excursion
|
|
|
|
(org-maybe-renumber-ordered-list))
|
|
|
|
(error nil)))
|
|
|
|
|
|
|
|
(defun org-cycle-list-bullet (&optional which)
|
|
|
|
"Cycle through the different itemize/enumerate bullets.
|
|
|
|
This cycle the entire list level through the sequence:
|
|
|
|
|
2008-12-16 16:17:15 +00:00
|
|
|
`-' -> `+' -> `*' -> `1.' -> `1)'
|
2008-09-23 06:03:13 +00:00
|
|
|
|
|
|
|
If WHICH is a string, use that as the new bullet. If WHICH is an integer,
|
2008-12-16 16:20:59 +00:00
|
|
|
0 means `-', 1 means `+' etc."
|
2008-09-23 06:03:13 +00:00
|
|
|
(interactive "P")
|
|
|
|
(org-preserve-lc
|
|
|
|
(org-beginning-of-item-list)
|
|
|
|
(org-at-item-p)
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(let ((current (match-string 0))
|
|
|
|
(prevp (eq which 'previous))
|
2008-11-20 09:03:31 +00:00
|
|
|
new old)
|
2008-09-23 06:03:13 +00:00
|
|
|
(setq new (cond
|
|
|
|
((and (numberp which)
|
|
|
|
(nth (1- which) '("-" "+" "*" "1." "1)"))))
|
|
|
|
((string-match "-" current) (if prevp "1)" "+"))
|
|
|
|
((string-match "\\+" current)
|
|
|
|
(if prevp "-" (if (looking-at "\\S-") "1." "*")))
|
|
|
|
((string-match "\\*" current) (if prevp "+" "1."))
|
2008-11-20 09:03:31 +00:00
|
|
|
((string-match "\\." current)
|
|
|
|
(if prevp (if (looking-at "\\S-") "+" "*") "1)"))
|
2008-09-23 06:03:13 +00:00
|
|
|
((string-match ")" current) (if prevp "1." "-"))
|
|
|
|
(t (error "This should not happen"))))
|
2008-11-20 09:03:31 +00:00
|
|
|
(and (looking-at "\\([ \t]*\\)\\(\\S-+\\)")
|
|
|
|
(setq old (match-string 2))
|
|
|
|
(replace-match (concat "\\1" new)))
|
|
|
|
(org-shift-item-indentation (- (length new) (length old)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-fix-bullet-type)
|
|
|
|
(org-maybe-renumber-ordered-list))))
|
|
|
|
|
|
|
|
(defun org-get-string-indentation (s)
|
|
|
|
"What indentation has S due to SPACE and TAB at the beginning of the string?"
|
|
|
|
(let ((n -1) (i 0) (w tab-width) c)
|
|
|
|
(catch 'exit
|
|
|
|
(while (< (setq n (1+ n)) (length s))
|
|
|
|
(setq c (aref s n))
|
|
|
|
(cond ((= c ?\ ) (setq i (1+ i)))
|
|
|
|
((= c ?\t) (setq i (* (/ (+ w i) w) w)))
|
|
|
|
(t (throw 'exit t)))))
|
|
|
|
i))
|
|
|
|
|
|
|
|
(defun org-renumber-ordered-list (arg)
|
|
|
|
"Renumber an ordered plain list.
|
|
|
|
Cursor needs to be in the first line of an item, the line that starts
|
|
|
|
with something like \"1.\" or \"2)\"."
|
|
|
|
(interactive "p")
|
|
|
|
(unless (and (org-at-item-p)
|
|
|
|
(match-beginning 3))
|
|
|
|
(error "This is not an ordered list"))
|
|
|
|
(let ((line (org-current-line))
|
|
|
|
(col (current-column))
|
|
|
|
(ind (org-get-string-indentation
|
|
|
|
(buffer-substring (point-at-bol) (match-beginning 3))))
|
|
|
|
;; (term (substring (match-string 3) -1))
|
|
|
|
ind1 (n (1- arg))
|
2008-11-20 09:03:31 +00:00
|
|
|
fmt bobp old new)
|
2008-09-23 06:03:13 +00:00
|
|
|
;; find where this list begins
|
|
|
|
(org-beginning-of-item-list)
|
|
|
|
(setq bobp (bobp))
|
|
|
|
(looking-at "[ \t]*[0-9]+\\([.)]\\)")
|
2009-02-15 18:59:11 +00:00
|
|
|
(setq fmt (concat "%d" (or (match-string 1) ".")))
|
2008-09-23 06:03:13 +00:00
|
|
|
(beginning-of-line 0)
|
|
|
|
;; walk forward and replace these numbers
|
|
|
|
(catch 'exit
|
|
|
|
(while t
|
|
|
|
(catch 'next
|
|
|
|
(if bobp (setq bobp nil) (beginning-of-line 2))
|
|
|
|
(if (eobp) (throw 'exit nil))
|
|
|
|
(if (looking-at "[ \t]*$") (throw 'next nil))
|
|
|
|
(skip-chars-forward " \t") (setq ind1 (current-column))
|
|
|
|
(if (> ind1 ind) (throw 'next t))
|
|
|
|
(if (< ind1 ind) (throw 'exit t))
|
|
|
|
(if (not (org-at-item-p)) (throw 'exit nil))
|
2008-11-20 09:03:31 +00:00
|
|
|
(setq old (match-string 2))
|
2008-09-23 06:03:13 +00:00
|
|
|
(delete-region (match-beginning 2) (match-end 2))
|
|
|
|
(goto-char (match-beginning 2))
|
2008-11-20 09:03:31 +00:00
|
|
|
(insert (setq new (format fmt (setq n (1+ n)))))
|
|
|
|
(org-shift-item-indentation (- (length new) (length old))))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-line line)
|
|
|
|
(org-move-to-column col)))
|
|
|
|
|
|
|
|
(defun org-fix-bullet-type ()
|
2008-11-20 09:03:31 +00:00
|
|
|
"Make sure all items in this list have the same bullet as the first item.
|
|
|
|
Also, fix the indentation."
|
2008-09-23 06:03:13 +00:00
|
|
|
(interactive)
|
|
|
|
(unless (org-at-item-p) (error "This is not a list"))
|
|
|
|
(let ((line (org-current-line))
|
|
|
|
(col (current-column))
|
|
|
|
(ind (current-indentation))
|
2008-11-20 09:03:31 +00:00
|
|
|
ind1 bullet oldbullet)
|
2008-09-23 06:03:13 +00:00
|
|
|
;; find where this list begins
|
|
|
|
(org-beginning-of-item-list)
|
|
|
|
(beginning-of-line 1)
|
|
|
|
;; find out what the bullet type is
|
|
|
|
(looking-at "[ \t]*\\(\\S-+\\)")
|
2008-11-21 05:54:46 +00:00
|
|
|
(setq bullet (concat (match-string 1) " "))
|
|
|
|
(if (and org-list-two-spaces-after-bullet-regexp
|
|
|
|
(string-match org-list-two-spaces-after-bullet-regexp bullet))
|
|
|
|
(setq bullet (concat bullet " ")))
|
2008-09-23 06:03:13 +00:00
|
|
|
;; walk forward and replace these numbers
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(catch 'exit
|
|
|
|
(while t
|
|
|
|
(catch 'next
|
|
|
|
(beginning-of-line 2)
|
|
|
|
(if (eobp) (throw 'exit nil))
|
|
|
|
(if (looking-at "[ \t]*$") (throw 'next nil))
|
|
|
|
(skip-chars-forward " \t") (setq ind1 (current-column))
|
|
|
|
(if (> ind1 ind) (throw 'next t))
|
|
|
|
(if (< ind1 ind) (throw 'exit t))
|
|
|
|
(if (not (org-at-item-p)) (throw 'exit nil))
|
|
|
|
(skip-chars-forward " \t")
|
2008-11-21 05:54:46 +00:00
|
|
|
(looking-at "\\S-+ *")
|
2008-11-20 09:03:31 +00:00
|
|
|
(setq oldbullet (match-string 0))
|
2009-02-15 18:50:56 +00:00
|
|
|
(unless (equal bullet oldbullet) (replace-match bullet))
|
2008-11-20 09:03:31 +00:00
|
|
|
(org-shift-item-indentation (- (length bullet) (length oldbullet))))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-line line)
|
|
|
|
(org-move-to-column col)
|
|
|
|
(if (string-match "[0-9]" bullet)
|
|
|
|
(org-renumber-ordered-list 1))))
|
|
|
|
|
2008-11-20 09:03:31 +00:00
|
|
|
(defun org-shift-item-indentation (delta)
|
|
|
|
"Shift the indentation in current item by DELTA."
|
|
|
|
(save-excursion
|
2008-11-20 16:51:51 +00:00
|
|
|
(let ((beg (point-at-bol))
|
|
|
|
(end (progn (org-end-of-item) (point)))
|
|
|
|
i)
|
2008-11-20 09:03:31 +00:00
|
|
|
(goto-char end)
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(while (> (point) beg)
|
|
|
|
(when (looking-at "[ \t]*\\S-")
|
|
|
|
;; this is not an empty line
|
|
|
|
(setq i (org-get-indentation))
|
|
|
|
(if (and (> i 0) (> (setq i (+ i delta)) 0))
|
|
|
|
(indent-line-to i)))
|
|
|
|
(beginning-of-line 0)))))
|
|
|
|
|
2008-09-23 06:03:13 +00:00
|
|
|
(defun org-beginning-of-item-list ()
|
|
|
|
"Go to the beginning of the current item list.
|
|
|
|
I.e. to the first item in this list."
|
|
|
|
(interactive)
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(let ((pos (point-at-bol))
|
2008-12-16 16:17:15 +00:00
|
|
|
(ind (org-get-indentation))
|
2008-09-23 06:03:13 +00:00
|
|
|
ind1)
|
|
|
|
;; find where this list begins
|
|
|
|
(catch 'exit
|
|
|
|
(while t
|
|
|
|
(catch 'next
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(if (looking-at "[ \t]*$")
|
|
|
|
(throw (if (bobp) 'exit 'next) t))
|
|
|
|
(skip-chars-forward " \t") (setq ind1 (current-column))
|
|
|
|
(if (or (< ind1 ind)
|
|
|
|
(and (= ind1 ind)
|
|
|
|
(not (org-at-item-p)))
|
|
|
|
(and (= (point-at-bol) (point-min))
|
|
|
|
(setq pos (point-min))))
|
|
|
|
(throw 'exit t)
|
|
|
|
(when (org-at-item-p) (setq pos (point-at-bol)))))))
|
|
|
|
(goto-char pos)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun org-end-of-item-list ()
|
|
|
|
"Go to the end of the current item list.
|
|
|
|
I.e. to the text after the last item."
|
|
|
|
(interactive)
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(let ((pos (point-at-bol))
|
2008-12-16 16:17:15 +00:00
|
|
|
(ind (org-get-indentation))
|
2008-09-23 06:03:13 +00:00
|
|
|
ind1)
|
|
|
|
;; find where this list begins
|
|
|
|
(catch 'exit
|
|
|
|
(while t
|
|
|
|
(catch 'next
|
|
|
|
(beginning-of-line 2)
|
|
|
|
(if (looking-at "[ \t]*$")
|
|
|
|
(throw (if (eobp) 'exit 'next) t))
|
|
|
|
(skip-chars-forward " \t") (setq ind1 (current-column))
|
|
|
|
(if (or (< ind1 ind)
|
|
|
|
(and (= ind1 ind)
|
|
|
|
(not (org-at-item-p)))
|
|
|
|
(eobp))
|
|
|
|
(progn
|
|
|
|
(setq pos (point-at-bol))
|
|
|
|
(throw 'exit t))))))
|
|
|
|
(goto-char pos)))
|
|
|
|
|
|
|
|
|
|
|
|
(defvar org-last-indent-begin-marker (make-marker))
|
|
|
|
(defvar org-last-indent-end-marker (make-marker))
|
|
|
|
|
|
|
|
(defun org-outdent-item (arg)
|
|
|
|
"Outdent a local list item."
|
|
|
|
(interactive "p")
|
|
|
|
(org-indent-item (- arg)))
|
|
|
|
|
|
|
|
(defun org-indent-item (arg)
|
|
|
|
"Indent a local list item."
|
|
|
|
(interactive "p")
|
2009-02-20 16:20:46 +00:00
|
|
|
(and (org-region-active-p) (org-cursor-to-region-beginning))
|
2008-09-23 06:03:13 +00:00
|
|
|
(unless (org-at-item-p)
|
|
|
|
(error "Not on an item"))
|
|
|
|
(save-excursion
|
|
|
|
(let (beg end ind ind1 tmp delta ind-down ind-up)
|
2009-02-20 16:20:46 +00:00
|
|
|
(setq end (and (org-region-active-p) (region-end)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(if (memq last-command '(org-shiftmetaright org-shiftmetaleft))
|
|
|
|
(setq beg org-last-indent-begin-marker
|
|
|
|
end org-last-indent-end-marker)
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq beg (move-marker org-last-indent-begin-marker (point)))
|
|
|
|
(org-end-of-item)
|
2009-02-20 16:20:46 +00:00
|
|
|
(setq end (move-marker org-last-indent-end-marker (or end (point)))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(goto-char beg)
|
|
|
|
(setq tmp (org-item-indent-positions)
|
|
|
|
ind (car tmp)
|
|
|
|
ind-down (nth 2 tmp)
|
|
|
|
ind-up (nth 1 tmp)
|
|
|
|
delta (if (> arg 0)
|
|
|
|
(if ind-down (- ind-down ind) 2)
|
|
|
|
(if ind-up (- ind-up ind) -2)))
|
|
|
|
(if (< (+ delta ind) 0) (error "Cannot outdent beyond margin"))
|
|
|
|
(while (< (point) end)
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(skip-chars-forward " \t") (setq ind1 (current-column))
|
|
|
|
(delete-region (point-at-bol) (point))
|
|
|
|
(or (eolp) (org-indent-to-column (+ ind1 delta)))
|
|
|
|
(beginning-of-line 2))))
|
|
|
|
(org-fix-bullet-type)
|
|
|
|
(org-maybe-renumber-ordered-list-safe)
|
|
|
|
(save-excursion
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(condition-case nil (org-beginning-of-item) (error nil))
|
|
|
|
(org-maybe-renumber-ordered-list-safe)))
|
|
|
|
|
|
|
|
(defun org-item-indent-positions ()
|
|
|
|
"Return indentation for plain list items.
|
2008-12-16 16:17:15 +00:00
|
|
|
This returns a list with three values: The current indentation, the
|
2008-12-16 16:20:59 +00:00
|
|
|
parent indentation and the indentation a child should have.
|
2008-09-23 06:03:13 +00:00
|
|
|
Assumes cursor in item line."
|
|
|
|
(let* ((bolpos (point-at-bol))
|
|
|
|
(ind (org-get-indentation))
|
|
|
|
ind-down ind-up pos)
|
|
|
|
(save-excursion
|
|
|
|
(org-beginning-of-item-list)
|
|
|
|
(skip-chars-backward "\n\r \t")
|
|
|
|
(when (org-in-item-p)
|
|
|
|
(org-beginning-of-item)
|
|
|
|
(setq ind-up (org-get-indentation))))
|
|
|
|
(setq pos (point))
|
|
|
|
(save-excursion
|
|
|
|
(cond
|
|
|
|
((and (condition-case nil (progn (org-previous-item) t)
|
|
|
|
(error nil))
|
|
|
|
(or (forward-char 1) t)
|
|
|
|
(re-search-forward "^\\([ \t]*\\([-+]\\|\\([0-9]+[.)]\\)\\)\\|[ \t]+\\*\\)\\( \\|$\\)" bolpos t))
|
|
|
|
(setq ind-down (org-get-indentation)))
|
|
|
|
((and (goto-char pos)
|
|
|
|
(org-at-item-p))
|
|
|
|
(goto-char (match-end 0))
|
|
|
|
(skip-chars-forward " \t")
|
|
|
|
(setq ind-down (current-column)))))
|
|
|
|
(list ind ind-up ind-down)))
|
|
|
|
|
|
|
|
|
2008-09-23 06:13:32 +00:00
|
|
|
;;; Send and receive lists
|
2008-09-23 06:03:13 +00:00
|
|
|
|
|
|
|
(defun org-list-parse-list (&optional delete)
|
|
|
|
"Parse the list at point and maybe DELETE it.
|
|
|
|
Return a list containing first level items as strings and
|
|
|
|
sublevels as a list of strings."
|
|
|
|
(let* ((item-beginning (org-list-item-beginning))
|
2008-12-16 16:17:15 +00:00
|
|
|
(start (car item-beginning))
|
|
|
|
(end (org-list-end (cdr item-beginning)))
|
|
|
|
output itemsep ltype)
|
2008-09-23 06:03:13 +00:00
|
|
|
(while (re-search-forward org-list-beginning-re end t)
|
|
|
|
(goto-char (match-beginning 3))
|
|
|
|
(save-match-data
|
2008-12-16 16:17:15 +00:00
|
|
|
(cond ((string-match "[0-9]" (match-string 2))
|
|
|
|
(setq itemsep "[0-9]+\\(?:\\.\\|)\\)"
|
|
|
|
ltype 'ordered))
|
|
|
|
((string-match "^.*::" (match-string 0))
|
|
|
|
(setq itemsep "[-+]" ltype 'descriptive))
|
|
|
|
(t (setq itemsep "[-+]" ltype 'unordered))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(let* ((indent1 (match-string 1))
|
|
|
|
(nextitem (save-excursion
|
|
|
|
(save-match-data
|
|
|
|
(or (and (re-search-forward
|
|
|
|
(concat "^" indent1 itemsep " *?") end t)
|
|
|
|
(match-beginning 0)) end))))
|
|
|
|
(item (buffer-substring
|
|
|
|
(point)
|
|
|
|
(or (and (re-search-forward
|
|
|
|
org-list-beginning-re end t)
|
|
|
|
(goto-char (match-beginning 0)))
|
|
|
|
(goto-char end))))
|
|
|
|
(nextindent (match-string 1))
|
|
|
|
(item (org-trim item))
|
2009-01-06 16:23:36 +00:00
|
|
|
(item (if (string-match "^\\[\\([xX ]\\)\\]" item)
|
|
|
|
(replace-match (if (equal (match-string 1 item) " ")
|
|
|
|
"[CBOFF]"
|
|
|
|
"[CBON]")
|
|
|
|
t nil item)
|
|
|
|
item)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(push item output)
|
|
|
|
(when (> (length nextindent)
|
|
|
|
(length indent1))
|
|
|
|
(narrow-to-region (point) nextitem)
|
|
|
|
(push (org-list-parse-list) output)
|
|
|
|
(widen))))
|
|
|
|
(when delete (delete-region start end))
|
|
|
|
(setq output (nreverse output))
|
|
|
|
(push ltype output)))
|
|
|
|
|
|
|
|
(defun org-list-item-beginning ()
|
|
|
|
"Find the beginning of the list item.
|
|
|
|
Return a cons which car is the beginning position of the item and
|
|
|
|
cdr is the indentation string."
|
|
|
|
(save-excursion
|
|
|
|
(if (not (or (looking-at org-list-beginning-re)
|
|
|
|
(re-search-backward
|
|
|
|
org-list-beginning-re nil t)))
|
|
|
|
(progn (goto-char (point-min)) (point))
|
|
|
|
(cons (match-beginning 0) (match-string 1)))))
|
|
|
|
|
|
|
|
(defun org-list-end (indent)
|
|
|
|
"Return the position of the end of the list.
|
|
|
|
INDENT is the indentation of the list."
|
|
|
|
(save-excursion
|
|
|
|
(catch 'exit
|
|
|
|
(while (or (looking-at org-list-beginning-re)
|
|
|
|
(looking-at (concat "^" indent "[ \t]+\\|^$")))
|
|
|
|
(if (eq (point) (point-max))
|
|
|
|
(throw 'exit (point-max)))
|
|
|
|
(forward-line 1))) (point)))
|
|
|
|
|
|
|
|
(defun org-list-insert-radio-list ()
|
|
|
|
"Insert a radio list template appropriate for this major mode."
|
|
|
|
(interactive)
|
|
|
|
(let* ((e (assq major-mode org-list-radio-list-templates))
|
|
|
|
(txt (nth 1 e))
|
|
|
|
name pos)
|
|
|
|
(unless e (error "No radio list setup defined for %s" major-mode))
|
|
|
|
(setq name (read-string "List name: "))
|
|
|
|
(while (string-match "%n" txt)
|
|
|
|
(setq txt (replace-match name t t txt)))
|
|
|
|
(or (bolp) (insert "\n"))
|
|
|
|
(setq pos (point))
|
|
|
|
(insert txt)
|
|
|
|
(goto-char pos)))
|
|
|
|
|
|
|
|
(defun org-list-send-list (&optional maybe)
|
|
|
|
"Send a tranformed version of this list to the receiver position.
|
|
|
|
With argument MAYBE, fail quietly if no transformation is defined for
|
|
|
|
this list."
|
|
|
|
(interactive)
|
|
|
|
(catch 'exit
|
|
|
|
(unless (org-at-item-p) (error "Not at a list"))
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (car (org-list-item-beginning)))
|
|
|
|
(beginning-of-line 0)
|
|
|
|
(unless (looking-at "#\\+ORGLST: *SEND +\\([a-zA-Z0-9_]+\\) +\\([^ \t\r\n]+\\)\\( +.*\\)?")
|
|
|
|
(if maybe
|
|
|
|
(throw 'exit nil)
|
|
|
|
(error "Don't know how to transform this list"))))
|
|
|
|
(let* ((name (match-string 1))
|
2008-12-16 16:17:15 +00:00
|
|
|
(item-beginning (org-list-item-beginning))
|
2008-09-23 06:03:13 +00:00
|
|
|
(transform (intern (match-string 2)))
|
|
|
|
(txt (buffer-substring-no-properties
|
2008-12-16 16:17:15 +00:00
|
|
|
(car item-beginning)
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-list-end (cdr item-beginning))))
|
|
|
|
(list (org-list-parse-list))
|
2008-12-16 16:17:15 +00:00
|
|
|
beg)
|
2008-09-23 06:03:13 +00:00
|
|
|
(unless (fboundp transform)
|
|
|
|
(error "No such transformation function %s" transform))
|
|
|
|
(setq txt (funcall transform list))
|
|
|
|
;; Find the insertion place
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (point-min))
|
|
|
|
(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"))
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(delete-region beg (point))
|
|
|
|
(goto-char beg)
|
|
|
|
(insert txt "\n"))
|
|
|
|
(message "List converted and installed at receiver location"))))
|
|
|
|
|
|
|
|
(defun org-list-to-generic (list params)
|
|
|
|
"Convert a LIST parsed through `org-list-parse-list' to other formats.
|
|
|
|
|
|
|
|
Valid parameters PARAMS are
|
|
|
|
|
2008-12-16 16:17:15 +00:00
|
|
|
:ustart String to start an unordered list
|
|
|
|
:uend String to end an unordered list
|
2008-09-23 06:03:13 +00:00
|
|
|
|
2008-12-16 16:17:15 +00:00
|
|
|
:ostart String to start an ordered list
|
|
|
|
:oend String to end an ordered list
|
2008-09-23 06:03:13 +00:00
|
|
|
|
2008-12-16 16:17:15 +00:00
|
|
|
:dstart String to start a descriptive list
|
|
|
|
:dend String to end a descriptive list
|
2008-09-23 06:03:13 +00:00
|
|
|
:dtstart String to start a descriptive term
|
2008-12-16 16:17:15 +00:00
|
|
|
:dtend String to end a descriptive term
|
2008-09-23 06:03:13 +00:00
|
|
|
:ddstart String to start a description
|
2008-12-16 16:17:15 +00:00
|
|
|
:ddend String to end a description
|
2008-09-23 06:03:13 +00:00
|
|
|
|
2008-12-16 16:17:15 +00:00
|
|
|
: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.
|
2008-09-23 06:03:13 +00:00
|
|
|
|
2008-12-16 16:17:15 +00:00
|
|
|
:istart String to start a list item
|
|
|
|
:iend String to end a list item
|
|
|
|
:isep String to separate items
|
2009-01-06 16:23:36 +00:00
|
|
|
:lsep String to separate sublists
|
|
|
|
|
|
|
|
:cboff String to insert for an unchecked checkbox
|
|
|
|
:cbon String to insert for a checked checkbox"
|
2008-09-23 06:03:13 +00:00
|
|
|
(interactive)
|
|
|
|
(let* ((p params) sublist
|
|
|
|
(splicep (plist-get p :splice))
|
|
|
|
(ostart (plist-get p :ostart))
|
2008-12-16 16:17:15 +00:00
|
|
|
(oend (plist-get p :oend))
|
2008-09-23 06:03:13 +00:00
|
|
|
(ustart (plist-get p :ustart))
|
2008-12-16 16:17:15 +00:00
|
|
|
(uend (plist-get p :uend))
|
2008-09-23 06:03:13 +00:00
|
|
|
(dstart (plist-get p :dstart))
|
2008-12-16 16:17:15 +00:00
|
|
|
(dend (plist-get p :dend))
|
2008-09-23 06:03:13 +00:00
|
|
|
(dtstart (plist-get p :dtstart))
|
2008-12-16 16:17:15 +00:00
|
|
|
(dtend (plist-get p :dtend))
|
2008-09-23 06:03:13 +00:00
|
|
|
(ddstart (plist-get p :ddstart))
|
2008-12-16 16:17:15 +00:00
|
|
|
(ddend (plist-get p :ddend))
|
2008-09-23 06:03:13 +00:00
|
|
|
(istart (plist-get p :istart))
|
2008-12-16 16:17:15 +00:00
|
|
|
(iend (plist-get p :iend))
|
|
|
|
(isep (plist-get p :isep))
|
2009-01-06 16:23:36 +00:00
|
|
|
(lsep (plist-get p :lsep))
|
|
|
|
(cbon (plist-get p :cbon))
|
|
|
|
(cboff (plist-get p :cboff)))
|
2008-09-23 06:03:13 +00:00
|
|
|
(let ((wrapper
|
|
|
|
(cond ((eq (car list) 'ordered)
|
|
|
|
(concat ostart "\n%s" oend "\n"))
|
|
|
|
((eq (car list) 'unordered)
|
|
|
|
(concat ustart "\n%s" uend "\n"))
|
|
|
|
((eq (car list) 'descriptive)
|
|
|
|
(concat dstart "\n%s" dend "\n"))))
|
|
|
|
rtn term defstart defend)
|
|
|
|
(while (setq sublist (pop list))
|
|
|
|
(cond ((symbolp sublist) nil)
|
|
|
|
((stringp sublist)
|
2008-12-16 16:17:15 +00:00
|
|
|
(when (string-match "^\\(.*\\) ::" sublist)
|
|
|
|
(setq term (org-trim (format (concat dtstart "%s" dtend)
|
|
|
|
(match-string 1 sublist))))
|
|
|
|
(setq sublist (substring sublist (1+ (length term)))))
|
2009-01-06 16:23:36 +00:00
|
|
|
(if (string-match "\\[CBON\\]" sublist)
|
|
|
|
(setq sublist (replace-match cbon t t sublist)))
|
|
|
|
(if (string-match "\\[CBOFF\\]" sublist)
|
|
|
|
(setq sublist (replace-match cboff t t sublist)))
|
2008-12-16 16:17:15 +00:00
|
|
|
(setq rtn (concat rtn istart term ddstart
|
|
|
|
sublist ddend iend isep)))
|
|
|
|
(t (setq rtn (concat rtn ;; previous list
|
|
|
|
lsep ;; list separator
|
|
|
|
(org-list-to-generic sublist p)
|
|
|
|
lsep ;; list separator
|
|
|
|
)))))
|
2008-09-23 06:03:13 +00:00
|
|
|
(format wrapper rtn))))
|
|
|
|
|
2009-01-06 16:23:36 +00:00
|
|
|
(defun org-list-to-latex (list &optional params)
|
|
|
|
"Convert LIST into a LaTeX list.
|
|
|
|
LIST is as returnd by `org-list-parse-list'. PARAMS is a property list
|
|
|
|
with overruling parameters for `org-list-to-generic'."
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-list-to-generic
|
2009-01-06 16:23:36 +00:00
|
|
|
list
|
|
|
|
(org-combine-plists
|
|
|
|
'(:splicep nil :ostart "\\begin{enumerate}" :oend "\\end{enumerate}"
|
|
|
|
:ustart "\\begin{itemize}" :uend "\\end{itemize}"
|
|
|
|
:dstart "\\begin{description}" :dend "\\end{description}"
|
|
|
|
:dtstart "[" :dtend "]"
|
|
|
|
:ddstart "" :ddend ""
|
|
|
|
:istart "\\item " :iend ""
|
|
|
|
:isep "\n" :lsep "\n"
|
|
|
|
:cbon "\\texttt{[X]}" :cboff "\\texttt{[ ]}")
|
|
|
|
params)))
|
|
|
|
|
|
|
|
(defun org-list-to-html (list &optional params)
|
|
|
|
"Convert LIST into a HTML list.
|
|
|
|
LIST is as returnd by `org-list-parse-list'. PARAMS is a property list
|
|
|
|
with overruling parameters for `org-list-to-generic'."
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-list-to-generic
|
2009-01-06 16:23:36 +00:00
|
|
|
list
|
|
|
|
(org-combine-plists
|
|
|
|
'(:splicep nil :ostart "<ol>" :oend "</ol>"
|
|
|
|
:ustart "<ul>" :uend "</ul>"
|
|
|
|
:dstart "<dl>" :dend "</dl>"
|
|
|
|
:dtstart "<dt>" :dtend "</dt>"
|
|
|
|
:ddstart "<dd>" :ddend "</dd>"
|
|
|
|
:istart "<li>" :iend "</li>"
|
|
|
|
:isep "\n" :lsep "\n"
|
|
|
|
:cbon "<code>[X]</code>" :cboff "<code>[ ]</code>")
|
|
|
|
params)))
|
|
|
|
|
|
|
|
(defun org-list-to-texinfo (list &optional params)
|
|
|
|
"Convert LIST into a Texinfo list.
|
|
|
|
LIST is as returnd by `org-list-parse-list'. PARAMS is a property list
|
|
|
|
with overruling parameters for `org-list-to-generic'."
|
2008-09-23 06:03:13 +00:00
|
|
|
(org-list-to-generic
|
2009-01-06 16:23:36 +00:00
|
|
|
list
|
|
|
|
(org-combine-plists
|
|
|
|
'(:splicep nil :ostart "@itemize @minus" :oend "@end itemize"
|
|
|
|
:ustart "@enumerate" :uend "@end enumerate"
|
|
|
|
:dstart "@table" :dend "@end table"
|
|
|
|
:dtstart "@item " :dtend "\n"
|
|
|
|
:ddstart "" :ddend ""
|
|
|
|
:istart "@item\n" :iend ""
|
|
|
|
:isep "\n" :lsep "\n"
|
|
|
|
:cbon "@code{[X]}" :cboff "@code{[ ]}")
|
|
|
|
params)))
|
2008-09-23 06:03:13 +00:00
|
|
|
|
|
|
|
(provide 'org-list)
|
|
|
|
|
2008-10-15 08:20:24 +00:00
|
|
|
;; arch-tag: 73cf50c1-200f-4d1d-8a53-4e842a5b11c8
|
2008-09-23 06:03:13 +00:00
|
|
|
;;; org-list.el ends here
|