430 lines
15 KiB
EmacsLisp
430 lines
15 KiB
EmacsLisp
;;; enumitem.el --- AUCTeX style for `enumitem.sty' (v3.5.2)
|
|
|
|
;; Copyright (C) 2015 Free Software Foundation, Inc.
|
|
|
|
;; Author: Arash Esbati <esbati'at'gmx.de>
|
|
;; Maintainer: auctex-devel@gnu.org
|
|
;; Created: 2014-10-20
|
|
;; Keywords: tex
|
|
|
|
;; This file is part of AUCTeX.
|
|
|
|
;; AUCTeX 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, or (at your option)
|
|
;; any later version.
|
|
|
|
;; AUCTeX is distributed in the hope that it will be useful, but
|
|
;; WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
;; General Public License for more details.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with AUCTeX; see the file COPYING. If not, write to the Free
|
|
;; Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
|
|
;; 02110-1301, USA.
|
|
|
|
;;; Commentary:
|
|
|
|
;; This file adds support for `enumitem.sty' (v3.5.2) from 2011/09/28.
|
|
;; `enumitem.sty' is part of TeXLive.
|
|
|
|
;; Tassilo Horn's `minted.el' was a major source of inspiration for
|
|
;; this style, many thanks to him (also for patiently answering my
|
|
;; many other questions, incl. the stupid ones.)
|
|
|
|
;; If things do not work or when in doubt, press `C-c C-n'. Comments
|
|
;; for improvement are welcome.
|
|
|
|
;;; Code:
|
|
|
|
;; Needed for compiling `pushnew':
|
|
(eval-when-compile (require 'cl))
|
|
|
|
;; Needed for auto-parsing.
|
|
(require 'tex)
|
|
|
|
(defvar LaTeX-enumitem-key-val-options
|
|
'(;; Vertical Spacing
|
|
("topsep")
|
|
("partopsep")
|
|
("parsep")
|
|
("itemsep")
|
|
;; Horizontal Spacing
|
|
("leftmargin" ("*" "!"))
|
|
("itemindent" ("*" "!"))
|
|
("labelsep" ("*" "!"))
|
|
("labelwidth" ("*" "!"))
|
|
("labelindent" ("*" "!"))
|
|
("labelsep*")
|
|
("labelindent*")
|
|
("widest")
|
|
("widest*")
|
|
("rightmargin")
|
|
;; Labels and cross reference format
|
|
("label")
|
|
("label*")
|
|
("ref")
|
|
("font")
|
|
("format")
|
|
("align" ("left" "right" "parleft"))
|
|
;; Numbering, stopping, resuming
|
|
("start")
|
|
("resume")
|
|
("resume*")
|
|
;; Series
|
|
("series")
|
|
;; Penalties
|
|
("beginpenalty")
|
|
("midpenalty")
|
|
("endpenalty")
|
|
("before")
|
|
("before*")
|
|
("after")
|
|
("after*")
|
|
;; Description styles
|
|
("style" ("standard" "multiline" "nextline" "sameline" "unboxed"))
|
|
;; Compact lists
|
|
("noitemsep")
|
|
("nosep")
|
|
;; Wide lists
|
|
("wide")
|
|
;; Inline lists
|
|
("itemjoin")
|
|
("itemjoin*")
|
|
("afterlabel")
|
|
("mode" ("boxed" "unboxed")))
|
|
"Key=value options for enumitem macros and environments.")
|
|
|
|
(defvar LaTeX-enumitem-key-val-options-local nil
|
|
"Buffer-local key=value options for enumitem macros and environments.")
|
|
(make-variable-buffer-local 'LaTeX-enumitem-key-val-options-local)
|
|
|
|
(defvar LaTeX-enumitem-newlist-list-local nil
|
|
"Local list of all environments definded with `\\newlist' plus
|
|
the ones initially available through `enumitem' package.")
|
|
(make-variable-buffer-local 'LaTeX-enumitem-newlist-list-local)
|
|
|
|
;; Setup for \newlist:
|
|
|
|
(TeX-auto-add-type "enumitem-newlist" "LaTeX")
|
|
|
|
(defvar LaTeX-enumitem-newlist-regexp
|
|
'("\\\\newlist{\\([^}]+\\)}{\\([^}]+\\)}"
|
|
(1 2) LaTeX-auto-enumitem-newlist)
|
|
"Matches the arguments of `\\newlist' from `enumitem'
|
|
package.")
|
|
|
|
;; Setup for \SetEnumitemKey:
|
|
|
|
(TeX-auto-add-type "enumitem-SetEnumitemKey" "LaTeX")
|
|
|
|
(defvar LaTeX-enumitem-SetEnumitemKey-regexp
|
|
'("\\\\SetEnumitemKey{\\([^}]+\\)}"
|
|
1 LaTeX-auto-enumitem-SetEnumitemKey)
|
|
"Matches the arguments of `\\SetEnumitemKey' from `enumitem'
|
|
package.")
|
|
|
|
;; Setup for \SetEnumitemValue:
|
|
|
|
(TeX-auto-add-type "enumitem-SetEnumitemValue" "LaTeX")
|
|
|
|
;; Upon Tassilo's recommendation, we include also `0' so that we can
|
|
;; use the function `LaTeX-enumitem-SetEnumitemValue-list' while we
|
|
;; make sure that `TeX-auto-list-information' doesn't remove multiple
|
|
;; defined values to a specific key. For this reason, we also ignore
|
|
;; the 3. argument to the `\SetEnumitemValue' macro (i.e., a third
|
|
;; {\\([^}]+\\)} in regex) so that we don't pollute the generated
|
|
;; `docname.el' with unnecessary (La)TeX code.
|
|
(defvar LaTeX-enumitem-SetEnumitemValue-regexp
|
|
'("\\\\SetEnumitemValue{\\([^}]+\\)}{\\([^}]+\\)}"
|
|
(0 1 2) LaTeX-auto-enumitem-SetEnumitemValue)
|
|
"Matches the arguments of `\\SetEnumitemValue' from `enumitem'
|
|
package.")
|
|
|
|
;; Plug them into the machinery.
|
|
(defun LaTeX-enumitem-auto-prepare ()
|
|
"Clear various `LaTeX-enumitem-*' before parsing."
|
|
(setq LaTeX-auto-enumitem-newlist nil
|
|
LaTeX-auto-enumitem-SetEnumitemKey nil
|
|
LaTeX-auto-enumitem-SetEnumitemValue nil))
|
|
|
|
(defun LaTeX-enumitem-auto-cleanup ()
|
|
"Move parsing results into right places for further usage."
|
|
;; \newlist{<name>}{<type>}{<max-depth>}
|
|
;; env=<name>, type=<type>, ignored=<max-depth>
|
|
(dolist (env-type (LaTeX-enumitem-newlist-list))
|
|
(let* ((env (car env-type))
|
|
(type (cadr env-type)))
|
|
(LaTeX-add-environments (list env 'LaTeX-enumitem-env-with-opts))
|
|
;; Tell AUCTeX about parsed description like environments.
|
|
(when (or (string-equal type "description")
|
|
(string-equal type "description*"))
|
|
(add-to-list 'LaTeX-item-list `(,env . LaTeX-item-argument)))))
|
|
;; Now add the parsed env's to the local list.
|
|
(when (LaTeX-enumitem-newlist-list)
|
|
(setq LaTeX-enumitem-newlist-list-local
|
|
(append (mapcar 'list (mapcar 'car (LaTeX-enumitem-newlist-list)))
|
|
LaTeX-enumitem-newlist-list-local))))
|
|
|
|
(add-hook 'TeX-auto-prepare-hook #'LaTeX-enumitem-auto-prepare t)
|
|
(add-hook 'TeX-auto-cleanup-hook #'LaTeX-enumitem-auto-cleanup t)
|
|
(add-hook 'TeX-update-style-hook #'TeX-auto-parse t)
|
|
|
|
(defun LaTeX-enumitem-env-with-opts (env)
|
|
"Update available key-val options, then insert ENV and optional
|
|
key-val and the first item."
|
|
(LaTeX-enumitem-update-key-val-options)
|
|
(LaTeX-insert-environment
|
|
env
|
|
(let ((opts (TeX-read-key-val t LaTeX-enumitem-key-val-options-local)))
|
|
(when (and opts (not (string-equal opts "")))
|
|
(format "[%s]" opts))))
|
|
(if (TeX-active-mark)
|
|
(progn
|
|
(LaTeX-find-matching-begin)
|
|
(end-of-line 1))
|
|
(end-of-line 0))
|
|
(delete-char 1)
|
|
(when (looking-at (concat "^[ \t]+$\\|"
|
|
"^[ \t]*" TeX-comment-start-regexp "+[ \t]*$"))
|
|
(delete-region (point) (line-end-position)))
|
|
(delete-horizontal-space)
|
|
;; Deactivate the mark here in order to prevent `TeX-parse-macro'
|
|
;; from swapping point and mark and the \item ending up right after
|
|
;; \begin{...}.
|
|
(TeX-deactivate-mark)
|
|
(LaTeX-insert-item)
|
|
;; The inserted \item may have outdented the first line to the
|
|
;; right. Fill it, if appropriate.
|
|
(when (and (not (looking-at "$"))
|
|
(not (assoc environment LaTeX-indent-environment-list))
|
|
(> (- (line-end-position) (line-beginning-position))
|
|
(current-fill-column)))
|
|
(LaTeX-fill-paragraph nil)))
|
|
|
|
(defun LaTeX-arg-SetEnumitemKey (optional)
|
|
"Ask for a new key to be defined and add it to
|
|
`LaTeX-enumitem-key-val-options-local'."
|
|
(LaTeX-enumitem-update-key-val-options)
|
|
(let ((key (TeX-read-string "New Key: "))
|
|
(replace (TeX-read-key-val optional
|
|
LaTeX-enumitem-key-val-options-local "Replacement")))
|
|
(TeX-argument-insert key optional)
|
|
(TeX-argument-insert replace optional)
|
|
(add-to-list 'LaTeX-enumitem-key-val-options-local (list key))
|
|
(LaTeX-add-enumitem-SetEnumitemKeys key)))
|
|
|
|
;; In `LaTeX-enumitem-SetEnumitemValue-regexp', we match (0 1 2).
|
|
;; When adding a new `key=val', we need something unique for `0'-match
|
|
;; until the next `C-c C-n'. We mimic that regex-match bei concat'ing
|
|
;; the elements and pass the result to
|
|
;; `LaTeX-add-enumitem-SetEnumitemValues'. It will vanish upon next
|
|
;; invocation of `C-c C-n'.
|
|
(defun LaTeX-arg-SetEnumitemValue (optional)
|
|
"Ask for a new value added to an existing key incl. the final
|
|
replacement of the value."
|
|
(LaTeX-enumitem-update-key-val-options)
|
|
(let* ((key (TeX-read-key-val optional LaTeX-enumitem-key-val-options-local "Key"))
|
|
(val (TeX-read-string "String value: "))
|
|
;; (key-match (car (assoc key LaTeX-enumitem-key-val-options-local)))
|
|
(val-match (cdr (assoc key LaTeX-enumitem-key-val-options-local)))
|
|
(temp (copy-alist LaTeX-enumitem-key-val-options-local))
|
|
(opts (assq-delete-all (car (assoc key temp)) temp)))
|
|
(if val-match
|
|
(pushnew (list key (delete-dups (apply 'append (list val) val-match)))
|
|
opts :test #'equal)
|
|
(pushnew (list key (list val)) opts :test #'equal))
|
|
(setq LaTeX-enumitem-key-val-options-local (copy-alist opts))
|
|
(TeX-argument-insert key optional)
|
|
(TeX-argument-insert val optional)
|
|
(LaTeX-add-enumitem-SetEnumitemValues
|
|
(list (concat "\\SetEnumitemValue{" key "}{" val "}")
|
|
key val))))
|
|
|
|
(defun LaTeX-enumitem-update-key-val-options ()
|
|
"Update the buffer-local key-val options before offering them
|
|
in `enumitem'-completions."
|
|
(dolist (key (LaTeX-enumitem-SetEnumitemKey-list))
|
|
(add-to-list 'LaTeX-enumitem-key-val-options-local key))
|
|
(dolist (keyvals (LaTeX-enumitem-SetEnumitemValue-list))
|
|
(let* ((key (nth 1 keyvals))
|
|
(val (nth 2 keyvals))
|
|
;; (key-match (car (assoc key LaTeX-enumitem-key-val-options-local)))
|
|
(val-match (cdr (assoc key LaTeX-enumitem-key-val-options-local)))
|
|
(temp (copy-alist LaTeX-enumitem-key-val-options-local))
|
|
(opts (assq-delete-all (car (assoc key temp)) temp)))
|
|
(if val-match
|
|
(pushnew (list key (delete-dups (apply 'append (list val) val-match)))
|
|
opts :test #'equal)
|
|
(pushnew (list key (list val)) opts :test #'equal))
|
|
(setq LaTeX-enumitem-key-val-options-local (copy-alist opts)))))
|
|
|
|
(TeX-add-style-hook
|
|
"enumitem"
|
|
(lambda ()
|
|
|
|
;; Add enumitem to the parser.
|
|
(TeX-auto-add-regexp LaTeX-enumitem-newlist-regexp)
|
|
(TeX-auto-add-regexp LaTeX-enumitem-SetEnumitemKey-regexp)
|
|
(TeX-auto-add-regexp LaTeX-enumitem-SetEnumitemValue-regexp)
|
|
|
|
;; Activate the buffer-local version of key-vals.
|
|
(setq LaTeX-enumitem-key-val-options-local
|
|
(copy-alist LaTeX-enumitem-key-val-options))
|
|
|
|
;; Set the standard env's to the local list.
|
|
(setq LaTeX-enumitem-newlist-list-local
|
|
'(("itemize") ("enumerate") ("description")))
|
|
|
|
;; Add the starred versions to the local list.
|
|
(when (LaTeX-provided-package-options-member "enumitem" "inline")
|
|
(setq LaTeX-enumitem-newlist-list-local
|
|
(append '(("itemize*") ("enumerate*") ("description*"))
|
|
LaTeX-enumitem-newlist-list-local)))
|
|
|
|
;; Standard env's take key-val as optional argument.
|
|
(LaTeX-add-environments
|
|
'("itemize" LaTeX-enumitem-env-with-opts)
|
|
'("enumerate" LaTeX-enumitem-env-with-opts)
|
|
'("description" LaTeX-enumitem-env-with-opts))
|
|
|
|
;; Make inline env's available with package option "inline"
|
|
(when (LaTeX-provided-package-options-member "enumitem" "inline")
|
|
(LaTeX-add-environments
|
|
'("itemize*" LaTeX-enumitem-env-with-opts)
|
|
'("enumerate*" LaTeX-enumitem-env-with-opts)
|
|
'("description*" LaTeX-enumitem-env-with-opts))
|
|
(add-to-list 'LaTeX-item-list '("description*" . LaTeX-item-argument)))
|
|
|
|
;; Cloning lists
|
|
(TeX-add-symbols
|
|
;; The easy way would be:
|
|
;; '("newlist"
|
|
;; "Name" (TeX-arg-eval
|
|
;; completing-read "Type: "
|
|
;; '(("itemize") ("enumerate") ("description")
|
|
;; ("itemize*") ("enumerate*") ("description*")))
|
|
;; "Max-depth")
|
|
;; But we go the extra mile to improve the user experience and add
|
|
;; the arguments directly to appropriate lists.
|
|
;; \newlist{<name>}{<type>}{<max-depth>}
|
|
'("newlist"
|
|
(TeX-arg-eval
|
|
(lambda ()
|
|
(let ((name (TeX-read-string "Name: "))
|
|
(type (completing-read
|
|
"Type: "
|
|
'(("itemize") ("enumerate") ("description")
|
|
("itemize*") ("enumerate*") ("description*"))))
|
|
(depth (TeX-read-string "Max-depth: ")))
|
|
(setq LaTeX-enumitem-newlist-list-local
|
|
(append `(,(list name)) LaTeX-enumitem-newlist-list-local))
|
|
(when (or (string-equal type "description")
|
|
(string-equal type "description*"))
|
|
(add-to-list 'LaTeX-item-list `(,name . LaTeX-item-argument)))
|
|
(LaTeX-add-environments `(,name LaTeX-enumitem-env-with-opts))
|
|
(LaTeX-add-enumitem-newlists (list name type))
|
|
(insert (format "{%s}" name)
|
|
(format "{%s}" type))
|
|
(format "%s" depth)))))
|
|
|
|
;; \renewlist{<name>}{<type>}{<max-depth>}
|
|
'("renewlist"
|
|
(TeX-arg-eval completing-read "Name: "
|
|
LaTeX-enumitem-newlist-list-local)
|
|
(TeX-arg-eval completing-read "Type: "
|
|
'(("itemize") ("enumerate") ("description")
|
|
("itemize*") ("enumerate*") ("description*")))
|
|
"Max-depth")
|
|
|
|
;; \setlist[<names,levels>]{<key-vals>}
|
|
'("setlist"
|
|
[TeX-arg-eval mapconcat 'identity
|
|
(TeX-completing-read-multiple
|
|
"Environment(s), level(s): "
|
|
`(,@LaTeX-enumitem-newlist-list-local
|
|
("1") ("2") ("3") ("4"))) ","]
|
|
(TeX-arg-eval
|
|
(lambda ()
|
|
(LaTeX-enumitem-update-key-val-options)
|
|
(let ((opts (TeX-read-key-val nil LaTeX-enumitem-key-val-options-local)))
|
|
(format "%s" opts)))))
|
|
|
|
;; \setlist*[<names,levels>]{<key-vals>}
|
|
'("setlist*"
|
|
[TeX-arg-eval mapconcat 'identity
|
|
(TeX-completing-read-multiple
|
|
"Environment, level: "
|
|
`(,@LaTeX-enumitem-newlist-list-local
|
|
("1") ("2") ("3") ("4"))) ","]
|
|
(TeX-arg-eval
|
|
(lambda ()
|
|
(LaTeX-enumitem-update-key-val-options)
|
|
(let ((opts (TeX-read-key-val nil LaTeX-enumitem-key-val-options-local)))
|
|
(format "%s" opts))))) )
|
|
|
|
;; General commands:
|
|
(TeX-add-symbols
|
|
|
|
;; Ask for an Integer and insert it.
|
|
'("setlistdepth" "Integer")
|
|
|
|
;; Just add the braces and let the user do the rest.
|
|
'("AddEnumerateCounter" 3)
|
|
'("AddEnumerateCounter*" 3)
|
|
|
|
;; "\restartlist" only works for lists defined with "resume" key.
|
|
;; We will not extract that information and leave that to users.
|
|
;; For completion, extract enumerated environments from
|
|
;; `LaTeX-enumitem-newlist-list' and add "enumerate" to them.
|
|
'("restartlist"
|
|
(TeX-arg-eval
|
|
(lambda ()
|
|
(let ((enums '("enumerate")))
|
|
(when (LaTeX-provided-package-options-member "enumitem" "inline")
|
|
(pushnew "enumerate*" enums :test #'equal))
|
|
(dolist (env-type (LaTeX-enumitem-newlist-list))
|
|
(let ((env (car env-type))
|
|
(type (cadr env-type)))
|
|
(when (or (string-equal type "enumerate")
|
|
(string-equal type "enumerate*"))
|
|
(pushnew env enums :test #'equal))))
|
|
(completing-read "List name: " enums)))))
|
|
|
|
;; "Key" will be parsed and added to key-val list.
|
|
'("SetEnumitemKey" LaTeX-arg-SetEnumitemKey)
|
|
|
|
;; "Key" and "Value" are added to our key-val list
|
|
'("SetEnumitemValue" LaTeX-arg-SetEnumitemValue "Replacement"))
|
|
|
|
;; Setting enumerate short label
|
|
(when (LaTeX-provided-package-options-member "enumitem" "shortlabels")
|
|
(TeX-add-symbols
|
|
'("SetEnumerateShortLabel"
|
|
(TeX-arg-eval completing-read "Key: "
|
|
'(("A") ("a") ("I") ("i") ("1")))
|
|
"Replacement")))
|
|
|
|
;; Fontification
|
|
(when (and (featurep 'font-latex)
|
|
(eq TeX-install-font-lock 'font-latex-setup))
|
|
(font-latex-add-keywords '(("newlist" "{{{")
|
|
("renewlist" "{{{")
|
|
("setlist" "*[{")
|
|
("AddEnumerateCounter" "*{{{")
|
|
("SetEnumitemKey" "{{" )
|
|
("SetEnumitemValue" "{{{"))
|
|
'function)
|
|
(font-latex-add-keywords '(("restartlist" "{" )
|
|
("setlistdepth" "{" )
|
|
("SetEnumerateShortLabel" "{{"))
|
|
'variable)))
|
|
LaTeX-dialect)
|
|
|
|
(defvar LaTeX-enumitem-package-options
|
|
'("inline" "ignoredisplayed" "shortlabels" "loadonly")
|
|
"Package options for the enumitem package.")
|
|
|
|
;;; enumitem.el ends here
|