diff options
Diffstat (limited to 'elpa/auctex-13.1.3/context.el')
| -rw-r--r-- | elpa/auctex-13.1.3/context.el | 1837 |
1 files changed, 1837 insertions, 0 deletions
diff --git a/elpa/auctex-13.1.3/context.el b/elpa/auctex-13.1.3/context.el new file mode 100644 index 0000000..e87feec --- /dev/null +++ b/elpa/auctex-13.1.3/context.el @@ -0,0 +1,1837 @@ +;;; context.el --- Support for ConTeXt documents. -*- lexical-binding: t; -*- + +;; Copyright (C) 2003-2022 Free Software Foundation, Inc. + +;; Maintainer: Berend de Boer <berend@pobox.com> +;; 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 is in progress ConTeXt support for AUCTeX. Please report +;; anomalies or things you believe should be added. + +;; AUCTeX is closely interwoven with LaTeX. We have to split up +;; things without breaking 'em. + +;; some parts are stolen from latex.el and adapted to ConTeXt. + +;; TODO +;; 1. indentation still bad. +;; 2. paragraph refilling doesn't work 100%, and is very slow. +;; 4. Remove dependency on LaTeX by moving LaTeX commands to TeX. +;; 5. Most ConTeXt macro's don't currently have lisp code to query for +;; arguments. As ConTeXt arguments are quite complex, the LaTeX way +;; of querying for arguments just doesn't cut it. +;; 6. Check auto-parsing: does it detect % interface=nl for example? +;; 7. Complete adding ConTeXt macro's. Perhaps parse cont-en.xml and +;; generate the interfaces? +;; 8. Add to menu: make TeX hash (mktexlsr), context format and metapost format. + +;; TODO Documentation +;; 1. multifile done differently with ConTeXt + +;;; Code: + +(require 'tex) +(require 'latex) ; for functions like `TeX-look-at' and `LaTeX-split-long-menu' +(require 'plain-tex) ; for `plain-TeX-common-initialization' + +;; Silence the compiler: +(defvar ConTeXt-extra-paragraph-commands) + +(defgroup ConTeXt-macro nil + "Special support for ConTeXt macros in AUCTeX." + :prefix "TeX-" + :group 'ConTeXt + :group 'TeX-macro) + +;; others + +(defvar ConTeXt-known-interfaces '("cz" "de" "en" "it" "nl" "ro" "uk")) + +(defcustom ConTeXt-default-interface "en" + "Default interface to be used when running ConTeXt." + :group 'ConTeXt + :type 'string) + +(defvar ConTeXt-current-interface "en" + "Interface to be used for inserting macros and ConTeXt run.") +(make-variable-buffer-local 'ConTeXt-current-interface) + +(defvar ConTeXt-menu-changed nil) +;; Need to update ConTeXt menu. +(make-variable-buffer-local 'ConTeXt-menu-changed) + +(defvar ConTeXt-largest-level nil + "Largest sectioning level within current document.") +(make-variable-buffer-local 'ConTeXt-largest-level) + +(defun ConTeXt-largest-level () + (TeX-update-style) + ConTeXt-largest-level) + + +;;; Syntax + +(defvar ConTeXt-optop "[" + "The ConTeXt optional argument opening character.") + +(defvar ConTeXt-optcl "]" + "The ConTeXt optional argument closing character.") + + +;; Define a ConTeXt macro + +(defvar ConTeXt-define-list () + "Calls ConTeXt-XX-define-list where XX is the current interface.") + +(defun ConTeXt-define-command (what) + "The ConTeXt macro to define WHAT." + (funcall + (intern (concat "ConTeXt-define-command-" ConTeXt-current-interface)) what)) + +(defun ConTeXt-insert-define (define) + "Insert the ConTeXt define macro DEFINE." + (insert TeX-esc (ConTeXt-define-command define)) + (newline) + (indent-according-to-mode) + (ConTeXt-arg-setup nil)) + + +;; Setup a ConTeXt macro + +(defvar ConTeXt-setup-list () + "Calls ConTeXt-XX-setup-list where XX is the current interface.") + +(defun ConTeXt-setup-command (what) + "The ConTeXt macro to setup WHAT." + (funcall + (intern (concat "ConTeXt-setup-command-" ConTeXt-current-interface)) what)) + +(defun ConTeXt-insert-setup (setup) + "Insert the ConTeXt setup macro SETUP." + (insert TeX-esc (ConTeXt-setup-command setup)) + (newline) + (indent-according-to-mode) + (ConTeXt-arg-setup nil)) + + +;; Referencing ConTeXt macro's + +(defvar ConTeXt-referencing-list () + "Calls ConTeXt-XX-referencing-list where XX is the current interface.") + +(defun ConTeXt-referencing-command (what) + "The ConTeXt macro to call WHAT is itself, no interface specific calls." + what) + +(defun ConTeXt-insert-referencing (what) + "Insert the ConTeXt referencing WHAT." + (insert TeX-esc (ConTeXt-referencing-command what)) + (newline) + (indent-according-to-mode) + (ConTeXt-arg-setup nil)) + + +;; Other ConTeXt macro's + +(defvar ConTeXt-other-macro-list () + "Calls ConTeXt-XX-other-macro-list where XX is the current interface.") + +(defun ConTeXt-other-macro-command (what) + "The ConTeXt macro to call WHAT is itself, no interface specific calls." + what) + +(defun ConTeXt-insert-other-macro (other-macro) + "Insert the ConTeXt other macro's macro OTHER-MACRO." + (insert TeX-esc (ConTeXt-other-macro-command other-macro)) + (newline) + (indent-according-to-mode) + (ConTeXt-arg-setup nil)) + + +;;; Project structure + +(defvar ConTeXt-project-structure-list () + "Calls ConTeXt-XX-project-structure where XX is the current interface.") + +(defun ConTeXt-project-structure (N) + "Insert a ConTeXt project structure. +N is in index into `ConTeXt-project-structure-list'." + (funcall (intern(concat + "ConTeXt-project-" + (nth N ConTeXt-project-structure-list) + "-insert")))) + +(defun ConTeXt-project-project-insert () + "Insert a basic template for a new ConTeXt project." + (save-excursion + (insert "% The following names are examples only\n") + (insert TeX-esc (ConTeXt-environment-start-name) (nth 0 ConTeXt-project-structure-list) " myproject") + (newline 2) + (insert TeX-esc (nth 1 ConTeXt-project-structure-list) " myenvironment") + (newline 2) + (insert TeX-esc (nth 2 ConTeXt-project-structure-list) " myproduct1") + (newline 2) + (insert TeX-esc (nth 2 ConTeXt-project-structure-list) " myproduct2") + (newline 2) + (insert TeX-esc (ConTeXt-environment-stop-name) (nth 0 ConTeXt-project-structure-list)))) + +(defun ConTeXt-project-environment-insert () + "Insert a basic template for the environment of a ConTeXt project." + (save-excursion + (insert "% The name 'myenvironment' is an example only.\n" + "% It must match the name in your project file.\n") + (insert TeX-esc (ConTeXt-environment-start-name) + (nth 1 ConTeXt-project-structure-list) " myenvironment\n\n") + (insert "% Put environment charateristics that must be defined at the " + "highest level here\n\n") + (insert TeX-esc (ConTeXt-environment-stop-name) + (nth 1 ConTeXt-project-structure-list)))) + +(defun ConTeXt-project-product-insert () + "Insert a basic template for a product of a ConTeXt project." + (save-excursion + (insert "% The following names are examples only\n") + (insert TeX-esc (ConTeXt-environment-start-name) + (nth 2 ConTeXt-project-structure-list) " myproduct1") + (newline 2) + (insert TeX-esc (nth 0 ConTeXt-project-structure-list) " myproject") + (newline 2) + (insert "% Components are optional. " + "You can also just start your document here.\n") + (insert TeX-esc (nth 3 ConTeXt-project-structure-list) " mycomponent1") + (newline 2) + (insert TeX-esc (nth 3 ConTeXt-project-structure-list) " mycomponent2") + (newline 2) + (insert TeX-esc (ConTeXt-environment-stop-name) + (nth 2 ConTeXt-project-structure-list)))) + +(defun ConTeXt-project-component-insert () + "Insert a basic template for a component of a ConTeXt project." + (save-excursion + (insert "% The following names are examples only\n") + (insert TeX-esc (ConTeXt-environment-start-name) + (nth 3 ConTeXt-project-structure-list) " mycomponent1") + (newline 2) + (insert TeX-esc (nth 0 ConTeXt-project-structure-list) " myproject\n") + (insert TeX-esc (nth 2 ConTeXt-project-structure-list) " myproduct1") + (newline 2) + (insert "% ... text here ...") + (newline 2) + (insert TeX-esc (ConTeXt-environment-stop-name) + (nth 3 ConTeXt-project-structure-list)))) + + +;;; Section blocks + +(defvar ConTeXt-section-block-list () + "Calls ConTeXt-XX-section-list where XX is the current interface.") + +(defun ConTeXt-section-block (section-block) + "Insert the ConTeXt section block SECTION-BLOCK." + (ConTeXt-environment-menu section-block)) + + +;;; Sections + +;; Declare dynamically scoped vars. +(defvar ConTeXt-title nil "Dynamically bound by `ConTeXt-section'.") +(defvar ConTeXt-name nil "Dynamically bound by `ConTeXt-section'.") +(defvar ConTeXt-level nil "Dynamically bound by `ConTeXt-section'.") +(defvar ConTeXt-done-mark nil "Dynamically bound by `ConTeXt-section'.") +(defvar ConTeXt-reference nil "Dynamically bound by `ConTeXt-section'.") + +(defun ConTeXt-section (arg) + "Insert a template for a ConTeXt section. +Determinate the type of section to be inserted, by the argument ARG. + +If ARG is nil or missing, use the current level. +If ARG is a list (selected by \\[universal-argument]), go downward one level. +If ARG is negative, go up that many levels. +If ARG is positive or zero, use absolute level: + + 0 : part + 1 : chapter + 2 : section + 3 : subsection + 4 : subsubsection + 5 : subsubsubsection + +Or: + + 0 : title + 1 : subject + 2 : subsubject + 3 : subsubsubject + +The following variables can be set to customize: + +`ConTeXt-numbered-section-hook' Hooks to run when inserting a section. +`ConTeXt-section-ref' Prefix to all section references." + + (interactive "*P") + (let* ((val (prefix-numeric-value arg)) + (ConTeXt-level (cond ((null arg) + (ConTeXt-current-section)) + ((listp arg) + (ConTeXt-down-section)) + ((< val 0) + (ConTeXt-up-section (- val))) + (t val))) + (ConTeXt-name (ConTeXt-numbered-section-name ConTeXt-level)) + (ConTeXt-title "") + (ConTeXt-reference nil) + (ConTeXt-done-mark (make-marker))) + (newline) + (run-hooks 'ConTeXt-numbered-section-hook) + (newline) + (if (marker-position ConTeXt-done-mark) + (goto-char (marker-position ConTeXt-done-mark))) + (set-marker ConTeXt-done-mark nil))) + +;; LaTeX has a max function here, which makes no sense. +;; I think you want to insert a section that is max ConTeXt-largest-level +(defun ConTeXt-current-section () + "Return the level of the section that contain point. +See also `ConTeXt-section' for description of levels." + (save-excursion + (min (ConTeXt-largest-level) + (if (re-search-backward outline-regexp nil t) + (+ 1 (- (ConTeXt-outline-level) (ConTeXt-outline-offset))) + (ConTeXt-largest-level))))) + +(defun ConTeXt-down-section () + "Return the value of a section one level under the current. +Tries to find what kind of section that have been used earlier in the +text, if this fail, it will just return one less than the current +section." + (save-excursion + (let ((current (ConTeXt-current-section)) + (next nil) + (regexp outline-regexp)) + (if (not (re-search-backward regexp nil t)) + (1+ current) + (while (not next) + (cond + ((eq (ConTeXt-current-section) current) + (if (re-search-forward regexp nil t) + (if (<= (setq next (ConTeXt-current-section)) current) ;Wow! + (setq next (1+ current))) + (setq next (1+ current)))) + ((not (re-search-backward regexp nil t)) + (setq next (1+ current))))) + next)))) + +(defun ConTeXt-up-section (arg) + "Return the value of the section ARG levels above this one." + (save-excursion + (if (zerop arg) + (ConTeXt-current-section) + (let ((current (ConTeXt-current-section))) + (while (and (>= (ConTeXt-current-section) current) + (re-search-backward outline-regexp + nil t))) + (ConTeXt-up-section (1- arg)))))) + +(defvar ConTeXt-numbered-section-list () + "ConTeXt-XX-numbered-section-list where XX is the current interface.") + +(defvar ConTeXt-unnumbered-section-list () + "ConTeXt-XX-unnumbered-section-list where XX is the current interface.") + +(defvar ConTeXt-section-list + (append ConTeXt-numbered-section-list ConTeXt-unnumbered-section-list) +) + +(defun ConTeXt-numbered-section-name (level) + "Return the name of the section corresponding to LEVEL." + (let ((entry (TeX-member level ConTeXt-numbered-section-list + (function (lambda (a b) (equal a (nth 1 b))))))) + (if entry + (nth 0 entry) + nil))) + +(defun ConTeXt-unnumbered-section-name (level) + "Return the name of the section corresponding to LEVEL." + (let ((entry (TeX-member level ConTeXt-unnumbered-section-list + (function (lambda (a b) (equal a (nth 1 b))))))) + (if entry + (nth 0 entry) + nil))) + +(defun ConTeXt-numbered-section-level (name) + "Return the level of the section NAME." + (let ((entry (TeX-member name ConTeXt-numbered-section-list + (function (lambda (a b) (equal a (nth 0 b))))))) + (if entry + (nth 1 entry) + nil))) + +(defun ConTeXt-unnumbered-section-level (name) + "Return the level of the section NAME." + (let ((entry (TeX-member name ConTeXt-unnumbered-section-list + (function (lambda (a b) (equal a (nth 0 b))))))) + (if entry + (nth 1 entry) + nil))) + + +;;; Section Hooks. + +(defcustom ConTeXt-numbered-section-hook + '(ConTeXt-numbered-section-heading + ConTeXt-section-title + ConTeXt-section-ref + ConTeXt-section-section) + "List of hooks to run when a new section is inserted. + +The following variables are set before the hooks are run + +`ConTeXt-level' - numeric section level, see the documentation of + `ConTeXt-section'. +`ConTeXt-name' - name of the sectioning command, derived from + `ConTeXt-level'. +`ConTeXt-title' - The title of the section, default to an empty + string. +`ConTeXt-done-mark' - Position of point afterwards, default nil + (meaning end). + +The following standard hooks exist - + +ConTeXt-numbered-section-heading: Query the user about the name +of the sectioning command. Modifies `ConTeXt-level' and +`ConTeXt-name'. + +ConTeXt-section-title: Query the user about the title of the +section. Modifies `ConTeXt-title'. + +ConTeXt-section-section: Insert ConTeXt section command according +to `ConTeXt-name', `ConTeXt-title', and `ConTeXt-reference'. If +`ConTeXt-title' is an empty string, `ConTeXt-done-mark' will be +placed at the point they should be inserted. + +ConTeXt-section-ref: Insert a reference for this section command. + +To get a full featured `ConTeXt-section' command, insert + + (setq ConTeXt-numbered-section-hook + \\='(ConTeXt-numbered-section-heading + ConTeXt-section-title + ConTeXt-section-section + ConTeXt-section-ref)) + +in your init file such as .emacs.d/init.el or .emacs." + :group 'ConTeXt-macro + :type 'hook + :options + '(ConTeXt-numbered-section-heading + ConTeXt-section-title + ConTeXt-section-ref + ConTeXt-section-section)) + +(defcustom ConTeXt-unnumbered-section-hook + '(ConTeXt-unnumbered-section-heading + ConTeXt-section-title + ConTeXt-section-ref + ConTeXt-section-section) + ;; FIXME: I can't see where this variable is used! + "List of hooks to run when a new section is inserted. + +The following variables are set before the hooks are run + +`ConTeXt-level' - numeric section level, see the documentation of + `ConTeXt-section'. +`ConTeXt-name' - name of the sectioning command, derived from + `ConTeXt-level'. +`ConTeXt-title' - The title of the section, default to an empty + string. +`ConTeXt-done-mark' - Position of point afterwards, default nil + (meaning end). + +The following standard hooks exist - + +ConTeXt-unnumbered-section-heading: Query the user about the name +of the sectioning command. Modifies `ConTeXt-level' and +`ConTeXt-name'. + +ConTeXt-section-title: Query the user about the title of the +section. Modifies `ConTeXt-title'. + +ConTeXt-section-section: Insert ConTeXt section command according +to `ConTeXt-name', `ConTeXt-title', and `ConTeXt-reference'. If +`ConTeXt-title' is an empty string, `ConTeXt-done-mark' will be +placed at the point they should be inserted. + +ConTeXt-section-ref: Insert a reference for this section command. + +To get a full featured `ConTeXt-section' command, insert + + (setq ConTeXt-unnumbered-section-hook + \\='(ConTeXt-unnumbered-section-heading + ConTeXt-section-title + ConTeXt-section-section + ConTeXt-section-ref)) + +in your init file such as .emacs.d/init.el or .emacs." + :group 'ConTeXt-macro + :type 'hook + :options + '(ConTeXt-unnumbered-section-heading + ConTeXt-section-title + ConTeXt-section-ref + ConTeXt-section-section)) + +;; Define before first use. +(defcustom ConTeXt-Mark-version "II" + "ConTeXt Mark version used for running ConTeXt." + :type 'string + :group 'TeX-command) +(make-variable-buffer-local 'ConTeXt-Mark-version) +(put 'ConTeXt-Mark-version 'safe-local-variable #'stringp) + +(defun ConTeXt-numbered-section-heading () + "Hook to prompt for ConTeXt section name. +Insert this hook into `ConTeXt-numbered-section-hook' to allow +the user to change the name of the sectioning command inserted +with `\\[ConTeXt-section]'." + (let ((string (completing-read + (concat "Select level (default " ConTeXt-name "): ") + ConTeXt-numbered-section-list + nil nil nil))) + ;; Update name + (if (not (zerop (length string))) + (setq ConTeXt-name string)))) + +(defun ConTeXt-unnumbered-section-heading () + "Hook to prompt for ConTeXt section name. +Insert this hook into `ConTeXt-unnumbered-section-hook' to allow +the user to change the name of the sectioning command inserted +with `\\[ConTeXt-section]'." + (let ((string (completing-read + (concat "Select level (default " ConTeXt-name "): ") + ConTeXt-unnumbered-section-list + nil nil nil))) + ;; Update name + (if (not (zerop (length string))) + (setq ConTeXt-name string)))) + +(defun ConTeXt-section-title () + "Hook to prompt for ConTeXt section title. +Insert this hook into `ConTeXt-(un)numbered-section-hook' to +allow the user to change the title of the section inserted with +`\\[ConTeXt-section]." + (setq ConTeXt-title (TeX-read-string "What title: "))) + +(defun ConTeXt-section-section () + "Hook to insert ConTeXt section command into the file. +Insert this hook into `ConTeXt-numbered-section-hook' after those hooks +which sets the `ConTeXt-name', `ConTeXt-title', and +`ConTeXt-reference' variables, but before those hooks which +assumes the section already is inserted." + (insert TeX-esc ConTeXt-name) + (cond ((null ConTeXt-reference)) + ((zerop (length ConTeXt-reference)) + (insert ConTeXt-optop) + (set-marker ConTeXt-done-mark (point)) + (insert ConTeXt-optcl)) + (t + (insert ConTeXt-optop ConTeXt-reference ConTeXt-optcl))) + (insert TeX-grop) + (if (zerop (length ConTeXt-title)) + (set-marker ConTeXt-done-mark (point))) + (insert ConTeXt-title TeX-grcl) + (newline) + ;; If RefTeX is available, tell it that we've just made a new section + (and (fboundp 'reftex-notice-new-section) + (funcall (symbol-function 'reftex-notice-new-section)))) + +(defun ConTeXt-section-ref () + "Hook to insert a reference after the sectioning command. +Insert this hook into `ConTeXt-numbered-section-hook' to prompt +for a label to be inserted after the sectioning command." + (setq ConTeXt-reference + (completing-read + (TeX-argument-prompt t nil + "Comma separated list of references") + (LaTeX-label-list) nil nil)) + ;; No reference or empty string entered? + (if (string-equal "" ConTeXt-reference) + (setq ConTeXt-reference nil))) + + +;; Various +(defun TeX-ConTeXt-sentinel (process name) + "Cleanup TeX output buffer after running ConTeXt." + (cond + ;; Mark IV + ((with-current-buffer TeX-command-buffer + (string= ConTeXt-Mark-version "IV")) + (cond ((TeX-TeX-sentinel-check process name)) + ((re-search-forward "fatal error: " nil t) + (message (concat name ": problems after " + (TeX-current-pages))) + (setq TeX-command-next TeX-command-default)) + (t + (message (concat name ": successfully formatted " + (TeX-current-pages))) + (setq TeX-command-next TeX-command-Show)))) + ;; Mark II + (t + (cond ((TeX-TeX-sentinel-check process name)) + ((save-excursion + ;; in a full ConTeXt run there will multiple texutil + ;; outputs. Just looking for "another run needed" would + ;; find the first occurence + (goto-char (point-max)) + (re-search-backward "TeXUtil " nil t) + (re-search-forward "another run needed" nil t)) + (message (concat "You should run ConTeXt again " + "to get references right, " + (TeX-current-pages))) + (setq TeX-command-next TeX-command-default)) + ((re-search-forward "removed files :" nil t) + (message "sucessfully cleaned up")) + ((re-search-forward "^ ?TeX\\(Exec\\|Util\\)" nil t) ;; strange regexp --pg + (message (concat name ": successfully formatted " + (TeX-current-pages))) + (setq TeX-command-next TeX-command-Show)) + (t + (message (concat name ": problems after " + (TeX-current-pages))) + (setq TeX-command-next TeX-command-default))))) + (unless TeX-error-list + (run-hook-with-args 'TeX-after-compilation-finished-functions + (with-current-buffer TeX-command-buffer + (expand-file-name + (TeX-active-master (TeX-output-extension))))))) + + +;;; Environments + +(defgroup ConTeXt-environment nil + "Environments in ConTeXt." + :group 'ConTeXt-macro) + +;; TODO: interface awareness +(defcustom ConTeXt-default-environment "itemize" + "The default environment when creating new ones with `ConTeXt-environment'." + :group 'ConTeXt-environment + :type 'string) +(make-variable-buffer-local 'ConTeXt-default-environment) + +(TeX-auto-add-type "environment" "ConTeXt") + +(advice-add 'ConTeXt-add-environments :after #'ConTeXt--invalidate-menu) +(defun ConTeXt--invalidate-menu (&rest _) + "Mark the menu as being in need of a refresh." + (setq ConTeXt-menu-changed t)) + +;; (defvar ConTeXt-environment-list () +;; "ConTeXt-environment-list-XX where XX is the current interface.") + +(defvar ConTeXt-environment-history nil) + +(defun ConTeXt-environment-start-name () + "Return the \\start translated to the language in current interface." + ;; it is "inizia", others are "start" + (cond ((equal ConTeXt-current-interface "it") + "inizia") + ((member ConTeXt-current-interface ConTeXt-known-interfaces) + "start") + (t + ;; this should not happen + (error "Unknown interface: %s" ConTeXt-current-interface)))) + +(defun ConTeXt-environment-stop-name () + "Return the \\stop translated to the language in current interface." + ;; it is "termina", others are "stop" + (cond ((equal ConTeXt-current-interface "it") + "termina") + ((member ConTeXt-current-interface ConTeXt-known-interfaces) + "stop") + (t + ;; this should not happen + (error "Unknown interface: %s" ConTeXt-current-interface)))) + +(defun ConTeXt-environment (arg) + "Make ConTeXt environment (\\start...-\\stop... pair). +With optional ARG, modify current environment." + (interactive "*P") + (let* ((default (cond + ((TeX-near-bobp) "text") + (t ConTeXt-default-environment))) + (environment + (completing-read (concat "Environment type (default " default "): ") + ConTeXt-environment-list nil nil nil + 'ConTeXt-environment-history default))) + ;; Use `environment' as default for the next time only if it is different + ;; from the current default. + (unless (equal environment default) + (setq ConTeXt-default-environment environment)) + + (let ((entry (assoc environment ConTeXt-environment-list))) + (if (null entry) + (ConTeXt-add-environments (list environment))) + + (if arg + (ConTeXt-modify-environment environment) + (ConTeXt-environment-menu environment))))) + +(defun ConTeXt-modify-environment (environment) + "Modify current environment." + (save-excursion + (ConTeXt-find-matching-stop) + (re-search-backward (concat (regexp-quote TeX-esc) + (ConTeXt-environment-stop-name) + " *\\([a-zA-Z]*\\)") + (save-excursion (beginning-of-line 1) (point))) + (replace-match + (concat TeX-esc (ConTeXt-environment-stop-name) environment) t t) + (beginning-of-line 1) + (ConTeXt-find-matching-start) + (re-search-forward (concat (regexp-quote TeX-esc) + (ConTeXt-environment-start-name) + " *\\([a-zA-Z]*\\)") + (save-excursion (end-of-line 1) (point))) + (replace-match + (concat TeX-esc (ConTeXt-environment-start-name) environment) t t))) + + +(defun ConTeXt-environment-menu (environment) + "Insert ENVIRONMENT around point or region." + (let ((entry (assoc environment ConTeXt-environment-list))) + (cond ((not (and entry (nth 1 entry))) + (ConTeXt-insert-environment environment)) + ((numberp (nth 1 entry)) + (let ((count (nth 1 entry)) + (args "")) + (while (> count 0) + (setq args (concat args TeX-grop TeX-grcl)) + (setq count (- count 1))) + (ConTeXt-insert-environment environment args))) + ((stringp (nth 1 entry)) + (let ((prompts (cdr entry)) + (args "")) + (while prompts + (setq args (concat args + TeX-grop + (read-from-minibuffer + (concat (car prompts) ": ")) + TeX-grcl)) + (setq prompts (cdr prompts))) + (ConTeXt-insert-environment environment args))) + (t + (apply (nth 1 entry) environment (nthcdr 2 entry)))))) + +(defun ConTeXt-close-environment () + "Insert \\stop... to match the current environment." + (interactive "*") + (beginning-of-line) + (let ((empty-line (looking-at "[ \t]*$"))) + (end-of-line) + (if (not empty-line) + (newline))) + (insert TeX-esc (ConTeXt-environment-stop-name) + (ConTeXt-current-environment)) + ;; indent broken, so don't do it. + ;;(indent-according-to-mode) + (end-of-line) + (newline)) + +(defun ConTeXt-insert-environment (environment &optional extra) + "Insert ENVIRONMENT, with optional argument EXTRA." + (if (and (TeX-active-mark) + (not (eq (mark) (point)))) + (save-excursion + (if (< (mark) (point)) + (exchange-point-and-mark)) + (insert TeX-esc (ConTeXt-environment-start-name) environment) + (newline) + (forward-line -1) + (indent-according-to-mode) + (if extra (insert extra)) + (goto-char (mark)) + (or (TeX-looking-at-backward "^[ \t]*") + (newline)) + (insert TeX-esc (ConTeXt-environment-stop-name) environment) + (newline) + (forward-line -1) + (indent-according-to-mode) + ;;(goto-char (point)) + ) + (or (TeX-looking-at-backward "^[ \t]*") + (newline)) + (insert TeX-esc (ConTeXt-environment-start-name) environment) + (indent-according-to-mode) + (if extra (insert extra)) + (end-of-line) + (newline-and-indent) + (newline) + (insert TeX-esc (ConTeXt-environment-stop-name) environment) + (or (looking-at "[ \t]*$") + (save-excursion (newline-and-indent))) + (indent-according-to-mode) + (end-of-line 0))) + + +;; with the following we can call a function on an environment. Say +;; you have metapost stuff within your TeX file, go to the environment +;; and run ConTeXt-work-on-environment (suggested Key: C-c !). AUCTeX +;; sees that you are inside e.g. \startMPpage....\stopMPpage and +;; looks in ConTeXt-environment-helper for a function to be called. + +;; % so pressing C-c ! inside the following ... +;;\startuseMPgraphic{Logo}{Scale} +;; % Top rectangle +;; filldraw (0,0)--(2cm,0)--(2cm,1cm)--(0,1cm)--cycle withcolor blue ; +;; % Bottom black rectangle +;; drawfill (0,0)--(2cm,0)--(2cm,-1cm)--(0,-1cm)--cycle withcolor black; +;; % White Text +;; draw btex \bf AB etex withcolor white ; +;; % resize to size +;; currentpicture := currentpicture scaled \MPvar{Scale} ; +;; \stopuseMPgraphic + +;; % ...should give you a "new buffer" (currently narrowed to region +;; % and switched to metapost-mode and recursive-edit) + +;; % Top rectangle +;; filldraw (0,0)--(2cm,0)--(2cm,1cm)--(0,1cm)--cycle withcolor blue ; +;; % Bottom black rectangle +;; drawfill (0,0)--(2cm,0)--(2cm,-1cm)--(0,-1cm)--cycle withcolor black; +;; % White Text +;; draw btex \bf AB etex withcolor white ; +;; % resize to size +;; currentpicture := currentpicture scaled \MPvar{Scale} ; + + +(defvar ConTeXt-environment-helper + '(("useMPgraphic" . ConTeXt-mp-region) + ("MPpage" . ConTeXt-mp-region)) + "Alist that holds functions to call for working on regions. +An entry looks like: (\"environment\" . function)") + +(defun ConTeXt-mp-region () + "Edit region in `metapost-mode'." + (ConTeXt-mark-environment t) + (narrow-to-region (mark) (point)) + (metapost-mode) + (message "Type `M-x exit-recursive-edit' to get back") + (recursive-edit) + (context-mode) + (widen)) + +;; find smarter name. Suggestions welcome +(defun ConTeXt-work-on-environment () + "Takes current environment and does something on it (todo: documentation)." + (interactive) + (let ((fun (cdr (assoc (ConTeXt-current-environment) + ConTeXt-environment-helper)))) + (when (functionp fun) + (funcall fun)))) + +(defun ConTeXt-current-environment () + "Return the name of the current environment." + ;; don't make this interactive. + (let ((beg)) + (save-excursion + (ConTeXt-last-unended-start) + (setq beg (+ (point) (length (ConTeXt-environment-start-name)) 1)) + (goto-char (match-end 0)) + (skip-chars-forward "a-zA-Z") + (buffer-substring beg (point))))) + +(defun ConTeXt-last-unended-start () + "Leave point at the beginning of the last unstopped `\\start...'. +Look back from the current cursor." + (while (and (re-search-backward "\\\\start[a-zA-Z]*\\|\\\\stop[a-zA-Z]*") + (looking-at "\\\\stop[a-zA-Z]*")) + (ConTeXt-last-unended-start))) + +(defun ConTeXt-mark-environment (&optional inner) + "Set mark to end of current environment (\\start...-\\stop...) and +point to the matching begin. +If optional INNER is not nil, include \\start... and \\stop, otherwise only +the contents." + (interactive) + (let ((cur (point))) + (ConTeXt-find-matching-stop inner) + (push-mark (point)) + (goto-char cur) + (ConTeXt-find-matching-start inner) + (TeX-activate-region))) + +(defun ConTeXt-find-matching-stop (&optional inner) + "Find end of current \\start...\\stop-Pair. +If INNER is non-nil, go to the point just past before +\\stop... macro. Otherwise goto the point just past \\stop..." + (interactive) + (let ((regexp (concat (regexp-quote TeX-esc) + "\\(" + (ConTeXt-environment-start-name) + "\\|" + (ConTeXt-environment-stop-name) + "\\)" + )) + (level 1)) + ;;jump over the \start... when at the beginning of it. + (when (looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-start-name))) + (re-search-forward regexp nil t)) + (while (and (> level 0) + (re-search-forward regexp nil t) + (goto-char (1- (match-beginning 1))) + (cond ((looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-start-name))) + (re-search-forward regexp nil t) + (setq level (1+ level))) + ((looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-stop-name))) + (re-search-forward regexp nil t) + (setq level (1- level)))))) + ;; now we have to look if we want to start behind the \start... macro + (if inner + (beginning-of-line) + (skip-chars-forward "a-zA-Z")))) + +(defun ConTeXt-find-matching-start (&optional inner) + "Find beginning of current \\start...\\stop-Pair. +If INNER is non-nil, go to the point just past the \\start... macro." + (interactive) + (let ((regexp (concat (regexp-quote TeX-esc) + "\\(" + (ConTeXt-environment-start-name) + "\\|" + (ConTeXt-environment-stop-name) + "\\)" + )) + (level 1) + (pos)) + (while (and (> level 0) + (re-search-backward regexp nil t) + (cond ((looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-stop-name))) + (setq level (1+ level))) + ((looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-start-name))) + (setq level (1- level)))))) + ;; now we have to look if we want to start behind the \start... macro + (when inner + ;; \startfoo can have 0 or more {} and [] pairs. I assume that + ;; skipping all those parens will be smart enough. It fails when + ;; the first part in the \start-\stop-environment is { or [, like + ;; in \startquotation {\em important} \stopquotation. There is + ;; yet another pitfall: \startsetups SomeSetup foo bar + ;; \stopsetups will use SomeSetup as the argument and the + ;; environment + (skip-chars-forward "\\\\a-zA-Z") + (save-excursion + (while (progn + (skip-chars-forward "\t\n ") + (forward-comment 1) + (skip-chars-forward "\t\n ") + (looking-at "\\s\(")) + (forward-list 1) + (setq pos (point)))) + (when pos + (goto-char pos)) + (unless (bolp) + (forward-line))))) + +;;; items + +(defun ConTeXt-insert-item () + "Insert a new item." + (interactive "*") + (or (TeX-looking-at-backward "^[ \t]*") + (newline)) + (TeX-insert-macro "item") + (indent-according-to-mode)) + + +;;; Macro Argument Hooks + +(defun ConTeXt-optional-argument-insert (arg &optional _prefix) + "Insert ARG surrounded by square brackets." + (insert ConTeXt-optop) + (insert arg) + (insert ConTeXt-optcl)) + +(defun ConTeXt-required-argument-insert (arg &optional _prefix) + "Insert ARG surrounded by curly braces." + (insert TeX-grop) + (insert arg) + (insert TeX-grcl)) + +(defun ConTeXt-argument-insert (arg optional &optional prefix) + "Insert ARG surrounded by curly braces. + +If OPTIONAL, only insert it if not empty, and then use square brackets." + (if optional + (if + (not (string-equal arg "")) + (ConTeXt-optional-argument-insert arg prefix)) + (ConTeXt-required-argument-insert arg prefix))) + +(defun ConTeXt-arg-ref (optional &optional prompt definition) + "Prompt for a reference completing with known references." + (let ((ref (completing-read (TeX-argument-prompt optional prompt "ref") + (LaTeX-label-list)))) + (if (and definition (not (string-equal "" ref))) + (LaTeX-add-labels ref)) + (ConTeXt-argument-insert ref optional))) + +(defun ConTeXt-arg-define-ref (&optional prompt) + "Prompt for an optional reference completing with known references." + (ConTeXt-arg-ref t prompt t)) + +(defun ConTeXt-arg-setup (optional &optional prompt) + "Prompt for setup arguments." + (let ((setup (read-from-minibuffer + (TeX-argument-prompt optional prompt "Setup")))) + (ConTeXt-argument-insert setup t))) + + +;; paragraph (re)-formatting + +(defvar ConTeXt-item-list () + "List of macro's considered items.") + +(defun ConTeXt-paragraph-commands-regexp () + "Return a regexp matching macros that should have their own line." + (concat + (regexp-quote TeX-esc) "\\(" + "[][]\\|" ; display math delimitors (is this applicable to ConTeXt??) + (ConTeXt-environment-start-name) "\\|" + (ConTeXt-environment-stop-name) "\\|" + (mapconcat #'car ConTeXt-numbered-section-list "\\b\\|") "\\b\\|" + (mapconcat #'car ConTeXt-unnumbered-section-list "\\b\\|") "\\b\\|" + (mapconcat #'identity ConTeXt-extra-paragraph-commands "\\b\\|") + "\\b\\|" + (mapconcat #'identity ConTeXt-item-list "\\b\\|") "\\b\\)")) + + +;; Outline support + +(defun ConTeXt-environment-full-start-name (environment) + "Return the ConTeXt macro name that starts ENVIRONMENT. +It is interface aware" + (concat (ConTeXt-environment-start-name) environment)) + +(defun ConTeXt-outline-regexp (&optional anywhere) + "Return regexp for ConTeXt section blocks and sections. + +If optional argument ANYWHERE is not nil, do not require that the +header is at the start of a line." + (concat + (if anywhere "" "^") + "[ \t]*" + (regexp-quote TeX-esc) + "\\(" + (mapconcat #'ConTeXt-environment-full-start-name ConTeXt-section-block-list "\\|") "\\|" + (mapconcat #'car ConTeXt-numbered-section-list "\\|") "\\|" + (mapconcat #'car ConTeXt-unnumbered-section-list "\\|") + "\\)\\b" + (if TeX-outline-extra + "\\|" + "") + (mapconcat #'car TeX-outline-extra "\\|") + "\\|" (ConTeXt-header-end) "\\b" + "\\|" (ConTeXt-trailer-start) "\\b")) + +(defvar ConTeXt-text "Name of ConTeXt macro that begins the text body.") + +(defun ConTeXt-header-end () + "Default end of header marker for ConTeXt documents." + (concat + (regexp-quote TeX-esc) + (ConTeXt-environment-start-name) + ConTeXt-text)) + +(defun ConTeXt-trailer-start () + "Default start of trailer marker for ConTeXt documents." + (concat + (regexp-quote TeX-esc) + (ConTeXt-environment-stop-name) + ConTeXt-text)) + +(defun ConTeXt-outline-offset () + "Offset to add to `ConTeXt-section-list' levels to get outline level." + (- 4 (ConTeXt-largest-level))) + +(defun ConTeXt-start-environment-regexp (list) + "Regular expression that matches a start of all environments mentioned in LIST." + (concat + "start\\(" + (mapconcat #'identity list "\\|") + "\\)\\b")) + +;; The top headings are \starttext, \startfrontmatter, \startbodymatter etc. +;; \part, \chapter etc. are children of that. +(defun ConTeXt-outline-level () + "Find the level of current outline heading in an ConTeXt document." + (cond ((looking-at (concat (ConTeXt-header-end) "\\b")) 1) + ((looking-at (concat (ConTeXt-trailer-start) "\\b")) 1) + ((TeX-look-at TeX-outline-extra) + (max 1 (+ (TeX-look-at TeX-outline-extra) + (ConTeXt-outline-offset)))) + (t + (save-excursion + (skip-chars-forward " \t") + (forward-char 1) + (cond ((looking-at (ConTeXt-start-environment-regexp + ConTeXt-section-block-list)) 1) + ((TeX-look-at ConTeXt-section-list) + (max 1 (+ (TeX-look-at ConTeXt-section-list) + (ConTeXt-outline-offset)))) + (t + (error "Unrecognized header"))))))) + + +;;; Fonts + +(defcustom ConTeXt-font-list '((?\C-b "{\\bf " "}") + (?\C-c "{\\sc " "}") + (?\C-e "{\\em " "}") + (?\C-i "{\\it " "}") + (?\C-r "{\\rm " "}") + (?\C-s "{\\sl " "}") + (?\C-t "{\\tt " "}") + (?\C-d "" "" t)) + "List of fonts used by `TeX-font'. + +Each entry is a list. +The first element is the key to activate the font. +The second element is the string to insert before point, and the third +element is the string to insert after point. +If the fourth and fifth element are strings, they specify the prefix and +suffix to be used in math mode. +An optional fourth (or sixth) element means always replace if t." + :group 'TeX-macro + :type '(repeat + (group + :value (?\C-a "" "") + (character :tag "Key") + (string :tag "Prefix") + (string :tag "Suffix") + (option (group + :inline t + (string :tag "Math Prefix") + (string :tag "Math Suffix"))) + (option (sexp :format "Replace\n" :value t))))) + + +;; Imenu support + +(defun ConTeXt-outline-name () + "Guess a name for the current header line." + (save-excursion + (if (re-search-forward "{\\([^\}]*\\)}" (point-at-eol) t) + (match-string 1) + (buffer-substring-no-properties (point) (point-at-eol))))) + +;; This imenu also includes commented out chapters. Perhaps a feature +;; for LaTeX, not sure we want or need that for ConTeXt. + +(defun ConTeXt-imenu-create-index-function () + "Imenu support function for ConTeXt." + (TeX-update-style) + (let (entries + (regexp (ConTeXt-outline-regexp))) + (goto-char (point-max)) + (while (re-search-backward regexp nil t) + (let* ((name (ConTeXt-outline-name)) + (level (make-string (1- (ConTeXt-outline-level)) ?\ )) + (label (concat level level name)) + (mark (make-marker))) + (set-marker mark (point)) + (set-text-properties 0 (length label) nil label) + (setq entries (cons (cons label mark) entries)))) + entries)) + + +;; Indentation, copied from Berend's context mode. +;; TODO: doesn't work great. + +(defvar ConTeXt-indent-allhanging t) +(defvar ConTeXt-indent-arg 2) +(defvar ConTeXt-indent-basic 2) +(defvar ConTeXt-indent-item ConTeXt-indent-basic) +(defvar ConTeXt-indent-item-re "\\\\\\(item\\|sym\\)\\>") + +(defvar ConTeXt-indent-syntax-table (make-syntax-table TeX-mode-syntax-table) + "Syntax table used while computing indentation.") + +(progn + (modify-syntax-entry ?$ "." ConTeXt-indent-syntax-table) + (modify-syntax-entry ?\( "." ConTeXt-indent-syntax-table) + (modify-syntax-entry ?\) "." ConTeXt-indent-syntax-table)) + +(defun ConTeXt-indent-line (&optional _arg) + (with-syntax-table ConTeXt-indent-syntax-table + ;; TODO: Rather than ignore $, we should try to be more clever about it. + (let ((indent + (save-excursion + (beginning-of-line) + (ConTeXt-find-indent)))) + (if (< indent 0) (setq indent 0)) + (if (<= (current-column) (current-indentation)) + (indent-line-to indent) + (save-excursion (indent-line-to indent)))))) + +(defun ConTeXt-find-indent (&optional virtual) + "Find the proper indentation of text after point. +VIRTUAL if non-nil indicates that we're only trying to find the +indentation in order to determine the indentation of something +else. There might be text before point." + (save-excursion + (skip-chars-forward " \t") + (or + ;; Trust the current indentation, if such info is applicable. + (and virtual (>= (current-indentation) (current-column)) + (current-indentation)) + ;; Put leading close-paren where the matching open brace would be. + (condition-case nil + (and (eq (char-syntax (char-after)) ?\)) + (save-excursion + (skip-syntax-forward " )") + (backward-sexp 1) + (ConTeXt-find-indent 'virtual))) + (error nil)) + ;; Default (maybe an argument) + (let ((pos (point)) + (char (char-after)) + (indent 0) + up-list-pos) + ;; Look for macros to be outdented + (cond ((looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-stop-name))) + (setq indent (- indent ConTeXt-indent-basic))) + ((looking-at ConTeXt-indent-item-re) + (setq indent (- indent ConTeXt-indent-item)))) + ;; Find the previous point which determines our current indentation. + (condition-case err + (progn + (backward-sexp 1) + (while (or (> (current-column) (current-indentation)) + ;; Continue going back if we are + ;; at a hanging optional group. + (looking-at (regexp-quote ConTeXt-optop))) + (backward-sexp 1))) + (scan-error + (setq up-list-pos (nth 2 err)))) + (cond + ((= (point-min) pos) 0) ; We're really just indenting the first line. + ((integerp up-list-pos) + ;; Have to indent relative to the open-paren. + (goto-char up-list-pos) + (if (and (not ConTeXt-indent-allhanging) + (> pos (progn (down-list 1) + (forward-comment (point-max)) + (point)))) + ;; Align with the first element after the open-paren. + (current-column) + ;; We're the first element after a hanging brace. + (goto-char up-list-pos) + (+ indent ConTeXt-indent-basic (ConTeXt-find-indent 'virtual)))) + ;; We're now at the "beginning" of a line. + ((not (and (not virtual) (eq (char-after) ?\\))) + ;; Nothing particular here: just keep the same indentation. + (+ indent (current-column))) + ;; We're now looking at an item. + ((looking-at ConTeXt-indent-item-re) + ;; Indenting relative to an item, have to re-add the outdenting. + (+ indent (current-column) ConTeXt-indent-item)) + ;; We're looking at an environment starter. + ((and (looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-start-name))) + (not (looking-at (concat (regexp-quote TeX-esc) + (ConTeXt-environment-start-name) + ConTeXt-text)))) ; other environments? + (+ indent (current-column) ConTeXt-indent-basic)) + (t + (let ((col (current-column))) + (if (not (and char (eq (char-syntax char) ?\())) + ;; If the first char was not an open-paren, there's + ;; a risk that this is really not an argument to the + ;; macro at all. + (+ indent col) + (forward-sexp 1) + (if (< (line-end-position) + (save-excursion (forward-comment (point-max)) + (point))) + ;; we're indenting the first argument. + (min (current-column) (+ ConTeXt-indent-arg col)) + (skip-syntax-forward " ") + (current-column)))))))))) + + +;; XML inside ConTeXt support + +(defun ConTeXt-last-unended-start-xml () + "Leave point at the beginning of the last `tag' that is unstopped." + (while (and (re-search-backward "<[_A-Za-z][-:._A-Za-z0-9]*\\([ \t\r\n]\\|[_A-Za-z][-:._A-Za-z0-9]*\=\"[^\"]*\"\\)*>\\|</[_A-Za-z][-:_A-Za-z0-9]*>") + (looking-at "</[_A-Za-z][-:._A-Za-z0-9]*>")) + (ConTeXt-last-unended-start-xml))) + +(defun ConTeXt-close-xml-tag () + "Create an </...> to match the last unclosed <...>. Not fool-proof." + (interactive "*") + (let ((new-line-needed (bolp)) text indentation) + (save-excursion + (condition-case nil + (ConTeXt-last-unended-start-xml) + (error (error "Couldn't find unended XML tag"))) + (setq indentation (current-column)) + (re-search-forward "<\\([_A-Za-z][-:._A-Za-z0-9]*\\)") + (setq text (buffer-substring (match-beginning 1) (match-end 1)))) + (indent-to indentation) + (insert "</" text ">") + (if new-line-needed (insert ?\n)))) + + +;; Key bindings + +(defvar ConTeXt-mode-map + (let ((map (make-sparse-keymap))) + (set-keymap-parent map TeX-mode-map) + + ;; We now set `beginning-of-defun-function' and + ;; `end-of-defun-function' instead. + ;; (define-key map "\e\C-a" #'ConTeXt-find-matching-start) + ;; (define-key map "\e\C-e" #'ConTeXt-find-matching-stop) + ;; likely to change in the future + (define-key map "\C-c!" #'ConTeXt-work-on-environment) + (define-key map "\C-c\C-e" #'ConTeXt-environment) + (define-key map "\C-c\n" #'ConTeXt-insert-item) + (or (key-binding "\e\r") + (define-key map "\e\r" #'ConTeXt-insert-item)) ;*** Alias + (define-key map "\C-c]" #'ConTeXt-close-environment) + (define-key map "\C-c\C-s" #'ConTeXt-section) + ;; XML in ConTeXt support + (define-key map "\C-c/" #'ConTeXt-close-xml-tag) + map) + "Keymap used in `ConTeXt-mode'.") + + +;;; Menu building + +;; functions to create menu entries + +;; ConTeXt \start... \stop... pairs +;; (Choose a different name than the one in LaTeX mode. Otherwise the +;; contents of the "Insert Environment" and "Change Environment" menus +;; will not be updated correctly upon loading and switching between +;; LaTeX and ConTeXt files. AFAICS this is due to a bug in +;; easymenu.el not returning the correct keymap when +;; `easy-menu-change' (and therefore `easy-menu-get-map') is called. +;; It just sees an entry with a matching name and returns this first +;; match.) +(defvar ConTeXt-environment-menu-name "Insert Environment (C-c C-e)") + +(defun ConTeXt-environment-menu-entry (entry) + "Create an ENTRY for the environment menu." + (vector (car entry) (list 'ConTeXt-environment-menu (car entry)) t)) + +(defvar ConTeXt-environment-modify-menu-name "Change Environment (C-u C-c C-e)") + +(defun ConTeXt-environment-modify-menu-entry (entry) + "Create an ENTRY for the change environment menu." + (vector (car entry) (list 'ConTeXt-modify-environment (car entry)) t)) + +;; ConTeXt define macros +(defvar ConTeXt-define-menu-name "Define") + +(defun ConTeXt-define-menu-entry (entry) + "Create an ENTRY for the define menu." + (vector entry (list 'ConTeXt-define-menu entry))) + +(defun ConTeXt-define-menu (define) + "Insert DEFINE from menu." + (ConTeXt-insert-define define)) + +;; ConTeXt setup macros +(defvar ConTeXt-setup-menu-name "Setup") + +(defun ConTeXt-setup-menu-entry (entry) + "Create an ENTRY for the setup menu." + (vector entry (list 'ConTeXt-setup-menu entry))) + +(defun ConTeXt-setup-menu (setup) + "Insert SETUP from menu." + (ConTeXt-insert-setup setup)) + +;; ConTeXt referencing macros +(defvar ConTeXt-referencing-menu-name "Referencing") + +(defun ConTeXt-referencing-menu-entry (entry) + "Create an ENTRY for the referencing menu." + (vector entry (list 'ConTeXt-referencing-menu entry))) + +(defun ConTeXt-referencing-menu (referencing) + "Insert REFERENCING from menu." + (ConTeXt-insert-referencing referencing)) + +;; ConTeXt other macros +(defvar ConTeXt-other-macro-menu-name "Other macro") + +(defun ConTeXt-other-macro-menu-entry (entry) + "Create an ENTRY for the other macro menu." + (vector entry (list 'ConTeXt-other-macro-menu entry))) + +(defun ConTeXt-other-macro-menu (other-macro) + "Insert OTHER-MACRO from menu." + (ConTeXt-insert-other-macro other-macro)) + + +;; meta-structure project structure menu entries + +(defvar ConTeXt-project-structure-menu-name "Project Structure") + +(defun ConTeXt-project-structure-menu (project-structure) + "Insert PROJECT-STRUCTURE from menu." + (ConTeXt-project-structure + (let ((l ConTeXt-project-structure-list)) + (- (length l) (length (member project-structure l)))))) + +(defun ConTeXt-project-structure-menu-entry (entry) + "Create an ENTRY for the project structure menu." + (vector entry (list 'ConTeXt-project-structure-menu entry))) + + +;; meta-structure section blocks menu entries + +(defvar ConTeXt-section-block-menu-name "Section Block") + +(defun ConTeXt-section-block-menu (section-block) + "Insert SECTION-BLOCK from menu." + (ConTeXt-section-block section-block)) + +(defun ConTeXt-section-block-menu-entry (entry) + "Create an ENTRY for the section block menu." + (vector entry (list 'ConTeXt-section-block-menu entry))) + + +;; section menu entries + +(defvar ConTeXt-numbered-section-menu-name "Numbered section (C-c C-s)") +(defvar ConTeXt-unnumbered-section-menu-name "Unnumbered section") + +(defun ConTeXt-section-enable-symbol (level) + "Symbol used to enable section LEVEL in the menu bar." + (intern (concat "ConTeXt-section-" (int-to-string level) "-enable"))) + +(defun ConTeXt-section-enable (entry) + "Enable or disable section ENTRY from `ConTeXt-section-list'." + (let ((level (nth 1 entry))) + (set (ConTeXt-section-enable-symbol level) + (>= level ConTeXt-largest-level)))) + +(defun ConTeXt-numbered-section-menu (level) + "Insert numbered section from menu." + (let ((ConTeXt-numbered-section-hook + (delq 'ConTeXt-numbered-section-heading + (copy-sequence ConTeXt-numbered-section-hook)))) + (ConTeXt-section level))) + +(defun ConTeXt-unnumbered-section-menu (level) + "Insert unnumbered section from menu." + (let ((ConTeXt-unnumbered-section-hook + (delq 'ConTeXt-unnumbered-section-heading + (copy-sequence ConTeXt-unnumbered-section-hook)))) + (ConTeXt-section level))) + +(defun ConTeXt-numbered-section-menu-entry (entry) + "Create an ENTRY for the numbered section menu." + (let ((enable (ConTeXt-section-enable-symbol (nth 1 entry)))) + (set enable t) + (vector (car entry) (list 'ConTeXt-numbered-section-menu (nth 1 entry)) enable))) + +(defun ConTeXt-unnumbered-section-menu-entry (entry) + "Create an ENTRY for the unnumbered section menu." + (let ((enable (ConTeXt-section-enable-symbol (nth 1 entry)))) + (set enable t) + (vector (car entry) (list 'ConTeXt-unnumbered-section-menu (nth 1 entry)) enable))) + + +;; etexshow support + +(defun ConTeXt-etexshow () + "Call etexshow, if available, to show the definition of a ConText macro." + (interactive) + (if (fboundp 'etexshow) + (let () + (require 'etexshow) + (funcall (symbol-function 'etexshow-cmd))) + (error "etexshow is not installed. Get it from http://levana.de/emacs/"))) + +;; menu itself + +(easy-menu-define ConTeXt-mode-command-menu + ConTeXt-mode-map + "Command menu used in ConTeXt mode." + (TeX-mode-specific-command-menu 'context-mode)) + +;; it seems the menu is evaluated at compile/load-time +;; we don't have ConTeXt-current-interface at that time +;; so make sure to do updates based on that variable in +;; ConTeXt-menu-update +(easy-menu-define ConTeXt-mode-menu + ConTeXt-mode-map + "Menu used in ConTeXt mode." + `("ConTeXt" + (,ConTeXt-project-structure-menu-name) + (,ConTeXt-section-block-menu-name) + (,ConTeXt-numbered-section-menu-name) + (,ConTeXt-unnumbered-section-menu-name) + ["Add Table of Contents to Emacs Menu" (imenu-add-to-menubar "TOC") t] + "-" + ["Macro ..." TeX-insert-macro + :help "Insert a macro and possibly arguments"] + ["Complete" TeX-complete-symbol + :help "Complete the current macro or environment name"] + ["Show ConTeXt Macro Definition" ConTeXt-etexshow] + "-" + (,ConTeXt-environment-menu-name) + (,ConTeXt-environment-modify-menu-name) + ["Item" ConTeXt-insert-item + :help "Insert a new \\item into current environment"] + (,ConTeXt-define-menu-name) + (,ConTeXt-setup-menu-name) + (,ConTeXt-other-macro-menu-name) + "-" + ("Insert Font" + ["Emphasize" (TeX-font nil ?\C-e) :keys "C-c C-f C-e"] + ["Bold" (TeX-font nil ?\C-b) :keys "C-c C-f C-b"] + ["Typewriter" (TeX-font nil ?\C-t) :keys "C-c C-f C-t"] + ["Small Caps" (TeX-font nil ?\C-c) :keys "C-c C-f C-c"] + ["Sans Serif" (TeX-font nil ?\C-f) :keys "C-c C-f C-f"] + ["Italic" (TeX-font nil ?\C-i) :keys "C-c C-f C-i"] + ["Slanted" (TeX-font nil ?\C-s) :keys "C-c C-f C-s"] + ["Roman" (TeX-font nil ?\C-r) :keys "C-c C-f C-r"] + ["Calligraphic" (TeX-font nil ?\C-a) :keys "C-c C-f C-a"]) + ("Replace Font" + ["Emphasize" (TeX-font t ?\C-e) :keys "C-u C-c C-f C-e"] + ["Bold" (TeX-font t ?\C-b) :keys "C-u C-c C-f C-b"] + ["Typewriter" (TeX-font t ?\C-t) :keys "C-u C-c C-f C-t"] + ["Small Caps" (TeX-font t ?\C-c) :keys "C-u C-c C-f C-c"] + ["Sans Serif" (TeX-font t ?\C-f) :keys "C-u C-c C-f C-f"] + ["Italic" (TeX-font t ?\C-i) :keys "C-u C-c C-f C-i"] + ["Slanted" (TeX-font t ?\C-s) :keys "C-u C-c C-f C-s"] + ["Roman" (TeX-font t ?\C-r) :keys "C-u C-c C-f C-r"] + ["Calligraphic" (TeX-font t ?\C-a) :keys "C-u C-c C-f C-a"]) + ["Delete Font" (TeX-font t ?\C-d) :keys "C-c C-f C-d"] + "-" + ["Comment or Uncomment Region" + comment-or-uncomment-region + :help "Make the selected region outcommented or active again"] + ["Comment or Uncomment Paragraph" + TeX-comment-or-uncomment-paragraph + :help "Make the current paragraph outcommented or active again"] + ,TeX-fold-menu + "-" . ,TeX-common-menu-entries)) + +(defun ConTeXt-menu-update (&optional menu) + "Update entries on AUCTeX menu." + (or (not (memq major-mode '(context-mode))) + (null ConTeXt-menu-changed) + (progn + (TeX-update-style) + (setq ConTeXt-menu-changed nil) + (message "Updating section menu...") + (mapc #'ConTeXt-section-enable ConTeXt-section-list) + (message "Updating section menu...done") + (message "Updating environment menu...") + (easy-menu-change '("ConTeXt") ConTeXt-environment-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-environment-menu-entry + (ConTeXt-environment-list)))) + (message "Updating environment menu...done") + (message "Updating modify environment menu...") + (easy-menu-change '("ConTeXt") ConTeXt-environment-modify-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-environment-modify-menu-entry + (ConTeXt-environment-list)))) + (message "Updating modify environment menu...done") + (message "Updating define menu...") + (easy-menu-change '("ConTeXt") ConTeXt-define-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-define-menu-entry + ConTeXt-define-list))) + (message "Updating define menu...done") + (message "Updating setup menu...") + (easy-menu-change '("ConTeXt") ConTeXt-setup-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-setup-menu-entry + ConTeXt-setup-list))) + (message "Updating setup menu...done") + (message "Updating referencing menu...") + (easy-menu-change '("ConTeXt") ConTeXt-referencing-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-referencing-menu-entry + ConTeXt-referencing-list))) + (message "Updating referencing menu...done") + (message "Updating other macro's menu...") + (easy-menu-change '("ConTeXt") ConTeXt-other-macro-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-other-macro-menu-entry + ConTeXt-other-macro-list))) + (message "Updating other macro's menu...done") + (message "Updating project structure menu...") + (easy-menu-change '("ConTeXt") ConTeXt-project-structure-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-project-structure-menu-entry + ConTeXt-project-structure-list))) + (message "Updating project structure menu...done") + (message "Updating section block menu...") + (easy-menu-change '("ConTeXt") ConTeXt-section-block-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-section-block-menu-entry + ConTeXt-section-block-list))) + (message "Updating section block menu...done") + (message "Updating section menu...") + (easy-menu-change '("ConTeXt") ConTeXt-numbered-section-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-numbered-section-menu-entry + ConTeXt-numbered-section-list))) + (easy-menu-change '("ConTeXt") ConTeXt-unnumbered-section-menu-name + (LaTeX-split-long-menu + (mapcar #'ConTeXt-unnumbered-section-menu-entry + ConTeXt-unnumbered-section-list))) + (message "Updating section menu...done") + (and menu (easy-menu-return-item ConTeXt-mode-menu menu)) + ))) + +;;; Option expander + +(defvar ConTeXt-texexec-option-nonstop "--nonstop " + "Command line option for texexec to use nonstopmode.") + +(defun ConTeXt-expand-command () + "Expand ConTeXt command. +Use `ConTeXt-Mark-version' to choose the command." + (cond + ((string= ConTeXt-Mark-version "IV") + "context") + ;; In any other case fall back on Mark II. + (t + "texexec"))) + +(defun ConTeXt-expand-options () + "Expand options for context command." + (cond + ;; Mark IV + ((string= ConTeXt-Mark-version "IV") + (concat + (if TeX-source-correlate-mode + "--synctex=1 ") + (unless TeX-interactive-mode + ConTeXt-texexec-option-nonstop))) + ;; In any other case fall back on Mark II. + (t + (concat + (let ((engine (eval (nth 4 (TeX-engine-in-engine-alist TeX-engine)) t))) + (when engine + (format "--engine=%s " engine))) + (unless (eq ConTeXt-current-interface "en") + (format "--interface=%s " ConTeXt-current-interface)) + (when TeX-source-correlate-mode + (format "--passon=\"%s\" " + (if (eq (TeX-source-correlate-method-active) 'synctex) + TeX-synctex-tex-flags + TeX-source-specials-tex-flags))) + (unless TeX-interactive-mode + ConTeXt-texexec-option-nonstop))))) + +;;; Mode + +;; ConTeXt variables that are interface aware +;; They are mapped to interface specific variables + +(defvar ConTeXt-language-variable-list + '(ConTeXt-define-list + ConTeXt-setup-list + ConTeXt-referencing-list + ConTeXt-other-macro-list + ConTeXt-project-structure-list + ConTeXt-section-block-list + ConTeXt-numbered-section-list + ConTeXt-unnumbered-section-list + ConTeXt-section-list + ConTeXt-text + ConTeXt-item-list + ConTeXt-extra-paragraph-commands + ConTeXt-environment-list) + "List of variables to be set from languages specific ones.") + +(defconst ConTeXt-dialect :context + "Default dialect for use with function `TeX-add-style-hook' for +argument DIALECT-EXPR when the hook is to be run only on ConTeXt +file, or any mode derived thereof. See variable +`TeX-style-hook-dialect'." ) + +(defcustom ConTeXt-clean-intermediate-suffixes + ;; See *suffixes in texutil.pl. + '("\\.tui" "\\.tup" "\\.ted" "\\.tes" "\\.top" "\\.log" "\\.tmp" "\\.run" + "\\.bck" "\\.rlg" "\\.mpt" "\\.mpx" "\\.mpd" "\\.mpo" "\\.tuo" "\\.tub" + "\\.top" "-mpgraph\\.mp" "-mpgraph\\.mpd" "-mpgraph\\.mpo" "-mpgraph\\.mpy" + "-mprun\\.mp" "-mprun\\.mpd" "-mprun\\.mpo" "-mprun\\.mpy") + "List of regexps matching suffixes of files to be deleted. +The regexps will be anchored at the end of the file name to be matched, +that is, you do _not_ have to cater for this yourself by adding \\\\\\=' or $." + :type '(repeat regexp) + :group 'TeX-command) + +(defcustom ConTeXt-clean-output-suffixes + '("\\.dvi" "\\.pdf" "\\.ps") + "List of regexps matching suffixes of files to be deleted. +The regexps will be anchored at the end of the file name to be matched, +that is, you do _not_ have to cater for this yourself by adding \\\\\\=' or $." + :type '(repeat regexp) + :group 'TeX-command) + +(TeX-abbrev-mode-setup context-mode) + +(defun ConTeXt-mode-common-initialization () + "Initialization code that is common for all ConTeXt interfaces." + ;; `plain-TeX-common-initialization' kills all local variables, but + ;; we need to keep ConTeXt-current-interface, so save and restore + ;; it. + (let (save-ConTeXt-current-interface) + (setq save-ConTeXt-current-interface ConTeXt-current-interface) + (plain-TeX-common-initialization) + (setq ConTeXt-current-interface save-ConTeXt-current-interface)) + (setq major-mode 'context-mode) + + (setq local-abbrev-table context-mode-abbrev-table) + (set (make-local-variable 'TeX-style-hook-dialect) ConTeXt-dialect) + + ;; Make language specific variables buffer local + (dolist (symbol ConTeXt-language-variable-list) + (make-variable-buffer-local symbol)) + + (require (intern (concat "context-" ConTeXt-current-interface))) + (dolist (symbol ConTeXt-language-variable-list) + (set symbol (symbol-value (intern (concat (symbol-name symbol) "-" + ConTeXt-current-interface))))) + + ;; Create certain regular expressions based on language + (setq ConTeXt-indent-item-re (concat "\\\\\\(" (mapconcat #'identity ConTeXt-item-list "\\|") "\\)\\>")) + + ;; What's the deepest level at we can collapse a document? + ;; set only if user has not set it. Need to be set before menu is created. + ;; level 2 is "section" + (or ConTeXt-largest-level + (setq ConTeXt-largest-level 2)) + + ;; keybindings + (use-local-map ConTeXt-mode-map) + + ;; Indenting + (set (make-local-variable 'indent-line-function) #'ConTeXt-indent-line) + (set (make-local-variable 'fill-indent-according-to-mode) t) + + ;; Paragraph formatting + (set (make-local-variable 'LaTeX-syntactic-comments) nil) + (set (make-local-variable 'LaTeX-paragraph-commands-regexp) + (ConTeXt-paragraph-commands-regexp)) + (set (make-local-variable 'paragraph-ignore-fill-prefix) t) + (set (make-local-variable 'fill-paragraph-function) #'LaTeX-fill-paragraph) + (set (make-local-variable 'adaptive-fill-mode) nil) + (setq paragraph-start + (concat + "[ \t]*\\(" + (ConTeXt-paragraph-commands-regexp) "\\|" + "\\$\\$\\|" ; Plain TeX display math + "$\\)")) + (setq paragraph-separate + (concat + "[ \t]*\\(" + "\\$\\$" ; Plain TeX display math + "\\|$\\)")) + + ;; Keybindings and menu + (use-local-map ConTeXt-mode-map) + (setq ConTeXt-menu-changed t) + + (add-hook 'activate-menubar-hook #'ConTeXt-menu-update nil t) + + (setq-local beginning-of-defun-function #'ConTeXt-find-matching-start + end-of-defun-function #'ConTeXt-find-matching-stop) + + ;; Outline support + (require 'outline) + (set (make-local-variable 'outline-level) 'ConTeXt-outline-level) + (set (make-local-variable 'outline-regexp) (ConTeXt-outline-regexp t)) + ;;(make-local-variable 'outline-heading-end-regexp) + (setq TeX-header-end (ConTeXt-header-end) + TeX-trailer-start (ConTeXt-trailer-start)) + + ;; font switch support + (set (make-local-variable 'TeX-font-list) ConTeXt-font-list) + + ;; imenu support + (set (make-local-variable 'imenu-create-index-function) + #'ConTeXt-imenu-create-index-function) + + ;; run hooks + (setq TeX-command-default "ConTeXt") + (setq TeX-sentinel-default-function #'TeX-ConTeXt-sentinel) + (run-mode-hooks 'text-mode-hook 'TeX-mode-hook 'ConTeXt-mode-hook)) + +(defun context-guess-current-interface () + "Guess what ConTeXt interface the current buffer is using." + (interactive) + (save-excursion + (goto-char (point-min)) + (setq ConTeXt-current-interface + (cond ((re-search-forward "%.*?interface=en" (+ 512 (point)) t) + "en") + ((re-search-forward "%.*?interface=nl" (+ 512 (point)) t) + "nl") + ((re-search-forward "\\\\starttext" (+ 1024 (point)) t) + "en") + ((re-search-forward "\\\\starttekst" (+ 1024 (point)) t) + "nl") + (t + ConTeXt-default-interface))))) + +;;;###autoload +(defalias 'ConTeXt-mode #'context-mode) + +;;;###autoload +(defun context-mode () + "Major mode in AUCTeX for editing ConTeXt files. + +Special commands: +\\{ConTeXt-mode-map} + +Entering `context-mode' calls the value of `text-mode-hook', +then the value of `TeX-mode-hook', and then the value +of `ConTeXt-mode-hook'." + (interactive) + (context-guess-current-interface) + (require (intern (concat "context-" ConTeXt-current-interface))) + (funcall (intern (concat "context-" ConTeXt-current-interface "-mode")))) + +(provide 'context) + +;;; context.el ends here |