Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Tag: unicode-post-f…
Fetching contributors…

Cannot retrieve contributors at this time

5937 lines (5309 sloc) 237.867 kB
;;; allout.el --- extensive outline mode for use alone and with other modes
;; Copyright (C) 1992, 1993, 1994, 2001, 2002, 2003, 2004,
;; 2005, 2006 Free Software Foundation, Inc.
;; Author: Ken Manheimer <ken dot manheimer at gmail dot com>
;; Maintainer: Ken Manheimer <ken dot manheimer at gmail dot com>
;; Created: Dec 1991 - first release to usenet
;; Version: 2.2.1
;; Keywords: outlines wp languages
;; 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 2, 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
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;; Commentary:
;; Allout outline minor mode provides extensive outline formatting and
;; and manipulation beyond standard emacs outline mode. Some features:
;; - Classic outline-mode topic-oriented navigation and exposure adjustment
;; - Topic-oriented editing including coherent topic and subtopic
;; creation, promotion, demotion, cut/paste across depths, etc.
;; - Incremental search with dynamic exposure and reconcealment of text
;; - Customizable bullet format - enables programming-language specific
;; outlining, for code-folding editing. (Allout code itself is to try it;
;; formatted as an outline - do ESC-x eval-current-buffer in allout.el; but
;; emacs local file variables need to be enabled when the
;; file was visited - see `enable-local-variables'.)
;; - Configurable per-file initial exposure settings
;; - Symmetric-key and key-pair topic encryption, plus symmetric passphrase
;; mnemonic support, with verification against an established passphrase
;; (using a stashed encrypted dummy string) and user-supplied hint
;; maintenance. (See allout-toggle-current-subtree-encryption docstring.)
;; - Automatic topic-number maintenance
;; - "Hot-spot" operation, for single-keystroke maneuvering and
;; exposure control (see the allout-mode docstring)
;; - Easy rendering of exposed portions into numbered, latex, indented, etc
;; outline styles
;; - Careful attention to whitespace - enabling blank lines between items
;; and maintenance of hanging indentation (in paragraph auto-fill and
;; across topic promotion and demotion) of topic bodies consistent with
;; indentation of their topic header.
;; and more.
;; See the `allout-mode' function's docstring for an introduction to the
;; mode. The development version and helpful notes are available at
;; .
;; The outline menubar additions provide quick reference to many of
;; the features, and see the docstring of the variable `allout-init'
;; for instructions on priming your emacs session for automatic
;; activation of allout-mode.
;; See the docstring of the variables `allout-layout' and
;; `allout-auto-activation' for details on automatic activation of
;; `allout-mode' as a minor mode. (It has changed since allout
;; 3.x, for those of you that depend on the old method.)
;; Note - the lines beginning with `;;;_' are outline topic headers.
;; Just `ESC-x eval-current-buffer' to give it a whirl.
;; ken manheimer (ken dot manheimer at gmail dot com)
;;; Code:
;;;_* Dependency autoloads
(require 'overlay)
(eval-when-compile (progn (require 'pgg)
(require 'pgg-gpg)
(require 'overlay)
;;;_ > defgroup allout
(defgroup allout nil
"Extensive outline mode for use alone and with other modes."
:prefix "allout-"
:group 'outlines)
;;;_ + Layout, Mode, and Topic Header Configuration
;;;_ = allout-auto-activation
(defcustom allout-auto-activation nil
"*Regulates auto-activation modality of allout outlines - see `allout-init'.
Setq-default by `allout-init' to regulate whether or not allout
outline mode is automatically activated when the buffer-specific
variable `allout-layout' is non-nil, and whether or not the layout
dictated by `allout-layout' should be imposed on mode activation.
With value t, auto-mode-activation and auto-layout are enabled.
\(This also depends on `allout-find-file-hook' being installed in
`find-file-hook', which is also done by `allout-init'.)
With value `ask', auto-mode-activation is enabled, and endorsement for
performing auto-layout is asked of the user each time.
With value `activate', only auto-mode-activation is enabled,
auto-layout is not.
With value nil, neither auto-mode-activation nor auto-layout are
See the docstring for `allout-init' for the proper interface to
this variable."
:type '(choice (const :tag "On" t)
(const :tag "Ask about layout" "ask")
(const :tag "Mode only" "activate")
(const :tag "Off" nil))
:group 'allout)
;;;_ = allout-default-layout
(defcustom allout-default-layout '(-2 : 0)
"*Default allout outline layout specification.
This setting specifies the outline exposure to use when
`allout-layout' has the local value `t'. This docstring describes the
layout specifications.
A list value specifies a default layout for the current buffer,
to be applied upon activation of `allout-mode'. Any non-nil
value will automatically trigger `allout-mode', provided
`allout-init' has been called to enable this behavior.
The types of elements in the layout specification are:
integer - dictate the relative depth to open the corresponding topic(s),
- negative numbers force the topic to be closed before opening
to the absolute value of the number, so all siblings are open
only to that level.
- positive numbers open to the relative depth indicated by the
number, but do not force already opened subtopics to be closed.
- 0 means to close topic - hide all subitems.
: - repeat spec - apply the preceeding element to all siblings at
current level, *up to* those siblings that would be covered by specs
following the `:' on the list. Ie, apply to all topics at level but
trailing ones accounted for by trailing specs. \(Only the first of
multiple colons at the same level is honored - later ones are ignored.)
* - completely exposes the topic, including bodies
+ - exposes all subtopics, but not the bodies
- - exposes the body of the corresponding topic, but not subtopics
list - a nested layout spec, to be applied intricately to its
corresponding item(s)
'(-2 : 0)
Collapse the top-level topics to show their children and
grandchildren, but completely collapse the final top-level topic.
'(-1 () : 1 0)
Close the first topic so only the immediate subtopics are shown,
leave the subsequent topics exposed as they are until the second
second to last topic, which is exposed at least one level, and
completely close the last topic.
'(-2 : -1 *)
Expose children and grandchildren of all topics at current
level except the last two; expose children of the second to
last and completely expose the last one, including its subtopics.
See `allout-expose-topic' for more about the exposure process.
Also, allout's mode-specific provisions will make topic prefixes default
to the comment-start string, if any, of the language of the file. This
is modulo the setting of `allout-use-mode-specific-leader', which see."
:type 'allout-layout-type
:group 'allout)
;;;_ : allout-layout-type
(define-widget 'allout-layout-type 'lazy
"Allout layout format customization basic building blocks."
:type '(repeat
(choice (integer :tag "integer (<= zero is strict)")
(const :tag ": (repeat prior)" :)
(const :tag "* (completely expose)" *)
(const :tag "+ (expose all offspring, headlines only)" +)
(const :tag "- (expose topic body but not offspring)" -)
(allout-layout-type :tag "<Nested layout>"))))
;;;_ = allout-show-bodies
(defcustom allout-show-bodies nil
"*If non-nil, show entire body when exposing a topic, rather than
just the header."
:type 'boolean
:group 'allout)
(make-variable-buffer-local 'allout-show-bodies)
(put 'allout-show-bodies 'safe-local-variable
(if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
;;;_ = allout-header-prefix
(defcustom allout-header-prefix "."
"*Leading string which helps distinguish topic headers.
Outline topic header lines are identified by a leading topic
header prefix, which mostly have the value of this var at their front.
\(Level 1 topics are exceptions. They consist of only a single
character, which is typically set to the `allout-primary-bullet'. Many
outlines start at level 2 to avoid this discrepancy."
:type 'string
:group 'allout)
(make-variable-buffer-local 'allout-header-prefix)
(put 'allout-header-prefix 'safe-local-variable 'stringp)
;;;_ = allout-primary-bullet
(defcustom allout-primary-bullet "*"
"Bullet used for top-level outline topics.
Outline topic header lines are identified by a leading topic header
prefix, which is concluded by bullets that includes the value of this
var and the respective allout-*-bullets-string vars.
The value of an asterisk (`*') provides for backwards compatibility
with the original Emacs outline mode. See `allout-plain-bullets-string'
and `allout-distinctive-bullets-string' for the range of available
:type 'string
:group 'allout)
(make-variable-buffer-local 'allout-primary-bullet)
(put 'allout-primary-bullet 'safe-local-variable 'stringp)
;;;_ = allout-plain-bullets-string
(defcustom allout-plain-bullets-string ".,"
"*The bullets normally used in outline topic prefixes.
See `allout-distinctive-bullets-string' for the other kind of
DO NOT include the close-square-bracket, `]', as a bullet.
Outline mode has to be reactivated in order for changes to the value
of this var to take effect."
:type 'string
:group 'allout)
(make-variable-buffer-local 'allout-plain-bullets-string)
(put 'allout-plain-bullets-string 'safe-local-variable 'stringp)
;;;_ = allout-distinctive-bullets-string
(defcustom allout-distinctive-bullets-string "*+-=>()[{}&!?#%\"X@$~_\\:;^"
"*Persistent outline header bullets used to distinguish special topics.
These bullets are used to distinguish topics from the run-of-the-mill
ones. They are not used in the standard topic headers created by
the topic-opening, shifting, and rebulleting \(eg, on topic shift,
topic paste, blanket rebulleting) routines, but are offered among the
choices for rebulleting. They are not altered by the above automatic
rebulleting, so they can be used to characterize topics, eg:
`?' question topics
`\(' parenthetic comment \(with a matching close paren inside)
`[' meta-note \(with a matching close ] inside)
`\"' a quotation
`=' value settings
`~' \"more or less\"
`^' see above
... for example. (`#' typically has a special meaning to the software,
according to the value of `allout-numbered-bullet'.)
See `allout-plain-bullets-string' for the selection of
alternating bullets.
You must run `set-allout-regexp' in order for outline mode to
reconcile to changes of this value.
DO NOT include the close-square-bracket, `]', on either of the bullet
:type 'string
:group 'allout)
(make-variable-buffer-local 'allout-distinctive-bullets-string)
(put 'allout-distinctive-bullets-string 'safe-local-variable 'stringp)
;;;_ = allout-use-mode-specific-leader
(defcustom allout-use-mode-specific-leader t
"*When non-nil, use mode-specific topic-header prefixes.
Allout outline mode will use the mode-specific `allout-mode-leaders'
and/or comment-start string, if any, to lead the topic prefix string,
so topic headers look like comments in the programming language.
String values are used as they stand.
Value t means to first check for assoc value in `allout-mode-leaders'
alist, then use comment-start string, if any, then use default \(`.').
\(See note about use of comment-start strings, below.)
Set to the symbol for either of `allout-mode-leaders' or
`comment-start' to use only one of them, respectively.
Value nil means to always use the default \(`.').
comment-start strings that do not end in spaces are tripled, and an
`_' underscore is tacked on the end, to distinguish them from regular
comment strings. comment-start strings that do end in spaces are not
tripled, but an underscore is substituted for the space. [This
presumes that the space is for appearance, not comment syntax. You
can use `allout-mode-leaders' to override this behavior, when
:type '(choice (const t) (const nil) string
(const allout-mode-leaders)
(const comment-start))
:group 'allout)
(put 'allout-use-mode-specific-leader 'safe-local-variable
'(lambda (x) (or (memq x '(t nil allout-mode-leaders comment-start))
(stringp x))))
;;;_ = allout-mode-leaders
(defvar allout-mode-leaders '()
"Specific allout-prefix leading strings per major modes.
Entries will be used instead or in lieu of mode-specific
comment-start strings. See also `allout-use-mode-specific-leader'.
If you're constructing a string that will comment-out outline
structuring so it can be included in program code, append an extra
character, like an \"_\" underscore, to distinguish the lead string
from regular comments that start at bol.")
;;;_ = allout-old-style-prefixes
(defcustom allout-old-style-prefixes nil
"*When non-nil, use only old-and-crusty `outline-mode' `*' topic prefixes.
Non-nil restricts the topic creation and modification
functions to asterix-padded prefixes, so they look exactly
like the original Emacs-outline style prefixes.
Whatever the setting of this variable, both old and new style prefixes
are always respected by the topic maneuvering functions."
:type 'boolean
:group 'allout)
(make-variable-buffer-local 'allout-old-style-prefixes)
(put 'allout-old-style-prefixes 'safe-local-variable
(if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
;;;_ = allout-stylish-prefixes - alternating bullets
(defcustom allout-stylish-prefixes t
"*Do fancy stuff with topic prefix bullets according to level, etc.
Non-nil enables topic creation, modification, and repositioning
functions to vary the topic bullet char (the char that marks the topic
depth) just preceding the start of the topic text) according to level.
Otherwise, only asterisks (`*') and distinctive bullets are used.
This is how an outline can look (but sans indentation) with stylish
* Top level
.* A topic
. + One level 3 subtopic
. . One level 4 subtopic
. . A second 4 subtopic
. + Another level 3 subtopic
. #1 A numbered level 4 subtopic
. #2 Another
. ! Another level 4 subtopic with a different distinctive bullet
. #4 And another numbered level 4 subtopic
This would be an outline with stylish prefixes inhibited (but the
numbered and other distinctive bullets retained):
* Top level
.* A topic
. * One level 3 subtopic
. * One level 4 subtopic
. * A second 4 subtopic
. * Another level 3 subtopic
. #1 A numbered level 4 subtopic
. #2 Another
. ! Another level 4 subtopic with a different distinctive bullet
. #4 And another numbered level 4 subtopic
Stylish and constant prefixes (as well as old-style prefixes) are
always respected by the topic maneuvering functions, regardless of
this variable setting.
The setting of this var is not relevant when `allout-old-style-prefixes'
is non-nil."
:type 'boolean
:group 'allout)
(make-variable-buffer-local 'allout-stylish-prefixes)
(put 'allout-stylish-prefixes 'safe-local-variable
(if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
;;;_ = allout-numbered-bullet
(defcustom allout-numbered-bullet "#"
"*String designating bullet of topics that have auto-numbering; nil for none.
Topics having this bullet have automatic maintenance of a sibling
sequence-number tacked on, just after the bullet. Conventionally set
to \"#\", you can set it to a bullet of your choice. A nil value
disables numbering maintenance."
:type '(choice (const nil) string)
:group 'allout)
(make-variable-buffer-local 'allout-numbered-bullet)
(put 'allout-numbered-bullet 'safe-local-variable
(if (fboundp 'string-or-null-p)
'(lambda (x) (or (stringp x) (null x)))))
;;;_ = allout-file-xref-bullet
(defcustom allout-file-xref-bullet "@"
"*Bullet signifying file cross-references, for `allout-resolve-xref'.
Set this var to the bullet you want to use for file cross-references."
:type '(choice (const nil) string)
:group 'allout)
(put 'allout-file-xref-bullet 'safe-local-variable
(if (fboundp 'string-or-null-p)
'(lambda (x) (or (stringp x) (null x)))))
;;;_ = allout-presentation-padding
(defcustom allout-presentation-padding 2
"*Presentation-format white-space padding factor, for greater indent."
:type 'integer
:group 'allout)
(make-variable-buffer-local 'allout-presentation-padding)
(put 'allout-presentation-padding 'safe-local-variable 'integerp)
;;;_ = allout-abbreviate-flattened-numbering
(defcustom allout-abbreviate-flattened-numbering nil
"*If non-nil, `allout-flatten-exposed-to-buffer' abbreviates topic
numbers to minimal amount with some context. Otherwise, entire
numbers are always used."
:type 'boolean
:group 'allout)
;;;_ + LaTeX formatting
;;;_ - allout-number-pages
(defcustom allout-number-pages nil
"*Non-nil turns on page numbering for LaTeX formatting of an outline."
:type 'boolean
:group 'allout)
;;;_ - allout-label-style
(defcustom allout-label-style "\\large\\bf"
"*Font and size of labels for LaTeX formatting of an outline."
:type 'string
:group 'allout)
;;;_ - allout-head-line-style
(defcustom allout-head-line-style "\\large\\sl "
"*Font and size of entries for LaTeX formatting of an outline."
:type 'string
:group 'allout)
;;;_ - allout-body-line-style
(defcustom allout-body-line-style " "
"*Font and size of entries for LaTeX formatting of an outline."
:type 'string
:group 'allout)
;;;_ - allout-title-style
(defcustom allout-title-style "\\Large\\bf"
"*Font and size of titles for LaTeX formatting of an outline."
:type 'string
:group 'allout)
;;;_ - allout-title
(defcustom allout-title '(or buffer-file-name (buffer-name))
"*Expression to be evaluated to determine the title for LaTeX
formatted copy."
:type 'sexp
:group 'allout)
;;;_ - allout-line-skip
(defcustom allout-line-skip ".05cm"
"*Space between lines for LaTeX formatting of an outline."
:type 'string
:group 'allout)
;;;_ - allout-indent
(defcustom allout-indent ".3cm"
"*LaTeX formatted depth-indent spacing."
:type 'string
:group 'allout)
;;;_ + Topic encryption
;;;_ = allout-encryption group
(defgroup allout-encryption nil
"Settings for topic encryption features of allout outliner."
:group 'allout)
;;;_ = allout-topic-encryption-bullet
(defcustom allout-topic-encryption-bullet "~"
"*Bullet signifying encryption of the entry's body."
:type '(choice (const nil) string)
:version "22.0"
:group 'allout-encryption)
;;;_ = allout-passphrase-verifier-handling
(defcustom allout-passphrase-verifier-handling t
"*Enable use of symmetric encryption passphrase verifier if non-nil.
See the docstring for the `allout-enable-file-variable-adjustment'
variable for details about allout ajustment of file variables."
:type 'boolean
:version "22.0"
:group 'allout-encryption)
(make-variable-buffer-local 'allout-passphrase-verifier-handling)
;;;_ = allout-passphrase-hint-handling
(defcustom allout-passphrase-hint-handling 'always
"*Dictate outline encryption passphrase reminder handling:
always - always show reminder when prompting
needed - show reminder on passphrase entry failure
disabled - never present or adjust reminder
See the docstring for the `allout-enable-file-variable-adjustment'
variable for details about allout ajustment of file variables."
:type '(choice (const always)
(const needed)
(const disabled))
:version "22.0"
:group 'allout-encryption)
(make-variable-buffer-local 'allout-passphrase-hint-handling)
;;;_ = allout-encrypt-unencrypted-on-saves
(defcustom allout-encrypt-unencrypted-on-saves t
"*When saving, should topics pending encryption be encrypted?
The idea is to prevent file-system exposure of any un-encrypted stuff, and
mostly covers both deliberate file writes and auto-saves.
- Yes: encrypt all topics pending encryption, even if it's the one
currently being edited. \(In that case, the currently edited topic
will be automatically decrypted before any user interaction, so they
can continue editing but the copy on the file system will be
Auto-saves will use the \"All except current topic\" mode if this
one is selected, to avoid practical difficulties - see below.
- All except current topic: skip the topic currently being edited, even if
it's pending encryption. This may expose the current topic on the
file sytem, but avoids the nuisance of prompts for the encryption
passphrase in the middle of editing for, eg, autosaves.
This mode is used for auto-saves for both this option and \"Yes\".
- No: leave it to the user to encrypt any unencrypted topics.
For practical reasons, auto-saves always use the 'except-current policy
when auto-encryption is enabled. \(Otherwise, spurious passphrase prompts
and unavoidable timing collisions are too disruptive.) If security for a
file requires that even the current topic is never auto-saved in the clear,
disable auto-saves for that file."
:type '(choice (const :tag "Yes" t)
(const :tag "All except current topic" except-current)
(const :tag "No" nil))
:version "22.0"
:group 'allout-encryption)
(make-variable-buffer-local 'allout-encrypt-unencrypted-on-saves)
;;;_ + Miscellaneous customization
;;;_ = allout-command-prefix
(defcustom allout-command-prefix "\C-c "
"*Key sequence to be used as prefix for outline mode command key bindings.
Default is '\C-c<space>'; just '\C-c' is more short-and-sweet, if you're
willing to let allout use a bunch of \C-c keybindings."
:type 'string
:group 'allout)
;;;_ = allout-keybindings-list
;;; You have to reactivate allout-mode - `(allout-mode t)' - to
;;; institute changes to this var.
(defvar allout-keybindings-list ()
"*List of `allout-mode' key / function bindings, for `allout-mode-map'.
String or vector key will be prefaced with `allout-command-prefix',
unless optional third, non-nil element is present.")
(setq allout-keybindings-list
; Motion commands:
("\C-n" allout-next-visible-heading)
("\C-p" allout-previous-visible-heading)
("\C-u" allout-up-current-level)
("\C-f" allout-forward-current-level)
("\C-b" allout-backward-current-level)
("\C-a" allout-beginning-of-current-entry)
("\C-e" allout-end-of-entry)
; Exposure commands:
("\C-i" allout-show-children)
("\C-s" allout-show-current-subtree)
("\C-h" allout-hide-current-subtree)
("h" allout-hide-current-subtree)
("\C-o" allout-show-current-entry)
("!" allout-show-all)
("x" allout-toggle-current-subtree-encryption)
; Alteration commands:
(" " allout-open-sibtopic)
("." allout-open-subtopic)
("," allout-open-supertopic)
("'" allout-shift-in)
(">" allout-shift-in)
("<" allout-shift-out)
("\C-m" allout-rebullet-topic)
("*" allout-rebullet-current-heading)
("#" allout-number-siblings)
("\C-k" allout-kill-line t)
("\C-y" allout-yank t)
("\M-y" allout-yank-pop t)
("\C-k" allout-kill-topic)
; Miscellaneous commands:
;([?\C-\ ] allout-mark-topic)
("@" allout-resolve-xref)
("=c" allout-copy-exposed-to-buffer)
("=i" allout-indented-exposed-to-buffer)
("=t" allout-latexify-exposed)
("=p" allout-flatten-exposed-to-buffer)))
;;;_ = allout-use-hanging-indents
(defcustom allout-use-hanging-indents t
"*If non-nil, topic body text auto-indent defaults to indent of the header.
Ie, it is indented to be just past the header prefix. This is
relevant mostly for use with indented-text-mode, or other situations
where auto-fill occurs."
:type 'boolean
:group 'allout)
(make-variable-buffer-local 'allout-use-hanging-indents)
(put 'allout-use-hanging-indents 'safe-local-variable
(if (fboundp 'booleanp) 'booleanp '(lambda (x) (member x '(t nil)))))
;;;_ = allout-reindent-bodies
(defcustom allout-reindent-bodies (if allout-use-hanging-indents
"*Non-nil enables auto-adjust of topic body hanging indent with depth shifts.
When active, topic body lines that are indented even with or beyond
their topic header are reindented to correspond with depth shifts of
the header.
A value of t enables reindent in non-programming-code buffers, ie
those that do not have the variable `comment-start' set. A value of
`force' enables reindent whether or not `comment-start' is set."
:type '(choice (const nil) (const t) (const text) (const force))
:group 'allout)
(make-variable-buffer-local 'allout-reindent-bodies)
(put 'allout-reindent-bodies 'safe-local-variable
'(lambda (x) (memq x '(nil t text force))))
;;;_ = allout-enable-file-variable-adjustment
(defcustom allout-enable-file-variable-adjustment t
"*If non-nil, some allout outline actions edit Emacs local file var text.
This can range from changes to existing entries, addition of new ones,
and creation of a new local variables section when necessary.
Emacs file variables adjustments are also inhibited if `enable-local-variables'
is nil.
Operations potentially causing edits include allout encryption routines.
For details, see `allout-toggle-current-subtree-encryption's docstring."
:type 'boolean
:group 'allout)
(make-variable-buffer-local 'allout-enable-file-variable-adjustment)
;;;_* CODE - no user customizations below.
;;;_ #1 Internal Outline Formatting and Configuration
;;;_ : Version
;;;_ = allout-version
(defvar allout-version "2.2.1"
"Version of currently loaded outline package. \(allout.el)")
;;;_ > allout-version
(defun allout-version (&optional here)
"Return string describing the loaded outline version."
(interactive "P")
(let ((msg (concat "Allout Outline Mode v " allout-version)))
(if here (insert msg))
(message "%s" msg)
;;;_ : Mode activation (defined here because it's referenced early)
;;;_ = allout-mode
(defvar allout-mode nil "Allout outline mode minor-mode flag.")
(make-variable-buffer-local 'allout-mode)
;;;_ = allout-layout nil
(defvar allout-layout nil ; LEAVE GLOBAL VALUE NIL - see docstring.
"Buffer-specific setting for allout layout.
In buffers where this is non-nil \(and if `allout-init' has been run, to
enable this behavior), `allout-mode' will be automatically activated. The
layout dictated by the value will be used to set the initial exposure when
`allout-mode' is activated.
\*You should not setq-default this variable non-nil unless you want every
visited file to be treated as an allout file.*
The value would typically be set by a file local variable. For
example, the following lines at the bottom of an Emacs Lisp file:
;;;Local variables:
;;;allout-layout: \(0 : -1 -1 0)
dictate activation of `allout-mode' mode when the file is visited
\(presuming allout-init was already run), followed by the
equivalent of `\(allout-expose-topic 0 : -1 -1 0)'. \(This is
the layout used for the allout.el source file.)
`allout-default-layout' describes the specification format.
`allout-layout' can additionally have the value `t', in which
case the value of `allout-default-layout' is used.")
(make-variable-buffer-local 'allout-layout)
(put 'allout-layout 'safe-local-variable
'(lambda (x) (or (numberp x) (listp x) (memq x '(: * + -)))))
;;;_ : Topic header format
;;;_ = allout-regexp
(defvar allout-regexp ""
"*Regular expression to match the beginning of a heading line.
Any line whose beginning matches this regexp is considered a
heading. This var is set according to the user configuration vars
by `set-allout-regexp'.")
(make-variable-buffer-local 'allout-regexp)
;;;_ = allout-bullets-string
(defvar allout-bullets-string ""
"A string dictating the valid set of outline topic bullets.
This var should *not* be set by the user - it is set by `set-allout-regexp',
and is produced from the elements of `allout-plain-bullets-string'
and `allout-distinctive-bullets-string'.")
(make-variable-buffer-local 'allout-bullets-string)
;;;_ = allout-bullets-string-len
(defvar allout-bullets-string-len 0
"Length of current buffers' `allout-plain-bullets-string'.")
(make-variable-buffer-local 'allout-bullets-string-len)
;;;_ = allout-line-boundary-regexp
(defvar allout-line-boundary-regexp ()
"`allout-regexp' with outline style beginning-of-line anchor.
This is properly set when `allout-regexp' is produced by
`set-allout-regexp', so that (match-beginning 2) and (match-end
2) delimit the prefix.")
(make-variable-buffer-local 'allout-line-boundary-regexp)
;;;_ = allout-bob-regexp
(defvar allout-bob-regexp ()
"Like `allout-line-boundary-regexp', for headers at beginning of buffer.
\(match-beginning 2) and \(match-end 2) delimit the prefix.")
(make-variable-buffer-local 'allout-bob-regexp)
;;;_ = allout-header-subtraction
(defvar allout-header-subtraction (1- (length allout-header-prefix))
"Allout-header prefix length to subtract when computing topic depth.")
(make-variable-buffer-local 'allout-header-subtraction)
;;;_ = allout-plain-bullets-string-len
(defvar allout-plain-bullets-string-len (length allout-plain-bullets-string)
"Length of `allout-plain-bullets-string', updated by `set-allout-regexp'.")
(make-variable-buffer-local 'allout-plain-bullets-string-len)
;;;_ X allout-reset-header-lead (header-lead)
(defun allout-reset-header-lead (header-lead)
"*Reset the leading string used to identify topic headers."
(interactive "sNew lead string: ")
(setq allout-header-prefix header-lead)
(setq allout-header-subtraction (1- (length allout-header-prefix)))
;;;_ X allout-lead-with-comment-string (header-lead)
(defun allout-lead-with-comment-string (&optional header-lead)
"*Set the topic-header leading string to specified string.
Useful when for encapsulating outline structure in programming
language comments. Returns the leading string."
(interactive "P")
(if (not (stringp header-lead))
(setq header-lead (read-string
"String prefix for topic headers: ")))
(setq allout-reindent-bodies nil)
(allout-reset-header-lead header-lead)
;;;_ > allout-infer-header-lead ()
(defun allout-infer-header-lead ()
"Determine appropriate `allout-header-prefix'.
Works according to settings of:
`allout-header-prefix' (default)
and `allout-mode-leaders'.
Apply this via \(re)activation of `allout-mode', rather than
invoking it directly."
(let* ((use-leader (and (boundp 'allout-use-mode-specific-leader)
(if (or (stringp allout-use-mode-specific-leader)
(memq allout-use-mode-specific-leader
;; Oops - garbled value, equate with effect of 't:
((not use-leader) nil)
;; Use the explicitly designated leader:
((stringp use-leader) use-leader)
(t (or (and (memq use-leader '(t allout-mode-leaders))
;; Get it from outline mode leaders?
(cdr (assq major-mode allout-mode-leaders)))
;; ... didn't get from allout-mode-leaders...
(and (memq use-leader '(t comment-start))
;; Use comment-start, maybe tripled, and with
;; underscore:
(if (string= " "
(substring comment-start
(1- (length comment-start))))
;; Use comment-start, sans trailing space:
(substring comment-start 0 -1)
(concat comment-start comment-start comment-start))
;; ... and append underscore, whichever:
(if (not leader)
(if (string= leader allout-header-prefix)
nil ; no change, nothing to do.
(setq allout-header-prefix leader)
;;;_ > allout-infer-body-reindent ()
(defun allout-infer-body-reindent ()
"Determine proper setting for `allout-reindent-bodies'.
Depends on default setting of `allout-reindent-bodies' \(which see)
and presence of setting for `comment-start', to tell whether the
file is programming code."
(if (and allout-reindent-bodies
(not (eq 'force allout-reindent-bodies)))
(setq allout-reindent-bodies nil)))
;;;_ > set-allout-regexp ()
(defun set-allout-regexp ()
"Generate proper topic-header regexp form for outline functions.
Works with respect to `allout-plain-bullets-string' and
;; Derive allout-bullets-string from user configured components:
(setq allout-bullets-string "")
(let ((strings (list 'allout-plain-bullets-string
(while strings
(setq index 0)
(setq cur-len (length (setq cur-string (symbol-value (car strings)))))
(while (< index cur-len)
(setq cur-char (aref cur-string index))
(setq allout-bullets-string
(concat allout-bullets-string
; Single dash would denote a
; sequence, repeated denotes
; a dash:
((eq cur-char ?-) "--")
; literal close-square-bracket
; doesn't work right in the
; expr, exclude it:
((eq cur-char ?\]) "")
(t (regexp-quote (char-to-string cur-char))))))
(setq index (1+ index)))
(setq strings (cdr strings)))
;; Derive next for repeated use in allout-pending-bullet:
(setq allout-plain-bullets-string-len (length allout-plain-bullets-string))
(setq allout-header-subtraction (1- (length allout-header-prefix)))
;; Produce the new allout-regexp:
(setq allout-regexp (concat "\\(\\"
"[ \t]*["
(setq allout-line-boundary-regexp
(concat "\\(\n\\)\\(" allout-regexp "\\)"))
(setq allout-bob-regexp
(concat "\\(\\`\\)\\(" allout-regexp "\\)"))
;;;_ : Key bindings
;;;_ = allout-mode-map
(defvar allout-mode-map nil "Keybindings for (allout) outline minor mode.")
;;;_ > produce-allout-mode-map (keymap-alist &optional base-map)
(defun produce-allout-mode-map (keymap-list &optional base-map)
"Produce keymap for use as allout-mode-map, from KEYMAP-LIST.
Built on top of optional BASE-MAP, or empty sparse map if none specified.
See doc string for allout-keybindings-list for format of binding list."
(let ((map (or base-map (make-sparse-keymap)))
(pref (list allout-command-prefix)))
(mapcar (function
(lambda (cell)
(let ((add-pref (null (cdr (cdr cell))))
(key-suff (list (car cell))))
(apply 'define-key
(list map
(apply 'concat (if add-pref
(append pref key-suff)
(car (cdr cell)))))))
;;;_ = allout-prior-bindings - being deprecated.
(defvar allout-prior-bindings nil
"Variable for use in V18, with allout-added-bindings, for
resurrecting, on mode deactivation, bindings that existed before
activation. Being deprecated.")
;;;_ = allout-added-bindings - being deprecated
(defvar allout-added-bindings nil
"Variable for use in V18, with allout-prior-bindings, for
resurrecting, on mode deactivation, bindings that existed before
activation. Being deprecated.")
;;;_ : Menu bar
(defvar allout-mode-exposure-menu)
(defvar allout-mode-editing-menu)
(defvar allout-mode-navigation-menu)
(defvar allout-mode-misc-menu)
(defun produce-allout-mode-menubar-entries ()
(require 'easymenu)
(easy-menu-define allout-mode-exposure-menu
"Allout outline exposure menu."
["Show Entry" allout-show-current-entry t]
["Show Children" allout-show-children t]
["Show Subtree" allout-show-current-subtree t]
["Hide Subtree" allout-hide-current-subtree t]
["Hide Leaves" allout-hide-current-leaves t]
["Show All" allout-show-all t]))
(easy-menu-define allout-mode-editing-menu
"Allout outline editing menu."
["Open Sibling" allout-open-sibtopic t]
["Open Subtopic" allout-open-subtopic t]
["Open Supertopic" allout-open-supertopic t]
["Shift Topic In" allout-shift-in t]
["Shift Topic Out" allout-shift-out t]
["Rebullet Topic" allout-rebullet-topic t]
["Rebullet Heading" allout-rebullet-current-heading t]
["Number Siblings" allout-number-siblings t]
["Toggle Topic Encryption"
(> (allout-current-depth) 1)]))
(easy-menu-define allout-mode-navigation-menu
"Allout outline navigation menu."
["Next Visible Heading" allout-next-visible-heading t]
["Previous Visible Heading"
allout-previous-visible-heading t]
["Up Level" allout-up-current-level t]
["Forward Current Level" allout-forward-current-level t]
["Backward Current Level"
allout-backward-current-level t]
["Beginning of Entry"
allout-beginning-of-current-entry t]
["End of Entry" allout-end-of-entry t]
["End of Subtree" allout-end-of-current-subtree t]))
(easy-menu-define allout-mode-misc-menu
"Allout outlines miscellaneous bindings."
["Version" allout-version t]
["Duplicate Exposed" allout-copy-exposed-to-buffer t]
["Duplicate Exposed, numbered"
allout-flatten-exposed-to-buffer t]
["Duplicate Exposed, indented"
allout-indented-exposed-to-buffer t]
["Set Header Lead" allout-reset-header-lead t]
["Set New Exposure" allout-expose-topic t])))
;;;_ : Mode-Specific Variable Maintenance Utilities
;;;_ = allout-mode-prior-settings
(defvar allout-mode-prior-settings nil
"Internal `allout-mode' use; settings to be resumed on mode deactivation.")
(make-variable-buffer-local 'allout-mode-prior-settings)
;;;_ > allout-resumptions (name &optional value)
(defun allout-resumptions (name &optional value)
"Registers or resumes settings over `allout-mode' activation/deactivation.
First arg is NAME of variable affected. Optional second arg is list
containing allout-mode-specific VALUE to be imposed on named
variable, and to be registered. \(It's a list so you can specify
registrations of null values.) If no value is specified, the
registered value is returned (encapsulated in the list, so the caller
can distinguish nil vs no value), and the registration is popped
from the list."
(let ((on-list (assq name allout-mode-prior-settings))
prior-capsule ; By `capsule' i mean a list
; containing a value, so we can
; distinguish nil from no value.
(if value
;; Registering:
(if on-list
nil ; Already preserved prior value - don't mess with it.
;; Register the old value, or nil if previously unbound:
(setq allout-mode-prior-settings
(cons (list name
(if (boundp name) (list (symbol-value name))))
; And impose the new value, locally:
(progn (make-local-variable name)
(set name (car value))))
;; Relinquishing:
(if (not on-list)
;; Oops, not registered - leave it be:
;; Some registration:
; reestablish it:
(setq prior-capsule (car (cdr on-list)))
(if prior-capsule
(set name (car prior-capsule)) ; Some prior value - reestablish it.
(makunbound name)) ; Previously unbound - demolish var.
; Remove registration:
(let (rebuild)
(while allout-mode-prior-settings
(if (not (eq (car allout-mode-prior-settings)
(setq rebuild
(cons (car allout-mode-prior-settings)
(setq allout-mode-prior-settings
(cdr allout-mode-prior-settings)))
(setq allout-mode-prior-settings rebuild)))))
;;;_ : Mode-specific incidentals
;;;_ > allout-unprotected (expr)
(defmacro allout-unprotected (expr)
"Enable internal outline operations to alter invisible text."
`(let ((inhibit-read-only t))
;;;_ = allout-mode-hook
(defvar allout-mode-hook nil
"*Hook that's run when allout mode starts.")
;;;_ = allout-overlay-category
(defvar allout-overlay-category nil
"Symbol for use in allout invisible-text overlays as the category.")
;;;_ x allout-view-change-hook
(defvar allout-view-change-hook nil
"*\(Deprecated\) Hook that's run after allout outline exposure changes.
Switch to using `allout-exposure-change-hook' instead. Both
variables are currently respected, but this one will be ignored
in a subsequent allout version.")
;;;_ = allout-exposure-change-hook
(defvar allout-exposure-change-hook nil
"*Hook that's run after allout outline exposure changes.
This variable will replace `allout-view-change-hook' in a subsequent allout
version, though both are currently respected.")
;;;_ = allout-outside-normal-auto-fill-function
(defvar allout-outside-normal-auto-fill-function nil
"Value of normal-auto-fill-function outside of allout mode.
Used by allout-auto-fill to do the mandated normal-auto-fill-function
wrapped within allout's automatic fill-prefix setting.")
(make-variable-buffer-local 'allout-outside-normal-auto-fill-function)
;;;_ = file-var-bug hack
(defvar allout-v18/19-file-var-hack nil
"Horrible hack used to prevent invalid multiple triggering of outline
mode from prop-line file-var activation. Used by `allout-mode' function
to track repeats.")
;;;_ = allout-passphrase-verifier-string
(defvar allout-passphrase-verifier-string nil
"Setting used to test solicited encryption passphrases against the one
already associated with a file.
It consists of an encrypted random string useful only to verify that a
passphrase entered by the user is effective for decryption. The passphrase
itself is \*not* recorded in the file anywhere, and the encrypted contents
are random binary characters to avoid exposing greater susceptibility to
search attacks.
The verifier string is retained as an Emacs file variable, as well as in
the emacs buffer state, if file variable adjustments are enabled. See
`allout-enable-file-variable-adjustment' for details about that.")
(make-variable-buffer-local 'allout-passphrase-verifier-string)
(put 'allout-passphrase-verifier-string 'safe-local-variable 'stringp)
;;;_ = allout-passphrase-hint-string
(defvar allout-passphrase-hint-string ""
"Variable used to retain reminder string for file's encryption passphrase.
See the description of `allout-passphrase-hint-handling' for details about how
the reminder is deployed.
The hint is retained as an Emacs file variable, as well as in the emacs buffer
state, if file variable adjustments are enabled. See
`allout-enable-file-variable-adjustment' for details about that.")
(make-variable-buffer-local 'allout-passphrase-hint-string)
(setq-default allout-passphrase-hint-string "")
(put 'allout-passphrase-hint-string 'safe-local-variable 'stringp)
;;;_ = allout-after-save-decrypt
(defvar allout-after-save-decrypt nil
"Internal variable, is nil or has the value of two points:
- the location of a topic to be decrypted after saving is done
- where to situate the cursor after the decryption is performed
This is used to decrypt the topic that was currently being edited, if it
was encrypted automatically as part of a file write or autosave.")
(make-variable-buffer-local 'allout-after-save-decrypt)
;;;_ > allout-mode-p ()
;; Must define this macro above any uses, or byte compilation will lack
;; proper def, if file isn't loaded - eg, during emacs build!
(defmacro allout-mode-p ()
"Return t if `allout-mode' is active in current buffer."
;;;_ > allout-write-file-hook-handler ()
(defun allout-write-file-hook-handler ()
"Implement `allout-encrypt-unencrypted-on-saves' policy for file writes."
(if (or (not (allout-mode-p))
(not (boundp 'allout-encrypt-unencrypted-on-saves))
(not allout-encrypt-unencrypted-on-saves))
(let ((except-mark (and (equal allout-encrypt-unencrypted-on-saves
(if (save-excursion (goto-char (point-min))
(allout-next-topic-pending-encryption except-mark))
(message "auto-encrypting pending topics")
(sit-for 0)
(condition-case failure
(setq allout-after-save-decrypt
(allout-encrypt-decrypted except-mark))
(error (progn
"allout-write-file-hook-handler suppressing error %s"
(sit-for 2))))))
;;;_ > allout-auto-save-hook-handler ()
(defun allout-auto-save-hook-handler ()
"Implement `allout-encrypt-unencrypted-on-saves' policy for auto save."
(if (and (allout-mode-p) allout-encrypt-unencrypted-on-saves)
;; Always implement 'except-current policy when enabled.
(let ((allout-encrypt-unencrypted-on-saves 'except-current))
;;;_ > allout-after-saves-handler ()
(defun allout-after-saves-handler ()
"Decrypt topic encrypted for save, if it's currently being edited.
Ie, if it was pending encryption and contained the point in its body before
the save.
We use values stored in `allout-after-save-decrypt' to locate the topic
and the place for the cursor after the decryption is done."
(if (not (and (allout-mode-p)
(boundp 'allout-after-save-decrypt)
(goto-char (car allout-after-save-decrypt))
(let ((was-modified (buffer-modified-p)))
(if (not was-modified)
(set-buffer-modified-p nil)))
(goto-char (cadr allout-after-save-decrypt))
(setq allout-after-save-decrypt nil))
;;;_ #2 Mode activation
;;;_ = allout-explicitly-deactivated
(defvar allout-explicitly-deactivated nil
"If t, `allout-mode's last deactivation was deliberate.
So `allout-post-command-business' should not reactivate it...")
(make-variable-buffer-local 'allout-explicitly-deactivated)
;;;_ > allout-init (&optional mode)
(defun allout-init (&optional mode)
"Prime `allout-mode' to enable/disable auto-activation, wrt `allout-layout'.
MODE is one of the following symbols:
- nil \(or no argument) deactivate auto-activation/layout;
- `activate', enable auto-activation only;
- `ask', enable auto-activation, and enable auto-layout but with
confirmation for layout operation solicited from user each time;
- `report', just report and return the current auto-activation state;
- anything else \(eg, t) for auto-activation and auto-layout, without
any confirmation check.
Use this function to setup your Emacs session for automatic activation
of allout outline mode, contingent to the buffer-specific setting of
the `allout-layout' variable. (See `allout-layout' and
`allout-expose-topic' docstrings for more details on auto layout).
`allout-init' works by setting up (or removing) the `allout-mode'
find-file-hook, and giving `allout-auto-activation' a suitable
To prime your Emacs session for full auto-outline operation, include
the following two lines in your Emacs init file:
\(require 'allout)
\(allout-init t)"
(if (interactive-p)
(setq mode
(concat "Select outline auto setup mode "
"(empty for report, ? for options) ")
("ask") ("report") (""))
(if (string= mode "")
(setq mode 'report)
(setq mode (intern-soft mode)))))
;; convenience aliases, for consistent ref to respective vars:
((hook 'allout-find-file-hook)
(find-file-hook-var-name (if (boundp 'find-file-hook)
(curr-mode 'allout-auto-activation))
(cond ((not mode)
(set find-file-hook-var-name
(delq hook (symbol-value find-file-hook-var-name)))
(if (interactive-p)
(message "Allout outline mode auto-activation inhibited.")))
((eq mode 'report)
(if (not (memq hook (symbol-value find-file-hook-var-name)))
(allout-init nil)
;; Just punt and use the reports from each of the modes:
(allout-init (symbol-value curr-mode))))
(t (add-hook find-file-hook-var-name hook)
(set curr-mode ; `set', not `setq'!
(cond ((eq mode 'activate)
"Outline mode auto-activation enabled.")
((eq mode 'report)
;; Return the current mode setting:
(allout-init mode))
((eq mode 'ask)
(concat "Outline mode auto-activation and "
"-layout \(upon confirmation) enabled."))
"Outline mode auto-activation and -layout enabled.")
;;;_ > allout-setup-menubar ()
(defun allout-setup-menubar ()
"Populate the current buffer's menubar with `allout-mode' stuff."
(let ((menus (list allout-mode-exposure-menu
(while menus
(setq cur (car menus)
menus (cdr menus))
(easy-menu-add cur))))
;;;_ > allout-set-overlay-category
(defun allout-set-overlay-category ()
"Set the properties of the allout invisible-text overlay."
(setplist 'allout-overlay-category nil)
(put 'allout-overlay-category 'invisible 'allout)
(put 'allout-overlay-category 'evaporate t)
;; XXX We use isearch-open-invisible *and* isearch-mode-end-hook. The
;; latter would be sufficient, but it seems that a separate behavior -
;; the _transient_ opening of invisible text during isearch - is keyed to
;; presence of the isearch-open-invisible property - even though this
;; property controls the isearch _arrival_ behavior. This is the case at
;; least in emacs 21, 22.0, and xemacs 21.4.
(put 'allout-overlay-category 'isearch-open-invisible
(if (featurep 'xemacs)
(put 'allout-overlay-category 'start-open t)
(put 'allout-overlay-category 'insert-in-front-hooks
(if (featurep 'xemacs)
(progn (make-variable-buffer-local 'before-change-functions)
(add-hook 'before-change-functions
(put 'allout-overlay-category 'modification-hooks
;;;_ > allout-mode (&optional toggle)
;;;_ : Defun:
(defun allout-mode (&optional toggle)
;;;_ . Doc string:
"Toggle minor mode for controlling exposure and editing of text outlines.
Optional arg forces mode to re-initialize iff arg is positive num or
symbol. Allout outline mode always runs as a minor mode.
Allout outline mode provides extensive outline oriented formatting and
manipulation. It enables structural editing of outlines, as well as
navigation and exposure. It also is specifically aimed at
accommodating syntax-sensitive text like programming languages. \(For
an example, see the allout code itself, which is organized as an allout
In addition to outline navigation and exposure, allout includes:
- topic-oriented repositioning, promotion/demotion, cut, and paste
- integral outline exposure-layout
- incremental search with dynamic exposure and reconcealment of hidden text
- automatic topic-number maintenance
- easy topic encryption and decryption
- \"Hot-spot\" operation, for single-keystroke maneuvering and
exposure control. \(See the allout-mode docstring.)
and many other features.
Below is a description of the bindings, and then explanation of
special `allout-mode' features and terminology. See also the outline
menubar additions for quick reference to many of the features, and see
the docstring of the function `allout-init' for instructions on
priming your emacs session for automatic activation of `allout-mode'.
The bindings are dictated by the `allout-keybindings-list' and
`allout-command-prefix' variables.
Navigation: Exposure Control:
---------- ----------------
\\[allout-next-visible-heading] allout-next-visible-heading | \\[allout-hide-current-subtree] allout-hide-current-subtree
\\[allout-previous-visible-heading] allout-previous-visible-heading | \\[allout-show-children] allout-show-children
\\[allout-up-current-level] allout-up-current-level | \\[allout-show-current-subtree] allout-show-current-subtree
\\[allout-forward-current-level] allout-forward-current-level | \\[allout-show-current-entry] allout-show-current-entry
\\[allout-backward-current-level] allout-backward-current-level | \\[allout-show-all] allout-show-all
\\[allout-end-of-entry] allout-end-of-entry
\\[allout-beginning-of-current-entry] allout-beginning-of-current-entry, alternately, goes to hot-spot
Topic Header Production:
\\[allout-open-sibtopic] allout-open-sibtopic Create a new sibling after current topic.
\\[allout-open-subtopic] allout-open-subtopic ... an offspring of current topic.
\\[allout-open-supertopic] allout-open-supertopic ... a sibling of the current topic's parent.
Topic Level and Prefix Adjustment:
\\[allout-shift-in] allout-shift-in Shift current topic and all offspring deeper.
\\[allout-shift-out] allout-shift-out ... less deep.
\\[allout-rebullet-current-heading] allout-rebullet-current-heading Prompt for alternate bullet for
current topic.
\\[allout-rebullet-topic] allout-rebullet-topic Reconcile bullets of topic and its offspring
- distinctive bullets are not changed, others
alternated according to nesting depth.
\\[allout-number-siblings] allout-number-siblings Number bullets of topic and siblings - the
offspring are not affected. With repeat
count, revoke numbering.
Topic-oriented Killing and Yanking:
\\[allout-kill-topic] allout-kill-topic Kill current topic, including offspring.
\\[allout-kill-line] allout-kill-line Like kill-line, but reconciles numbering, etc.
\\[allout-yank] allout-yank Yank, adjusting depth of yanked topic to
depth of heading if yanking into bare topic
heading (ie, prefix sans text).
\\[allout-yank-pop] allout-yank-pop Is to allout-yank as yank-pop is to yank
Topic-oriented Encryption:
\\[allout-toggle-current-subtree-encryption] allout-toggle-current-subtree-encryption Encrypt/Decrypt topic content
Misc commands:
M-x outlineify-sticky Activate outline mode for current buffer,
and establish a default file-var setting
for `allout-layout'.
\\[allout-mark-topic] allout-mark-topic
\\[allout-copy-exposed-to-buffer] allout-copy-exposed-to-buffer
Duplicate outline, sans concealed text, to
buffer with name derived from derived from that
of current buffer - \"*BUFFERNAME exposed*\".
\\[allout-flatten-exposed-to-buffer] allout-flatten-exposed-to-buffer
Like above 'copy-exposed', but convert topic
prefixes to section.subsection... numeric
\\[eval-expression] (allout-init t) Setup Emacs session for outline mode
Topic Encryption
Outline mode supports gpg encryption of topics, with support for
symmetric and key-pair modes, passphrase timeout, passphrase
consistency checking, user-provided hinting for symmetric key
mode, and auto-encryption of topics pending encryption on save.
\(Topics pending encryption are, by default, automatically
encrypted during file saves; if you're editing the contents of
such a topic, it is automatically decrypted for continued
editing.) The aim is reliable topic privacy while preventing
accidents like neglected encryption before saves, forgetting
which passphrase was used, and other practical pitfalls.
See `allout-toggle-current-subtree-encryption' function docstring and
`allout-encrypt-unencrypted-on-saves' customization variable for details.
HOT-SPOT Operation
Hot-spot operation provides a means for easy, single-keystroke outline
navigation and exposure control.
When the text cursor is positioned directly on the bullet character of
a topic, regular characters (a to z) invoke the commands of the
corresponding allout-mode keymap control chars. For example, \"f\"
would invoke the command typically bound to \"C-c<space>C-f\"
\(\\[allout-forward-current-level] `allout-forward-current-level').
Thus, by positioning the cursor on a topic bullet, you can
execute the outline navigation and manipulation commands with a
single keystroke. Regular navigation keys (eg, \\[forward-char], \\[next-line]) never get
this special translation, so you can use them to get out of the
hot-spot and back to normal operation.
Note that the command `allout-beginning-of-current-entry' \(\\[allout-beginning-of-current-entry]\)
will move to the hot-spot when the cursor is already located at the
beginning of the current entry, so you usually can hit \\[allout-beginning-of-current-entry]
twice in a row to get to the hot-spot.
Topic hierarchy constituents - TOPICS and SUBTOPICS:
TOPIC: A basic, coherent component of an Emacs outline. It can
contain and be contained by other topics.
CURRENT topic:
The visible topic most immediately containing the cursor.
DEPTH: The degree of nesting of a topic; it increases with
containment. Also called the:
LEVEL: The same as DEPTH.
The topics that contain a topic.
PARENT: A topic's immediate ancestor. It has a depth one less than
the topic.
The topics contained by a topic;
An immediate offspring of a topic;
The immediate offspring of a topic.
Topics having the same parent and depth.
Topic text constituents:
HEADER: The first line of a topic, include the topic PREFIX and header
PREFIX: The leading text of a topic which distinguishes it from normal
text. It has a strict form, which consists of a prefix-lead
string, padding, and a bullet. The bullet may be followed by a
number, indicating the ordinal number of the topic among its
siblings, a space, and then the header text.
The relative length of the PREFIX determines the nesting depth
of the topic.
The string at the beginning of a topic prefix, normally a `.'.
It can be customized by changing the setting of
`allout-header-prefix' and then reinitializing `allout-mode'.
By setting the prefix-lead to the comment-string of a
programming language, you can embed outline structuring in
program code without interfering with the language processing
of that code. See `allout-use-mode-specific-leader'
docstring for more detail.
Spaces or asterisks which separate the prefix-lead and the
bullet, determining the depth of the topic.
BULLET: A character at the end of the topic prefix, it must be one of
the characters listed on `allout-plain-bullets-string' or
`allout-distinctive-bullets-string'. (See the documentation
for these variables for more details.) The default choice of
bullet when generating topics varies in a cycle with the depth of
the topic.
ENTRY: The text contained in a topic before any offspring.
BODY: Same as ENTRY.
The state of a topic which determines the on-screen visibility
of its offspring and contained text.
Topics and entry text whose display is inhibited. Contiguous
units of concealed text is represented by `...' ellipses.
Concealed topics are effectively collapsed within an ancestor.
CLOSED: A topic whose immediate offspring and body-text is concealed.
OPEN: A topic that is not closed, though its offspring or body may be."
;;;_ . Code
(interactive "P")
(let* ((active (and (not (equal major-mode 'outline))
; Massage universal-arg `toggle' val:
(toggle (and toggle
(or (and (listp toggle)(car toggle))
; Activation specifically demanded?
(explicit-activation (and toggle
(or (symbolp toggle)
(and (wholenump toggle)
(not (zerop toggle))))))
;; allout-mode already called once during this complex command?
(same-complex-command (eq allout-v18/19-file-var-hack
(car command-history)))
(write-file-hook-var-name (cond ((boundp 'write-file-functions)
((boundp 'write-file-hooks)
(t 'local-write-file-hooks)))
; See comments below re v19.18,.19 bug.
(setq allout-v18/19-file-var-hack (car command-history))
;; Provision for v19.18, 19.19 bug -
;; Emacs v 19.18, 19.19 file-var code invokes prop-line-designated
;; modes twice when file is visited. We have to avoid toggling mode
;; off on second invocation, so we detect it as best we can, and
;; skip everything.
((and same-complex-command ; Still in same complex command
; as last time `allout-mode' invoked.
active ; Already activated.
(not explicit-activation) ; Prop-line file-vars don't have args.
(string-match "^19.1[89]" ; Bug only known to be in v19.18 and
emacs-version)); 19.19.
;; Deactivation:
((and (not explicit-activation)
(or active toggle))
; Activation not explicitly
; requested, and either in
; active state or *de*activation
; specifically requested:
(setq allout-explicitly-deactivated t)
(if (string-match "^18\." emacs-version)
; Revoke those keys that remain
; as we set them:
(let ((curr-loc (current-local-map)))
(mapcar (function
(lambda (cell)
(if (eq (lookup-key curr-loc (car cell))
(car (cdr cell)))
(define-key curr-loc (car cell)
(assq (car cell) allout-prior-bindings)))))
(allout-resumptions 'allout-added-bindings)
(allout-resumptions 'allout-prior-bindings)))
(if allout-old-style-prefixes
(allout-resumptions 'allout-primary-bullet)
(allout-resumptions 'allout-old-style-prefixes)))
;;(allout-resumptions 'selective-display)
(remove-from-invisibility-spec '(allout . t))
(set write-file-hook-var-name
(delq 'allout-write-file-hook-handler
(symbol-value write-file-hook-var-name)))
(setq auto-save-hook
(delq 'allout-auto-save-hook-handler
(allout-resumptions 'paragraph-start)
(allout-resumptions 'paragraph-separate)
(allout-resumptions 'auto-fill-function)
(allout-resumptions 'normal-auto-fill-function)
(allout-resumptions 'allout-former-auto-filler)
(setq allout-mode nil))
;; Activation:
((not active)
(setq allout-explicitly-deactivated nil)
(if allout-old-style-prefixes
(progn ; Inhibit all the fancy formatting:
(allout-resumptions 'allout-primary-bullet '("*"))
(allout-resumptions 'allout-old-style-prefixes '(()))))
(allout-set-overlay-category) ; Doesn't hurt to redo this.
; Produce map from current version
; of allout-keybindings-list:
(if (boundp 'minor-mode-map-alist)
(progn ; V19, and maybe lucid and
; epoch, minor-mode key bindings:
(setq allout-mode-map
(produce-allout-mode-map allout-keybindings-list))
(substitute-key-definition 'beginning-of-line
allout-mode-map global-map)
(substitute-key-definition 'end-of-line
allout-mode-map global-map)
(fset 'allout-mode-map allout-mode-map)
; Include on minor-mode-map-alist,
; if not already there:
(if (not (member '(allout-mode . allout-mode-map)
(setq minor-mode-map-alist
(cons '(allout-mode . allout-mode-map)
; V18 minor-mode key bindings:
; Stash record of added bindings
; for later revocation:
(allout-resumptions 'allout-added-bindings
(list allout-keybindings-list))
(allout-resumptions 'allout-prior-bindings
(list (current-local-map)))
; and add them:
(use-local-map (produce-allout-mode-map allout-keybindings-list
(add-to-invisibility-spec '(allout . t))
(make-local-variable 'line-move-ignore-invisible)
(setq line-move-ignore-invisible t)
(add-hook 'pre-command-hook 'allout-pre-command-business)
(add-hook 'post-command-hook 'allout-post-command-business)
(add-hook 'isearch-mode-end-hook 'allout-isearch-end-handler)
(add-hook write-file-hook-var-name 'allout-write-file-hook-handler)
(add-hook 'auto-save-hook 'allout-auto-save-hook-handler)
; Custom auto-fill func, to support
; respect for topic headline,
; hanging-indents, etc:
;; Register prevailing fill func for use by allout-auto-fill:
(allout-resumptions 'allout-former-auto-filler (list auto-fill-function))
;; Register allout-auto-fill to be used if filling is active:
(allout-resumptions 'auto-fill-function '(allout-auto-fill))
(allout-resumptions 'allout-outside-normal-auto-fill-function
(list normal-auto-fill-function))
(allout-resumptions 'normal-auto-fill-function '(allout-auto-fill))
;; Paragraphs are broken by topic headlines.
(make-local-variable 'paragraph-start)
(allout-resumptions 'paragraph-start
(list (concat paragraph-start "\\|^\\("
allout-regexp "\\)")))
(make-local-variable 'paragraph-separate)
(allout-resumptions 'paragraph-separate
(list (concat paragraph-separate "\\|^\\("
allout-regexp "\\)")))
(or (assq 'allout-mode minor-mode-alist)
(setq minor-mode-alist
(cons '(allout-mode " Allout") minor-mode-alist)))
(if allout-layout
(setq do-layout t))
(run-hooks 'allout-mode-hook)
(setq allout-mode t))
;; Reactivation:
((setq do-layout t)
) ; cond
(let ((use-layout (if (listp allout-layout)
(if (and do-layout
(and (not (eq allout-auto-activation 'activate))
(if (eq allout-auto-activation 'ask)
(if (y-or-n-p (format "Expose %s with layout '%s'? "
(message "Skipped %s layout." (buffer-name))
(message "Adjusting '%s' exposure..." (buffer-name))
(goto-char 0)
(condition-case err
(apply 'allout-expose-topic (list use-layout))
(message "Adjusting '%s' exposure... done." (buffer-name)))
;; Problem applying exposure - notify user, but don't
;; interrupt, eg, file visit:
(error (message "%s" (car (cdr err)))
(sit-for 1))))))
) ; let*
) ; defun
;;;_ > allout-minor-mode
(defalias 'allout-minor-mode 'allout-mode)
;;;_ - Position Assessment
;;;_ > allout-hidden-p (&optional pos)
(defsubst allout-hidden-p (&optional pos)
"Non-nil if the character after point is invisible."
(eq (get-char-property (or pos (point)) 'invisible) 'allout))
;;;_ > allout-overlay-insert-in-front-handler (ol after beg end
;;; &optional prelen)
(defun allout-overlay-insert-in-front-handler (ol after beg end
&optional prelen)
"Shift the overlay so stuff inserted in front of it are excluded."
(if after
(move-overlay ol (1+ beg) (overlay-end ol))))
;;;_ > allout-overlay-interior-modification-handler (ol after beg end
;;; &optional prelen)
(defun allout-overlay-interior-modification-handler (ol after beg end
&optional prelen)
"Get confirmation before making arbitrary changes to invisible text.
We expose the invisible text and ask for confirmation. Refusal or
keyboard-quit abandons the changes, with keyboard-quit additionally
reclosing the opened text.
No confirmation is necessary when inhibit-read-only is set - eg, allout
internal functions use this feature cohesively bunch changes."
(when (and (not inhibit-read-only) (not after))
(let ((start (point))
(ol-start (overlay-start ol))
(ol-end (overlay-end ol))
(goto-char beg)
(while (< (point) end)
(when (allout-hidden-p)
(if (allout-hidden-p)
(save-excursion (forward-char 1)
(when (not first)
(setq first (point))))
(goto-char (if (featurep 'xemacs)
(next-property-change (1+ (point)) nil end)
(next-char-property-change (1+ (point)) end))))
(when first
(goto-char first)
(condition-case nil
(if (not
(concat "Modify concealed text? (\"no\" just aborts,"
" \\[keyboard-quit] also reconceals) "))))
(progn (goto-char start)
(error "Concealed-text change refused.")))
(quit (allout-flag-region ol-start ol-end nil)
(allout-flag-region ol-start ol-end t)
(error "Concealed-text change abandoned, text reconcealed."))))
(goto-char start))))
;;;_ > allout-before-change-handler (beg end)
(defun allout-before-change-handler (beg end)
"Protect against changes to invisible text.
See allout-overlay-interior-modification-handler for details.
This before-change handler is used only where modification-hooks
overlay property is not supported."
(if (not (allout-mode-p))
(allout-overlay-interior-modification-handler nil nil beg end nil)))
;;;_ > allout-isearch-end-handler (&optional overlay)
(defun allout-isearch-end-handler (&optional overlay)
"Reconcile allout outline exposure on arriving in hidden text after isearch.
Optional OVERLAY parameter is for when this function is used by
`isearch-open-invisible' overlay property. It is otherwise unused, so this
function can also be used as an `isearch-mode-end-hook'."
(if (and (allout-mode-p) (allout-hidden-p))
;;;_ #3 Internal Position State-Tracking - "allout-recent-*" funcs
;;; All the basic outline functions that directly do string matches to
;;; evaluate heading prefix location set the variables
;;; `allout-recent-prefix-beginning' and `allout-recent-prefix-end'
;;; when successful. Functions starting with `allout-recent-' all
;;; use this state, providing the means to avoid redundant searches
;;; for just-established data. This optimization can provide
;;; significant speed improvement, but it must be employed carefully.
;;;_ = allout-recent-prefix-beginning
(defvar allout-recent-prefix-beginning 0
"Buffer point of the start of the last topic prefix encountered.")
(make-variable-buffer-local 'allout-recent-prefix-beginning)
;;;_ = allout-recent-prefix-end
(defvar allout-recent-prefix-end 0
"Buffer point of the end of the last topic prefix encountered.")
(make-variable-buffer-local 'allout-recent-prefix-end)
;;;_ = allout-recent-end-of-subtree
(defvar allout-recent-end-of-subtree 0
"Buffer point last returned by `allout-end-of-current-subtree'.")
(make-variable-buffer-local 'allout-recent-end-of-subtree)
;;;_ > allout-prefix-data (beg end)
(defmacro allout-prefix-data (beg end)
"Register allout-prefix state data - BEGINNING and END of prefix.
For reference by `allout-recent' funcs. Returns BEGINNING."
`(setq allout-recent-prefix-end ,end
allout-recent-prefix-beginning ,beg))
;;;_ > allout-recent-depth ()
(defmacro allout-recent-depth ()
"Return depth of last heading encountered by an outline maneuvering function.
All outline functions which directly do string matches to assess
headings set the variables `allout-recent-prefix-beginning' and
`allout-recent-prefix-end' if successful. This function uses those settings
to return the current depth."
'(max 1 (- allout-recent-prefix-end
;;;_ > allout-recent-prefix ()
(defmacro allout-recent-prefix ()
"Like `allout-recent-depth', but returns text of last encountered prefix.
All outline functions which directly do string matches to assess
headings set the variables `allout-recent-prefix-beginning' and
`allout-recent-prefix-end' if successful. This function uses those settings
to return the current depth."
'(buffer-substring allout-recent-prefix-beginning
;;;_ > allout-recent-bullet ()
(defmacro allout-recent-bullet ()
"Like allout-recent-prefix, but returns bullet of last encountered prefix.
All outline functions which directly do string matches to assess
headings set the variables `allout-recent-prefix-beginning' and
`allout-recent-prefix-end' if successful. This function uses those settings
to return the current depth of the most recently matched topic."
'(buffer-substring (1- allout-recent-prefix-end)
;;;_ #4 Navigation
;;;_ - Position Assessment
;;;_ : Location Predicates
;;;_ > allout-on-current-heading-p ()
(defun allout-on-current-heading-p ()
"Return non-nil if point is on current visible topics' header line.
Actually, returns prefix beginning point."
(and (looking-at allout-regexp)
(allout-prefix-data (match-beginning 0) (match-end 0)))))
;;;_ > allout-on-heading-p ()
(defalias 'allout-on-heading-p 'allout-on-current-heading-p)
;;;_ > allout-e-o-prefix-p ()
(defun allout-e-o-prefix-p ()
"True if point is located where current topic prefix ends, heading begins."
(and (save-excursion (beginning-of-line)
(looking-at allout-regexp))
(= (point)(save-excursion (allout-end-of-prefix)(point)))))
;;;_ : Location attributes
;;;_ > allout-depth ()
(defun allout-depth ()
"Return depth of topic most immediately containing point.
Return zero if point is not within any topic.
Like `allout-current-depth', but respects hidden as well as visible topics."
(let ((start-point (point)))
(if (and (allout-goto-prefix)
(not (< start-point (point))))
;; Oops, no prefix, zero prefix data:
(allout-prefix-data (point)(point))
;; ... and return 0:
;;;_ > allout-current-depth ()
(defun allout-current-depth ()
"Return depth of visible topic most immediately containing point.
Return zero if point is not within any topic."
(if (allout-back-to-current-heading)
(max 1
(- allout-recent-prefix-end
;;;_ > allout-get-current-prefix ()
(defun allout-get-current-prefix ()
"Topic prefix of the current topic."
(if (allout-goto-prefix)
;;;_ > allout-get-bullet ()
(defun allout-get-bullet ()
"Return bullet of containing topic (visible or not)."
(and (allout-goto-prefix)
;;;_ > allout-current-bullet ()
(defun allout-current-bullet ()
"Return bullet of current (visible) topic heading, or none if none found."
(condition-case nil
(buffer-substring (- allout-recent-prefix-end 1)
;; Quick and dirty provision, ostensibly for missing bullet:
('args-out-of-range nil))
;;;_ > allout-get-prefix-bullet (prefix)
(defun allout-get-prefix-bullet (prefix)
"Return the bullet of the header prefix string PREFIX."
;; Doesn't make sense if we're old-style prefixes, but this just
;; oughtn't be called then, so forget about it...
(if (string-match allout-regexp prefix)
(substring prefix (1- (match-end 0)) (match-end 0))))
;;;_ > allout-sibling-index (&optional depth)
(defun allout-sibling-index (&optional depth)
"Item number of this prospective topic among its siblings.
If optional arg DEPTH is greater than current depth, then we're
opening a new level, and return 0.
If less than this depth, ascend to that depth and count..."
(cond ((and depth (<= depth 0) 0))
((or (not depth) (= depth (allout-depth)))
(let ((index 1))
(while (allout-previous-sibling (allout-recent-depth) nil)
(setq index (1+ index)))
((< depth (allout-recent-depth))
(allout-ascend-to-depth depth)
;;;_ > allout-topic-flat-index ()
(defun allout-topic-flat-index ()
"Return a list indicating point's numeric section.subsect.subsubsect...
Outermost is first."
(let* ((depth (allout-depth))
(next-index (allout-sibling-index depth))
(rev-sibls nil))
(while (> next-index 0)
(setq rev-sibls (cons next-index rev-sibls))
(setq depth (1- depth))
(setq next-index (allout-sibling-index depth)))
;;;_ - Navigation routines
;;;_ > allout-beginning-of-current-line ()
(defun allout-beginning-of-current-line ()
"Like beginning of line, but to visible text."
;; XXX We would use `(move-beginning-of-line 1)', but it gets
;; stuck on some hidden newlines, eg at column 80, as of GNU Emacs 22.0.50.
;; Conversely, `beginning-of-line' can make no progress in other
;; situations. Both are necessary, in the order used below.
(move-beginning-of-line 1)
(while (or (not (bolp)) (allout-hidden-p))
(if (or (allout-hidden-p) (not (bolp)))
(forward-char -1))))
;;;_ > allout-end-of-current-line ()
(defun allout-end-of-current-line ()
"Move to the end of line, past concealed text if any."
;; XXX This is for symmetry with `allout-beginning-of-current-line' -
;; `move-end-of-line' doesn't suffer the same problem as
;; `move-beginning-of-line'.
(while (allout-hidden-p)
(if (allout-hidden-p) (forward-char 1))))
;;;_ > allout-next-heading ()
(defsubst allout-next-heading ()
"Move to the heading for the topic \(possibly invisible) before this one.
Returns the location of the heading, or nil if none found."
(if (and (bobp) (not (eobp)))
(forward-char 1))
(if (re-search-forward allout-line-boundary-regexp nil 0)
(allout-prefix-data ; Got valid location state - set vars:
(goto-char (or (match-beginning 2)
(or (match-end 2) allout-recent-prefix-end))))
;;;_ > allout-this-or-next-heading
(defun allout-this-or-next-heading ()
"Position cursor on current or next heading."
;; A throwaway non-macro that is defined after allout-next-heading
;; and usable by allout-mode.
(if (not (allout-goto-prefix)) (allout-next-heading)))
;;;_ > allout-previous-heading ()
(defmacro allout-previous-heading ()
"Move to the prior \(possibly invisible) heading line.
Return the location of the beginning of the heading, or nil if not found."
'(if (bobp)
;; searches are unbounded and return nil if failed:
(or (re-search-backward allout-line-boundary-regexp nil 0)
(looking-at allout-bob-regexp))
(progn ; Got valid location state - set vars:
(goto-char (or (match-beginning 2)
(or (match-end 2) allout-recent-prefix-end))))))
;;;_ > allout-get-invisibility-overlay ()
(defun allout-get-invisibility-overlay ()
"Return the overlay at point that dictates allout invisibility."
(let ((overlays (overlays-at (point)))
(while (and overlays (not got))
(if (equal (overlay-get (car overlays) 'invisible) 'allout)
(setq got (car overlays))))
;;;_ > allout-back-to-visible-text ()
(defun allout-back-to-visible-text ()
"Move to most recent prior character that is visible, and return point."
(if (allout-hidden-p)
(goto-char (overlay-start (allout-get-invisibility-overlay))))
;;;_ - Subtree Charting
;;;_ " These routines either produce or assess charts, which are
;;; nested lists of the locations of topics within a subtree.
;;; Use of charts enables efficient navigation of subtrees, by
;;; requiring only a single regexp-search based traversal, to scope
;;; out the subtopic locations. The chart then serves as the basis
;;; for assessment or adjustment of the subtree, without redundant
;;; traversal of the structure.
;;;_ > allout-chart-subtree (&optional levels orig-depth prev-depth)
(defun allout-chart-subtree (&optional levels orig-depth prev-depth)
"Produce a location \"chart\" of subtopics of the containing topic.
Optional argument LEVELS specifies the depth \(relative to start
depth) for the chart. Subsequent optional args are not for public
Point is left at the end of the subtree.
Charts are used to capture outline structure, so that outline-altering
routines need assess the structure only once, and then use the chart
for their elaborate manipulations.
Topics are entered in the chart so the last one is at the car.
The entry for each topic consists of an integer indicating the point
at the beginning of the topic. Charts for offspring consists of a
list containing, recursively, the charts for the respective subtopics.
The chart for a topics' offspring precedes the entry for the topic
The other function parameters are for internal recursion, and should
not be specified by external callers. ORIG-DEPTH is depth of topic at
starting point, and PREV-DEPTH is depth of prior topic."
(let ((original (not orig-depth)) ; `orig-depth' set only in recursion.
chart curr-depth)
(if original ; Just starting?
; Register initial settings and
; position to first offspring:
(progn (setq orig-depth (allout-depth))
(or prev-depth (setq prev-depth (1+ orig-depth)))
;; Loop over the current levels' siblings. Besides being more
;; efficient than tail-recursing over a level, it avoids exceeding
;; the typically quite constrained Emacs max-lisp-eval-depth.
;; Probably would speed things up to implement loop-based stack
;; operation rather than recursing for lower levels. Bah.
(while (and (not (eobp))
; Still within original topic?
(< orig-depth (setq curr-depth (allout-recent-depth)))
(cond ((= prev-depth curr-depth)
;; Register this one and move on:
(setq chart (cons (point) chart))
(if (and levels (<= levels 1))
;; At depth limit - skip sublevels:
(or (allout-next-sibling curr-depth)
;; or no more siblings - proceed to
;; next heading at lesser depth:
(while (and (<= curr-depth
((and (< prev-depth curr-depth)
(or (not levels)
(> levels 0)))
;; Recurse on deeper level of curr topic:
(setq chart
(cons (allout-chart-subtree (and levels
(1- levels))
;; ... then continue with this one.
;; ... else nil if we've ascended back to prev-depth.
(if original ; We're at the last sibling on
; the original level. Position
; to the end of it:
(progn (and (not (eobp)) (forward-char -1))
(and (= (preceding-char) ?\n)
(= (aref (buffer-substring (max 1 (- (point) 3))
(forward-char -1))
(setq allout-recent-end-of-subtree (point))))
chart ; (nreverse chart) not necessary,
; and maybe not preferable.
;;;_ > allout-chart-siblings (&optional start end)
(defun allout-chart-siblings (&optional start end)
"Produce a list of locations of this and succeeding sibling topics.
Effectively a top-level chart of siblings. See `allout-chart-subtree'
for an explanation of charts."
(if (allout-goto-prefix)
(let ((chart (list (point))))
(while (allout-next-sibling)
(setq chart (cons (point) chart)))
(if chart (setq chart (nreverse chart)))))))
;;;_ > allout-chart-to-reveal (chart depth)
(defun allout-chart-to-reveal (chart depth)
"Return a flat list of hidden points in subtree CHART, up to DEPTH.
Note that point can be left at any of the points on chart, or at the
start point."
(let (result here)
(while (and (or (eq depth t) (> depth 0))
(setq here (car chart))
(if (listp here)
(let ((further (allout-chart-to-reveal here (or (eq depth t)
(1- depth)))))
;; We're on the start of a subtree - recurse with it, if there's
;; more depth to go:
(if further (setq result (append further result)))
(setq chart (cdr chart)))
(goto-char here)
(if (allout-hidden-p)
(setq result (cons here result)))
(setq chart (cdr chart))))
;;;_ X allout-chart-spec (chart spec &optional exposing)
;; (defun allout-chart-spec (chart spec &optional exposing)
;; "Not yet \(if ever) implemented.
;; Produce exposure directives given topic/subtree CHART and an exposure SPEC.
;; Exposure spec indicates the locations to be exposed and the prescribed
;; exposure status. Optional arg EXPOSING is an integer, with 0
;; indicating pending concealment, anything higher indicating depth to
;; which subtopic headers should be exposed, and negative numbers
;; indicating (negative of) the depth to which subtopic headers and
;; bodies should be exposed.
;; The produced list can have two types of entries. Bare numbers
;; indicate points in the buffer where topic headers that should be
;; exposed reside.
;; - bare negative numbers indicates that the topic starting at the
;; point which is the negative of the number should be opened,
;; including their entries.
;; - bare positive values indicate that this topic header should be
;; opened.
;; - Lists signify the beginning and end points of regions that should
;; be flagged, and the flag to employ. (For concealment: `\(\?r\)', and
;; exposure:"
;; (while spec
;; (cond ((listp spec)
;; )
;; )
;; (setq spec (cdr spec)))
;; )
;;;_ - Within Topic
;;;_ > allout-goto-prefix ()
(defun allout-goto-prefix ()
"Put point at beginning of immediately containing outline topic.
Goes to most immediate subsequent topic if none immediately containing.
Not sensitive to topic visibility.
Returns the point at the beginning of the prefix, or nil if none."
(let (done)
(while (and (not done)
(search-backward "\n" nil 1))
(forward-char 1)
(if (looking-at allout-regexp)
(setq done (allout-prefix-data (match-beginning 0)
(match-end 0)))
(forward-char -1)))
(if (bobp)
(cond ((looking-at allout-regexp)
(allout-prefix-data (match-beginning 0)(match-end 0)))
;;;_ > allout-end-of-prefix ()
(defun allout-end-of-prefix (&optional ignore-decorations)
"Position cursor at beginning of header text.
If optional IGNORE-DECORATIONS is non-nil, put just after bullet,
otherwise skip white space between bullet and ensuing text."
(if (not (allout-goto-prefix))
(let ((match-data (match-data)))
(goto-char (match-end 0))
(if ignore-decorations
(while (looking-at "[0-9]") (forward-char 1))
(if (and (not (eolp)) (looking-at "\\s-")) (forward-char 1)))
(store-match-data match-data))
;; Reestablish where we are:
;;;_ > allout-current-bullet-pos ()
(defun allout-current-bullet-pos ()
"Return position of current \(visible) topic's bullet."
(if (not (allout-current-depth))
(1- (match-end 0))))
;;;_ > allout-back-to-current-heading ()
(defun allout-back-to-current-heading ()
"Move to heading line of current topic, or beginning if already on the line.
Return value of point, unless we started outside of (before any) topics,
in which case we return nil."
(if (or (allout-on-current-heading-p)
(and (re-search-backward (concat "^\\(" allout-regexp "\\)")
nil 'move)
(progn (while (allout-hidden-p)
(if (not (looking-at allout-regexp))
(re-search-backward (concat
"^\\(" allout-regexp "\\)")
nil 'move)))
(allout-prefix-data (match-beginning 1)
(match-end 1)))))
(if (interactive-p)
;;;_ > allout-back-to-heading ()
(defalias 'allout-back-to-heading 'allout-back-to-current-heading)
;;;_ > allout-pre-next-prefix ()
(defun allout-pre-next-prefix ()
"Skip forward to just before the next heading line.
Returns that character position."
(if (re-search-forward allout-line-boundary-regexp nil 'move)
(prog1 (goto-char (match-beginning 0))
(allout-prefix-data (match-beginning 2)(match-end 2)))))
;;;_ > allout-end-of-subtree (&optional current include-trailing-blank)
(defun allout-end-of-subtree (&optional current include-trailing-blank)
"Put point at the end of the last leaf in the containing topic.
Optional CURRENT means put point at the end of the containing
visible topic.
Optional INCLUDE-TRAILING-BLANK means include a trailing blank line, if
any, as part of the subtree. Otherwise, that trailing blank will be
excluded as delimiting whitespace between topics.
Returns the value of point."
(interactive "P")
(if current
(let ((level (allout-recent-depth)))
(while (and (not (eobp))
(> (allout-recent-depth) level))
(and (not (eobp)) (forward-char -1))
(if (and (not include-trailing-blank) (= ?\n (preceding-char)))
(forward-char -1))
(setq allout-recent-end-of-subtree (point))))
;;;_ > allout-end-of-current-subtree (&optional include-trailing-blank)
(defun allout-end-of-current-subtree (&optional include-trailing-blank)
"Put point at end of last leaf in currently visible containing topic.
Optional INCLUDE-TRAILING-BLANK means include a trailing blank line, if
any, as part of the subtree. Otherwise, that trailing blank will be
excluded as delimiting whitespace between topics.
Returns the value of point."
(allout-end-of-subtree t include-trailing-blank))
;;;_ > allout-beginning-of-current-entry ()
(defun allout-beginning-of-current-entry ()
"When not already there, position point at beginning of current topic header.
If already there, move cursor to bullet for hot-spot operation.
\(See `allout-mode' doc string for details of hot-spot operation.)"
(let ((start-point (point)))
(move-beginning-of-line 1)
(if (and (interactive-p)
(= (point) start-point))
(goto-char (allout-current-bullet-pos)))))
;;;_ > allout-end-of-entry (&optional inclusive)
(defun allout-end-of-entry (&optional inclusive)
"Position the point at the end of the current topics' entry.
Optional INCLUSIVE means also include trailing empty line, if any. When
unset, whitespace between items separates them even when the items are
(if (and (not inclusive) (not (bobp)) (= ?\n (preceding-char)))
(forward-char -1))
;;;_ > allout-end-of-current-heading ()
(defun allout-end-of-current-heading ()
(search-forward "\n" nil t)
(forward-char -1))
(defalias 'allout-end-of-heading 'allout-end-of-current-heading)
;;;_ > allout-get-body-text ()
(defun allout-get-body-text ()
"Return the unmangled body text of the topic immediately containing point."
(if (not (search-forward "\n" nil t))
(backward-char 1)
(let ((pre-body (point)))
(if (not pre-body)
(allout-end-of-entry t)
(if (not (= pre-body (point)))
(buffer-substring-no-properties (1+ pre-body) (point))))
;;;_ - Depth-wise
;;;_ > allout-ascend-to-depth (depth)
(defun allout-ascend-to-depth (depth)
"Ascend to depth DEPTH, returning depth if successful, nil if not."
(if (and (> depth 0)(<= depth (allout-depth)))
(let ((last-good (point)))
(while (and (< depth (allout-depth))
(setq last-good (point))
(if (= (allout-recent-depth) depth)
(progn (goto-char allout-recent-prefix-beginning)
(goto-char last-good)
(if (interactive-p) (allout-end-of-prefix))))
;;;_ > allout-ascend ()
(defun allout-ascend ()
"Ascend one level, returning t if successful, nil if not."
(if (allout-beginning-of-level)
(if (interactive-p) (allout-end-of-prefix))))
;;;_ > allout-descend-to-depth (depth)
(defun allout-descend-to-depth (depth)
"Descend to depth DEPTH within current topic.
Returning depth if successful, nil if not."
(let ((start-point (point))
(start-depth (allout-depth)))
(and (> (allout-depth) 0)
(not (= depth (allout-recent-depth))) ; ... not there yet
(allout-next-heading) ; ... go further
(< start-depth (allout-recent-depth)))) ; ... still in topic
(if (and (> (allout-depth) 0)
(= (allout-recent-depth) depth))
(goto-char start-point)
;;;_ > allout-up-current-level (arg &optional dont-complain)
(defun allout-up-current-level (arg &optional dont-complain)
"Move out ARG levels from current visible topic.
Positions on heading line of containing topic. Error if unable to
ascend that far, or nil if unable to ascend but optional arg
DONT-COMPLAIN is non-nil."
(interactive "p")
(let ((present-level (allout-recent-depth))
(last-good (point))
;; Loop for iterating arg:
(while (and (> (allout-recent-depth) 1)
(> arg 0)
(not (bobp))
(not failed))
(setq last-good (point))
;; Loop for going back over current or greater depth:
(while (and (not (< (allout-recent-depth) present-level))
(or (allout-previous-visible-heading 1)
(not (setq failed present-level)))))
(setq present-level (allout-current-depth))
(setq arg (- arg 1)))
(if (or failed
(> arg 0))
(progn (goto-char last-good)
(if (interactive-p) (allout-end-of-prefix))
(if (not dont-complain)
(error "Can't ascend past outermost level")
(if (interactive-p) (allout-end-of-prefix))
(if (interactive-p) (allout-end-of-prefix))
;;;_ - Linear
;;;_ > allout-next-sibling (&optional depth backward)
(defun allout-next-sibling (&optional depth backward)
"Like `allout-forward-current-level', but respects invisible topics.
Traverse at optional DEPTH, or current depth if none specified.
Go backward if optional arg BACKWARD is non-nil.
Return depth if successful, nil otherwise."
(if (and backward (bobp))
(let ((start-depth (or depth (allout-depth)))
(start-point (point))
(while (and (not (if backward (bobp) (eobp)))
(if backward (allout-previous-heading)
(> (setq last-depth (allout-recent-depth)) start-depth)))
(if (and (not (eobp))
(and (> (or last-depth (allout-depth)) 0)
(= (allout-recent-depth) start-depth)))
(goto-char start-point)
(if depth (allout-depth) start-depth)
;;;_ > allout-previous-sibling (&optional depth backward)
(defun allout-previous-sibling (&optional depth backward)
"Like `allout-forward-current-level' backwards, respecting invisible topics.
Optional DEPTH specifies depth to traverse, default current depth.
Optional BACKWARD reverses direction.
Return depth if successful, nil otherwise."
(allout-next-sibling depth (not backward))
;;;_ > allout-snug-back ()
(defun allout-snug-back ()
"Position cursor at end of previous topic.
Presumes point is at the start of a topic prefix."
(if (or (bobp) (eobp))
(forward-char -1))
(if (or (bobp) (not (= ?\n (preceding-char))))
(forward-char -1))
;;;_ > allout-beginning-of-level ()
(defun allout-beginning-of-level ()
"Go back to the first sibling at this level, visible or not."
(allout-end-of-level 'backward))
;;;_ > allout-end-of-level (&optional backward)
(defun allout-end-of-level (&optional backward)
"Go to the last sibling at this level, visible or not."
(let ((depth (allout-depth)))
(while (allout-previous-sibling depth nil))
(prog1 (allout-recent-depth)
(if (interactive-p) (allout-end-of-prefix)))))
;;;_ > allout-next-visible-heading (arg)
(defun allout-next-visible-heading (arg)
"Move to the next ARG'th visible heading line, backward if arg is negative.
Move to buffer limit in indicated direction if headings are exhausted."
(interactive "p")
(let* ((backward (if (< arg 0) (setq arg (* -1 arg))))
(step (if backward -1 1))
prev got)
(while (> arg 0) ; limit condition
(while (and (not (if backward (bobp)(eobp))) ; boundary condition
;; Move, skipping over all those concealed lines:
(prog1 (condition-case nil (or (line-move step) t)
(error nil))
(not (setq got (looking-at allout-regexp)))))
;; Register this got, it may be the last:
(if got (setq prev got))
(setq arg (1- arg)))
(cond (got ; Last move was to a prefix:
(allout-prefix-data (match-beginning 0) (match-end 0))
(prev ; Last move wasn't, but prev was:
(allout-prefix-data (match-beginning 0) (match-end 0)))
((not backward) (end-of-line) nil))))
;;;_ > allout-previous-visible-heading (arg)
(defun allout-previous-visible-heading (arg)
"Move to the previous heading line.
With argument, repeats or can move forward if negative.
A heading line is one that starts with a `*' (or that `allout-regexp'
(interactive "p")
(allout-next-visible-heading (- arg)))
;;;_ > allout-forward-current-level (arg)
(defun allout-forward-current-level (arg)
"Position point at the next heading of the same level.
Takes optional repeat-count, goes backward if count is negative.
Returns resulting position, else nil if none found."
(interactive "p")
(let ((start-depth (allout-current-depth))
(start-arg arg)
(backward (> 0 arg))
(last-good (point))
(if (= 0 start-depth)
(error "No siblings, not in a topic..."))
(if backward (setq arg (* -1 arg)))
(while (not (or (zerop arg)
(while (and (not (if backward (bobp) (eobp)))
(if backward (allout-previous-visible-heading 1)
(allout-next-visible-heading 1))
(> (setq last-depth (allout-recent-depth)) start-depth)))
(if (and last-depth (= last-depth start-depth)
(not (if backward (bobp) (eobp))))
(setq last-good (point)
arg (1- arg))
(setq at-boundary t)))
(if (and (not (eobp))
(= arg 0)
(and (> (or last-depth (allout-depth)) 0)
(= (allout-recent-depth) start-depth)))
(goto-char last-good)
(if (not (interactive-p))
(error "Hit %s level %d topic, traversed %d of %d requested"
(if backward "first" "last")
(- (abs start-arg) arg)
(abs start-arg))))))
;;;_ > allout-backward-current-level (arg)
(defun allout-backward-current-level (arg)
"Inverse of `allout-forward-current-level'."
(interactive "p")
(if (interactive-p)
(let ((current-prefix-arg (* -1 arg)))
(call-interactively 'allout-forward-current-level))
(allout-forward-current-level (* -1 arg))))
;;;_ #5 Alteration
;;;_ - Fundamental
;;;_ = allout-post-goto-bullet
(defvar allout-post-goto-bullet nil
"Outline internal var, for `allout-pre-command-business' hot-spot operation.
When set, tells post-processing to reposition on topic bullet, and
then unset it. Set by `allout-pre-command-business' when implementing
hot-spot operation, where literal characters typed over a topic bullet
are mapped to the command of the corresponding control-key on the
(make-variable-buffer-local 'allout-post-goto-bullet)
;;;_ > allout-post-command-business ()
(defun allout-post-command-business ()
"Outline `post-command-hook' function.
- Implement (and clear) `allout-post-goto-bullet', for hot-spot
outline commands.
- Decrypt topic currently being edited if it was encrypted for a save."
; Apply any external change func:
(if (not (allout-mode-p)) ; In allout-mode.
(if (and (boundp 'allout-after-save-decrypt)
;; Implement -post-goto-bullet, if set:
(if (and allout-post-goto-bullet
(progn (goto-char (allout-current-bullet-pos))
(setq allout-post-goto-bullet nil)))
;;;_ > allout-pre-command-business ()
(defun allout-pre-command-business ()
"Outline `pre-command-hook' function for outline buffers.
Implements special behavior when cursor is on bullet character.
When the cursor is on the bullet character, self-insert characters are
reinterpreted as the corresponding control-character in the
`allout-mode-map'. The `allout-mode' `post-command-hook' insures that
the cursor which has moved as a result of such reinterpretation is
positioned on the bullet character of the destination topic.
The upshot is that you can get easy, single (ie, unmodified) key
outline maneuvering operations by positioning the cursor on the bullet
char. When in this mode you can use regular cursor-positioning
command/keystrokes to relocate the cursor off of a bullet character to
return to regular interpretation of self-insert characters."
(if (not (allout-mode-p))
;; Hot-spot navigation provisions:
(if (and (eq this-command 'self-insert-command)
(eq (point)(allout-current-bullet-pos)))
(let* ((this-key-num (cond
((numberp last-command-char)
;; Only xemacs has characterp.
((and (fboundp 'characterp)
(apply 'characterp
(list last-command-char)))
(apply 'char-to-int (list last-command-char)))
(t 0)))
(if (zerop this-key-num)
; Map upper-register literals
; to lower register:
(if (<= 96 this-key-num)
(setq this-key-num (- this-key-num 32)))
; Check if we have a literal:
(if (and (<= 64 this-key-num)
(>= 96 this-key-num))
(setq mapped-binding
(lookup-key 'allout-mode-map
(concat allout-command-prefix
(char-to-string (- this-key-num
(if mapped-binding
(setq allout-post-goto-bullet t
this-command mapped-binding)))))))
;;;_ > allout-find-file-hook ()
(defun allout-find-file-hook ()
"Activate `allout-mode' on non-nil `allout-auto-activation', `allout-layout'.
See `allout-init' for setup instructions."
(if (and allout-auto-activation
(not (allout-mode-p))
(allout-mode t)))
;;;_ - Topic Format Assessment
;;;_ > allout-solicit-alternate-bullet (depth &optional current-bullet)
(defun allout-solicit-alternate-bullet (depth &optional current-bullet)
"Prompt for and return a bullet char as an alternative to the current one.
Offer one suitable for current depth DEPTH as default."
(let* ((default-bullet (or (and (stringp current-bullet) current-bullet)
(allout-bullet-for-depth depth)))
(sans-escapes (regexp-sans-escapes allout-bullets-string))
(goto-char (allout-current-bullet-pos))
(setq choice (solicit-char-in-string
(format "Select bullet: %s ('%s' default): "
(message "")
(if (string= choice "") default-bullet choice))
;;;_ > allout-distinctive-bullet (bullet)
(defun allout-distinctive-bullet (bullet)
"True if BULLET is one of those on `allout-distinctive-bullets-string'."
(string-match (regexp-quote bullet) allout-distinctive-bullets-string))
;;;_ > allout-numbered-type-prefix (&optional prefix)
(defun allout-numbered-type-prefix (&optional prefix)
"True if current header prefix bullet is numbered bullet."
(and allout-numbered-bullet
(string= allout-numbered-bullet
(if prefix
(allout-get-prefix-bullet prefix)
;;;_ > allout-encrypted-type-prefix (&optional prefix)
(defun allout-encrypted-type-prefix (&optional prefix)
"True if current header prefix bullet is for an encrypted entry \(body)."
(and allout-topic-encryption-bullet
(string= allout-topic-encryption-bullet
(if prefix
(allout-get-prefix-bullet prefix)
;;;_ > allout-bullet-for-depth (&optional depth)
(defun allout-bullet-for-depth (&optional depth)
"Return outline topic bullet suited to optional DEPTH, or current depth."
;; Find bullet in plain-bullets-string modulo DEPTH.
(if allout-stylish-prefixes
(char-to-string (aref allout-plain-bullets-string
(% (max 0 (- depth 2))
;;;_ - Topic Production
;;;_ > allout-make-topic-prefix (&optional prior-bullet
(defun allout-make-topic-prefix (&optional prior-bullet
;; Depth null means use current depth, non-null means we're either
;; opening a new topic after current topic, lower or higher, or we're
;; changing level of current topic.
;; Solicit dominates specified bullet-char.
;;;_ . Doc string:
"Generate a topic prefix suitable for optional arg DEPTH, or current depth.
All the arguments are optional.
PRIOR-BULLET indicates the bullet of the prefix being changed, or
nil if none. This bullet may be preserved (other options
notwithstanding) if it is on the `allout-distinctive-bullets-string',
for instance.
Second arg NEW indicates that a new topic is being opened after the
topic at point, if non-nil. Default bullet for new topics, eg, may
be set (contingent to other args) to numbered bullets if previous
sibling is one. The implication otherwise is that the current topic
is being adjusted - shifted or rebulleted - and we don't consider
bullet or previous sibling.
Third arg DEPTH forces the topic prefix to that depth, regardless of
the current topics' depth.
If SOLICIT is non-nil, then the choice of bullet is solicited from
user. If it's a character, then that character is offered as the
default, otherwise the one suited to the context \(according to
distinction or depth) is offered. \(This overrides other options,
including, eg, a distinctive PRIOR-BULLET.) If non-nil, then the
context-specific bullet is used.
Fifth arg, NUMBER-CONTROL, matters only if `allout-numbered-bullet'
is non-nil *and* soliciting was not explicitly invoked. Then
NUMBER-CONTROL non-nil forces prefix to either numbered or
denumbered format, depending on the value of the sixth arg, INDEX.
\(Note that NUMBER-CONTROL does *not* apply to level 1 topics. Sorry...)
If NUMBER-CONTROL is non-nil and sixth arg INDEX is non-nil then
the prefix of the topic is forced to be numbered. Non-nil
NUMBER-CONTROL and nil INDEX forces non-numbered format on the
bullet. Non-nil NUMBER-CONTROL and non-nil, non-number INDEX means
that the index for the numbered prefix will be derived, by counting
siblings back to start of level. If INDEX is a number, then that
number is used as the index for the numbered prefix (allowing, eg,
sequential renumbering to not require this function counting back the
index for each successive sibling)."
;;;_ . Code:
;; The options are ordered in likely frequence of use, most common
;; highest, least lowest. Ie, more likely to be doing prefix
;; adjustments than soliciting, and yet more than numbering.
;; Current prefix is least dominant, but most likely to be commonly
;; specified...
(let* (body
(depth (or depth (allout-depth)))
(header-lead allout-header-prefix)
;; Getting value for bullet char is practically the whole job:
; Simplest situation - level 1:
((<= depth 1) (setq header-lead "") allout-primary-bullet)
; Simple, too: all asterisks:
;; Cheat - make body the whole thing, null out header-lead and
;; bullet-char:
(setq body (make-string depth
(string-to-char allout-primary-bullet)))
(setq header-lead "")
;; (Neither level 1 nor old-style, so we're space padding.
;; Sneak it in the condition of the next case, whatever it is.)
;; Solicitation overrides numbering and other cases:
((progn (setq body (make-string (- depth 2) ?\ ))
;; The actual condition:
(let* ((got (allout-solicit-alternate-bullet depth solicit)))
;; Gotta check whether we're numbering and got a numbered bullet:
(setq numbering (and allout-numbered-bullet
(not (and number-control (not index)))
(string= got allout-numbered-bullet)))
;; Now return what we got, regardless:
;; Numbering invoked through args:
((and allout-numbered-bullet number-control)
(if (setq numbering (not (setq denumbering (not index))))
(if (and prior-bullet
(not (string= allout-numbered-bullet
(allout-bullet-for-depth depth))))
;;; Neither soliciting nor controlled numbering ;;;
;;; (may be controlled denumbering, tho) ;;;
;; Check wrt previous sibling:
((and new ; only check for new prefixes
(<= depth (allout-depth))
allout-numbered-bullet ; ... & numbering enabled
(not denumbering)
(let ((sibling-bullet
;; Locate correct sibling:
(or (>= depth (allout-depth))
(allout-ascend-to-depth depth))
(if (and sibling-bullet
(string= allout-numbered-bullet sibling-bullet))
(setq numbering sibling-bullet)))))
;; Distinctive prior bullet?
((and prior-bullet
(allout-distinctive-bullet prior-bullet)
;; Either non-numbered:
(or (not (and allout-numbered-bullet
(string= prior-bullet allout-numbered-bullet)))
;; or numbered, and not denumbering:
(setq numbering (not denumbering)))
;; Here 'tis:
;; Else, standard bullet per depth:
((allout-bullet-for-depth depth)))))
(concat header-lead
(if numbering
(format "%d" (cond ((and index (numberp index)) index)
(new (1+ (allout-sibling-index depth)))
;;;_ > allout-open-topic (relative-depth &optional before offer-recent-bullet)
(defun allout-open-topic (relative-depth &optional before offer-recent-bullet)
"Open a new topic at depth DEPTH.
New topic is situated after current one, unless optional flag BEFORE
is non-nil, or unless current line is completely empty - lacking even
whitespace - in which case open is done on the current line.
When adding an offspring, it will be added immediately after the parent if
the other offspring are exposed, or after the last child if the offspring
are hidden. \(The intervening offspring will be exposed in the latter
If OFFER-RECENT-BULLET is true, offer to use the bullet of the prior sibling.
- Creation of new topics is with respect to the visible topic
containing the cursor, regardless of intervening concealed ones.
- New headers are generally created after/before the body of a
topic. However, they are created right at cursor location if the
cursor is on a blank line, even if that breaks the current topic
body. This is intentional, to provide a simple means for
deliberately dividing topic bodies.
- Double spacing of topic lists is preserved. Also, the first
level two topic is created double-spaced (and so would be
subsequent siblings, if that's left intact). Otherwise,
single-spacing is used.
- Creation of sibling or nested topics is with respect to the topic
you're starting from, even when creating backwards. This way you
can easily create a sibling in front of the current topic without
having to go to its preceding sibling, and then open forward
from there."
(let* ((depth (+ (allout-current-depth) relative-depth))
(opening-on-blank (if (looking-at "^\$")
(not (setq before nil))))
;; bunch o vars set while computing ref-topic
(ref-topic (save-excursion
(cond ((< relative-depth 0)
(allout-ascend-to-depth depth))
((>= relative-depth 1) nil)
(t (allout-back-to-current-heading)))
(setq ref-depth (allout-recent-depth))
(setq ref-bullet
(if (> allout-recent-prefix-end 1)
(setq opening-numbered
(and allout-numbered-bullet
(or (<= relative-depth 0)
(allout-descend-to-depth depth))
(if (allout-numbered-type-prefix)
(if (not opening-on-blank)
; Positioning and vertical
; padding - only if not
; opening-on-blank:
(goto-char ref-topic)
(setq dbl-space ; Determine double space action:
(or (and (<= relative-depth 0) ; not descending;
;; at b-o-b or preceded by a blank line?
(or (> 0 (forward-line -1))
(looking-at "^\\s-*$")
;; succeeded by a blank line?
(looking-at "\n\n")))
(and (= ref-depth 1)
(or before
(= depth 1)
;; Don't already have following
;; vertical padding:
(not (allout-pre-next-prefix)))))))
;; Position to prior heading, if inserting backwards, and not
;; going outwards:
(if (and before (>= relative-depth 0))
(progn (allout-back-to-current-heading)
(setq doing-beginning (bobp))
(if (not (bobp))
(if (and before (bobp))
(open-line 1)))
(if (<= relative-depth 0)
;; Not going inwards, don't snug up:
(if doing-beginning
(if (not dbl-space)
(open-line 1)
(open-line 2))
(if before
(progn (end-of-line)
(while (and (= ?\n (following-char))
(forward-char 1)
(forward-char 1))
(if (not (looking-at "^$"))
(open-line 1)))
(if (looking-at "\n\n") (forward-char 1))))
;; Going inwards - double-space if first offspring is
;; double-spaced, otherwise snug up.
(if (eobp)
(newline 1)
(line-move 1))
(backward-char 1)
(if (bolp)
;; Blank lines between current header body and next
;; header - get to last substantive (non-white-space)
;; line in body:
(progn (setq dbl-space t)
(re-search-backward "[^ \t\n]" nil t)))
(if (looking-at "\n\n")
(setq dbl-space t))
(if (save-excursion
(when (> (allout-recent-depth) ref-depth)
;; This is an offspring.
(forward-line -1)
(looking-at "^\\s-*$")))
(progn (forward-line 1)
(open-line 1)
(forward-line 1)))
;;(if doing-beginning (goto-char doing-beginning))
(if (not (bobp))
;; We insert a newline char rather than using open-line to
;; avoid rear-stickiness inheritence of read-only property.
(progn (if (and (not (> depth ref-depth))
(not before))
(open-line 1)
(if (and (not dbl-space) (> depth ref-depth))
(newline 1)
(if dbl-space
(open-line 1)
(if (not before)
(newline 1)))))
(if (and dbl-space (not (> relative-depth 0)))
(newline 1))
(if (and (not (eobp))
(not (bolp)))
(forward-char 1))))
(insert (concat (allout-make-topic-prefix opening-numbered t depth)
" "))
(allout-rebullet-heading (and offer-recent-bullet ref-bullet)
depth nil nil t)
(if (> relative-depth 0)
(save-excursion (goto-char ref-topic)
;;;_ > allout-open-subtopic (arg)
(defun allout-open-subtopic (arg)
"Open new topic header at deeper level than the current one.
Negative universal arg means to open deeper, but place the new topic
prior to the current one."
(interactive "p")
(allout-open-topic 1 (> 0 arg) (< 1 arg)))
;;;_ > allout-open-sibtopic (arg)
(defun allout-open-sibtopic (arg)
"Open new topic header at same level as the current one.
Positive universal arg means to use the bullet of the prior sibling.
Negative universal arg means to place the new topic prior to the current
(interactive "p")
(allout-open-topic 0 (> 0 arg) (not (= 1 arg))))
;;;_ > allout-open-supertopic (arg)
(defun allout-open-supertopic (arg)
"Open new topic header at shallower level than the current one.
Negative universal arg means to open shallower, but place the new
topic prior to the current one."
(interactive "p")
(allout-open-topic -1 (> 0 arg) (< 1 arg)))
;;;_ - Outline Alteration
;;;_ : Topic Modification
;;;_ = allout-former-auto-filler
(defvar allout-former-auto-filler nil
"Name of modal fill function being wrapped by `allout-auto-fill'.")
;;;_ > allout-auto-fill ()
(defun allout-auto-fill ()
"`allout-mode' autofill function.
Maintains outline hanging topic indentation if
`allout-use-hanging-indents' is set."
(let ((fill-prefix (if allout-use-hanging-indents
;; Check for topic header indentation:
(if (looking-at allout-regexp)
;; ... construct indentation to account for
;; length of topic prefix:
(make-string (progn (allout-end-of-prefix)
?\ )))))
(use-auto-fill-function (or allout-outside-normal-auto-fill-function
(if (or allout-former-auto-filler allout-use-hanging-indents)
(funcall use-auto-fill-function))))
;;;_ > allout-reindent-body (old-depth new-depth &optional number)
(defun allout-reindent-body (old-depth new-depth &optional number)
"Reindent body lines which were indented at OLD-DEPTH to NEW-DEPTH.
Optional arg NUMBER indicates numbering is being added, and it must
be accommodated.
Note that refill of indented paragraphs is not done."
(let* ((new-margin (current-column))
excess old-indent-begin old-indent-end
;; We want the column where the header-prefix text started
;; *before* the prefix was changed, so we infer it relative
;; to the new margin and the shift in depth:
(old-margin (+ old-depth (- new-margin new-depth))))
;; Process lines up to (but excluding) next topic header:
(and (re-search-forward "\n\\(\\s-*\\)"
;; Register the indent data, before we reset the
;; match data with a subsequent `looking-at':
(setq old-indent-begin (match-beginning 1)
old-indent-end (match-end 1))
(not (looking-at allout-regexp)))
(if (> 0 (setq excess (- (- old-indent-end old-indent-begin)
;; Text starts left of old margin - don't adjust:
;; Text was hanging at or right of old left margin -
;; reindent it, preserving its existing indentation
;; beyond the old margin:
(delete-region old-indent-begin old-indent-end)
(indent-to (+ new-margin excess (current-column))))))))))
;;;_ > allout-rebullet-current-heading (arg)
(defun allout-rebullet-current-heading (arg)
"Solicit new bullet for current visible heading."
(interactive "p")
(let ((initial-col (current-column))
(on-bullet (eq (point)(allout-current-bullet-pos)))
(backwards (if (< arg 0)
(setq arg (* arg -1)))))
(while (> arg 0)
(save-excursion (allout-back-to-current-heading)
(allout-rebullet-heading t ;;; solicit
nil ;;; depth
nil ;;; number-control
nil ;;; index
t)) ;;; do-successors
(setq arg (1- arg))
(if (<= arg 0)
(setq initial-col nil) ; Override positioning back to init col
(if (not backwards)
(allout-next-visible-heading 1)
(allout-next-visible-heading -1))))
(message "Done.")
(cond (on-bullet (goto-char (allout-current-bullet-pos)))
(initial-col (move-to-column initial-col)))))
;;;_ > allout-rebullet-heading (&optional solicit ...)
(defun allout-rebullet-heading (&optional solicit
"Adjust bullet of current topic prefix.
All args are optional.
If SOLICIT is non-nil, then the choice of bullet is solicited from
user. If it's a character, then that character is offered as the
default, otherwise the one suited to the context \(according to
distinction or depth) is offered. If non-nil, then the
context-specific bullet is just used.
Second arg DEPTH forces the topic prefix to that depth, regardless
of the topic's current depth.
Third arg NUMBER-CONTROL can force the prefix to or away from
numbered form. It has effect only if `allout-numbered-bullet' is
non-nil and soliciting was not explicitly invoked (via first arg).
Its effect, numbering or denumbering, then depends on the setting
of the forth arg, INDEX.
If NUMBER-CONTROL is non-nil and forth arg INDEX is nil, then the
prefix of the topic is forced to be non-numbered. Null index and
non-nil NUMBER-CONTROL forces denumbering. Non-nil INDEX (and
non-nil NUMBER-CONTROL) forces a numbered-prefix form. If non-nil
INDEX is a number, then that number is used for the numbered
prefix. Non-nil and non-number means that the index for the
numbered prefix will be derived by allout-make-topic-prefix.
Fifth arg DO-SUCCESSORS t means re-resolve count on succeeding
Cf vars `allout-stylish-prefixes', `allout-old-style-prefixes',
and `allout-numbered-bullet', which all affect the behavior of
this function."
(let* ((current-depth (allout-depth))
(new-depth (or new-depth current-depth))
(mb allout-recent-prefix-beginning)
(me allout-recent-prefix-end)
(current-bullet (buffer-substring (- me 1) me))
(new-prefix (allout-make-topic-prefix current-bullet
;; Is new one is identical to old?
(if (and (= current-depth new-depth)
(string= current-bullet
(substring new-prefix (1- (length new-prefix)))))
;; Nothing to do:
;; New prefix probably different from old:
; get rid of old one:
(allout-unprotected (delete-region mb me))
(goto-char mb)
; Dispense with number if
; numbered-bullet prefix:
(if (and allout-numbered-bullet
(string= allout-numbered-bullet current-bullet)
(looking-at "[0-9]+"))
(delete-region (match-beginning 0)(match-end 0))))
; Put in new prefix:
(allout-unprotected (insert new-prefix))
;; Reindent the body if elected, margin changed, and not encrypted body:
(if (and allout-reindent-bodies
(not (= new-depth current-depth))
(not (allout-encrypted-topic-p)))
(allout-reindent-body current-depth new-depth))
;; Recursively rectify successive siblings of orig topic if
;; caller elected for it:
(if do-successors
(while (allout-next-sibling new-depth nil)
(setq index
(cond ((numberp index) (1+ index))
((not number-control) (allout-sibling-index))))
(if (allout-numbered-type-prefix)
(allout-rebullet-heading nil ;;; solicit
new-depth ;;; new-depth
number-control;;; number-control
index ;;; index
nil))))) ;;;(dont!)do-successors
) ; (if (and (= current-depth new-depth)...))
) ; let* ((current-depth (allout-depth))...)
) ; defun
;;;_ > allout-rebullet-topic (arg)
(defun allout-rebullet-topic (arg)
"Rebullet the visible topic containing point and all contained subtopics.
Descends into invisible as well as visible topics, however.
With repeat count, shift topic depth by that amount."
(interactive "P")
(let ((start-col (current-column)))
;; Normalize arg:
(cond ((null arg) (setq arg 0))
((listp arg) (setq arg (car arg))))
;; Fill the user in, in case we're shifting a big topic:
(if (not (zerop arg)) (message "Shifting..."))
(if (<= (+ (allout-recent-depth) arg) 0)
(error "Attempt to shift topic below level 1"))
(allout-rebullet-topic-grunt arg)
(if (not (zerop arg)) (message "Shifting... done.")))
(move-to-column (max 0 (+ start-col arg)))))
;;;_ > allout-rebullet-topic-grunt (&optional relative-depth ...)
(defun allout-rebullet-topic-grunt (&optional relative-depth
"Like `allout-rebullet-topic', but on nearest containing topic
\(visible or not).
See `allout-rebullet-heading' for rebulleting behavior.
All arguments are optional.
First arg RELATIVE-DEPTH means to shift the depth of the entire
topic that amount.
The rest of the args are for internal recursive use by the function
(let* ((relative-depth (or relative-depth 0))
(new-depth (allout-depth))
(starting-depth (or starting-depth new-depth))
(on-starting-call (null starting-point))
(index (or index
;; Leave index null on starting call, so rebullet-heading
;; calculates it at what might be new depth:
(and (or (zerop relative-depth)
(not on-starting-call))
(moving-outwards (< 0 relative-depth))
(starting-point (or starting-point (point))))
;; Sanity check for excessive promotion done only on starting call:
(and on-starting-call
(> 0 (+ starting-depth relative-depth))
(error "Attempt to shift topic out beyond level 1")) ;;; ====>
(cond ((= starting-depth new-depth)
;; We're at depth to work on this one:
(allout-rebullet-heading nil ;;; solicit
(+ starting-depth ;;; starting-depth
nil ;;; number
index ;;; index
;; Every contained topic will get hit,
;; and we have to get to outside ones
;; deliberately:
nil) ;;; do-successors
;; ... and work on subsequent ones which are at greater depth:
(setq index 0)
(while (and (not (eobp))
(< starting-depth (allout-recent-depth)))
(setq index (1+ index))
(allout-rebullet-topic-grunt relative-depth ;;; relative-depth
(1+ starting-depth);;;starting-depth
starting-point ;;; starting-point
index))) ;;; index
((< starting-depth new-depth)
;; Rare case - subtopic more than one level deeper than parent.
;; Treat this one at an even deeper level:
(allout-rebullet-topic-grunt relative-depth ;;; relative-depth
new-depth ;;; starting-depth
starting-point ;;; starting-point
index))) ;;; index
(if on-starting-call
;; Rectify numbering of former siblings of the adjusted topic,
;; if topic has changed depth
(if (or do-successors
(and (not (zerop relative-depth))
(or (= (allout-recent-depth) starting-depth)
(= (allout-recent-depth) (+ starting-depth
(allout-rebullet-heading nil nil nil nil t))
;; Now rectify numbering of new siblings of the adjusted topic,
;; if depth has been changed:
(progn (goto-char starting-point)
(if (not (zerop relative-depth))
(allout-rebullet-heading nil nil nil nil t)))))
;;;_ > allout-renumber-to-depth (&optional depth)
(defun allout-renumber-to-depth (&optional depth)
"Renumber siblings at current depth.
Affects superior topics if optional arg DEPTH is less than current depth.
Returns final depth."
;; Proceed by level, processing subsequent siblings on each,
;; ascending until we get shallower than the start depth:
(let ((ascender (allout-depth))
(while (and (not (eobp))
(>= (allout-recent-depth) depth)
(>= ascender depth))
; Skip over all topics at
; lesser depths, which can not
; have been disturbed:
(while (and (not (setq was-eobp (eobp)))
(> (allout-recent-depth) ascender))
; Prime ascender for ascension:
(setq ascender (1- (allout-recent-depth)))
(if (>= (allout-recent-depth) depth)
(allout-rebullet-heading nil ;;; solicit
nil ;;; depth
nil ;;; number-control
nil ;;; index
t)) ;;; do-successors
(if was-eobp (goto-char (point-max)))))
;;;_ > allout-number-siblings (&optional denumber)
(defun allout-number-siblings (&optional denumber)
"Assign numbered topic prefix to this topic and its siblings.
With universal argument, denumber - assign default bullet to this
topic and its siblings.
With repeated universal argument (`^U^U'), solicit bullet for each
rebulleting each topic at this level."
(interactive "P")
(let ((depth (allout-recent-depth))
(index (if (not denumber) 1))
(use-bullet (equal '(16) denumber))
(more t))
(while more
(allout-rebullet-heading use-bullet ;;; solicit
depth ;;; depth
t ;;; number-control
index ;;; index
nil) ;;; do-successors
(if index (setq index (1+ index)))
(setq more (allout-next-sibling depth nil))))))
;;;_ > allout-shift-in (arg)
(defun allout-shift-in (arg)
"Increase depth of current heading and any topics collapsed within it.
We disallow shifts that would result in the topic having a depth more than
one level greater than the immediately previous topic, to avoid containment
discontinuity. The first topic in the file can be adjusted to any positive
depth, however."
(interactive "p")
(if (> arg 0)
(if (not (bobp))
(let* ((current-depth (allout-recent-depth))
(start-point (point))
(predecessor-depth (progn
(forward-char -1)
(if (< (point) start-point)
(if (and (> predecessor-depth 0)
(> (+ current-depth arg)
(1+ predecessor-depth)))
(error (concat "Disallowed shift deeper than"
" containing topic's children.")))))))
(allout-rebullet-topic arg))
;;;_ > allout-shift-out (arg)
(defun allout-shift-out (arg)
"Decrease depth of current heading and any topics collapsed within it.
We disallow shifts that would result in the topic having a depth more than
one level greater than the immediately previous topic, to avoid containment
discontinuity. The first topic in the file can be adjusted to any positive
depth, however."
(interactive "p")
(if (< arg 0)
(allout-shift-in (* arg -1)))
(allout-rebullet-topic (* arg -1)))
;;;_ : Surgery (kill-ring) functions with special provisions for outlines:
;;;_ > allout-kill-line (&optional arg)
(defun allout-kill-line (&optional arg)
"Kill line, adjusting subsequent lines suitably for outline mode."
(interactive "*P")
(if (or (not (allout-mode-p))
(not (bolp))
(not (looking-at allout-regexp)))
;; Just do a regular kill:
(kill-line arg)
;; Ah, have to watch out for adjustments:
(let* ((beg (point))
(beg-hidden (allout-hidden-p))
(end-hidden (save-excursion (allout-end-of-current-line)
(depth (allout-depth))
(collapsed (allout-current-topic-collapsed-p)))
(if collapsed
(put-text-property beg (1+ beg) 'allout-was-collapsed t)
(remove-text-properties beg (1+ beg) '(allout-was-collapsed t)))
(if (and (not beg-hidden) (not end-hidden))
(allout-unprotected (kill-line arg))
(kill-line arg))
; Provide some feedback:
(sit-for 0)
(if allout-numbered-bullet
(save-excursion ; Renumber subsequent topics if needed:
(if (not (looking-at allout-regexp))
(allout-renumber-to-depth depth))))))
;;;_ > allout-kill-topic ()
(defun allout-kill-topic ()
"Kill topic together with subtopics.
Trailing whitespace is killed with a topic if that whitespace:
- would separate the topic from a subsequent sibling
- would separate the topic from the end of buffer
- would not be added to whitespace already separating the topic from the
previous one.
Completely collapsed topics are marked as such, for re-collapse
when yank with allout-yank into an outline as a heading."
;; Some finagling is done to make complex topic kills appear faster
;; than they actually are. A redisplay is performed immediately
;; after the region is deleted, though the renumbering process
;; has yet to be performed. This means that there may appear to be
;; a lag *after* a kill has been performed.
(let* ((collapsed (allout-current-topic-collapsed-p))
(beg (prog1 (allout-back-to-current-heading) (beginning-of-line)))
(depth (allout-recent-depth)))
(if (and (/= (current-column) 0) (not (eobp)))
(forward-char 1))
(if (not (eobp))
(if (and (looking-at "\n")
(or (save-excursion
(or (not (allout-next-heading))
(= depth (allout-recent-depth))))
(and (> (- beg (point-min)) 3)
(string= (buffer-substring (- beg 2) beg) "\n\n"))))
(forward-char 1)))
(if collapsed
(put-text-property beg (1+ beg) 'allout-was-collapsed t)
(remove-text-properties beg (1+ beg) '(allout-was-collapsed t)))
(allout-unprotected (kill-region beg (point)))
(sit-for 0)
(allout-renumber-to-depth depth))))
;;;_ > allout-yank-processing ()
(defun allout-yank-processing (&optional arg)
"Incidental allout-specific business to be done just after text yanks.
Does depth adjustment of yanked topics, when:
1 the stuff being yanked starts with a valid outline header prefix, and
2 it is being yanked at the end of a line which consists of only a valid
topic prefix.
Also, adjusts numbering of subsequent siblings when appropriate.
Depth adjustment alters the depth of all the topics being yanked
the amount it takes to make the first topic have the depth of the
header into which it's being yanked.
The point is left in front of yanked, adjusted topics, rather than
at the end (and vice-versa with the mark). Non-adjusted yanks,
however, are left exactly like normal, non-allout-specific yanks."
(interactive "*P")
; Get to beginning, leaving
; region around subject:
(if (< (allout-mark-marker t) (point))
(let* ((subj-beg (point))
(into-bol (bolp))
(subj-end (allout-mark-marker t))
(was-collapsed (get-text-property subj-beg 'allout-was-collapsed))
;; 'resituate' if yanking an entire topic into topic header:
(resituate (and (allout-e-o-prefix-p)
(looking-at (concat "\\(" allout-regexp "\\)"))
(allout-prefix-data (match-beginning 1)
(match-end 1))))
;; `rectify-numbering' if resituating (where several topics may
;; be resituating) or yanking a topic into a topic slot (bol):
(rectify-numbering (or resituate
(and into-bol (looking-at allout-regexp)))))
(if resituate
; The yanked stuff is a topic:
(let* ((prefix-len (- (match-end 1) subj-beg))
(subj-depth (allout-recent-depth))
(prefix-bullet (allout-recent-bullet))
;; Nil if adjustment unnecessary, otherwise depth to which
;; adjustment should be made:
(and (goto-char subj-end)
(goto-char subj-beg)
(and (looking-at allout-regexp)
(not (= (point) subj-beg)))
(looking-at allout-regexp)
(allout-prefix-data (match-beginning 0)
(match-end 0)))
(more t))
(setq rectify-numbering allout-numbered-bullet)
(if adjust-to-depth
; Do the adjustment:
(message "... yanking") (sit-for 0)
(narrow-to-region subj-beg subj-end)
; Trim off excessive blank
; line at end, if any:
(goto-char (point-max))
(if (looking-at "^$")
(allout-unprotected (delete-char -1)))
; Work backwards, with each
; shallowest level,
; successively excluding the
; last processed topic from
; the narrow region:
(while more
; go as high as we can in each bunch:
(while (allout-ascend-to-depth (1- (allout-depth))))
(allout-rebullet-topic-grunt (- adjust-to-depth
(if (setq more (not (bobp)))
(progn (widen)
(forward-char -1)
(narrow-to-region subj-beg (point))))))
(message "")
;; Preserve new bullet if it's a distinctive one, otherwise
;; use old one:
(if (string-match (regexp-quote prefix-bullet)
; Delete from bullet of old to
; before bullet of new: