;ELC ;;; compiled by kwzh@hal.gnu.ai.mit.edu on Tue May 2 20:11:30 1995 ;;; from file /gd/gnu/emacs/19.0/lisp/allout.el ;;; emacs version 19.28.90.69. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "`/gd/gnu/emacs/19.0/lisp/allout.el' was compiled for Emacs 19")) (byte-code "!!" [provide outline allout] 2) #@904 *Regulates auto-activation modality of allout outlines - see `outline-init'. Setq-default by `outline-init' to regulate whether or not allout outline mode is automatically activated when the buffer-specific variable `outline-layout' is non-nil, and whether or not the layout dictated by `outline-layout' should be imposed on mode activation. With value `t', auto-mode-activation and auto-layout are enabled. (This also depends on `outline-find-file-hooks' being installed in `find-file-hooks', which is also done by `outline-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 enabled. See the docstring for `outline-init' for the proper interface to this variable. (defvar outline-auto-activation nil (#$ . -532)) #@1185 *Layout specification and provisional mode trigger for allout outlines. Buffer-specific. A list value specifies a default layout for the current buffer, to be applied upon activation of allout outline-mode. Any non-nil value will automatically trigger allout outline-mode, provided `outline- init' has been called to enable it. See the docstring for `outline-init' for details on setting up for auto-mode-activation, and for `outline-expose-topic' for the format of the layout specification. You can associate a particular outline layout with a file by setting this var via the file's local variables. For example, the following lines at the bottom of an Emacs Lisp file: ;;;Local variables: ;;;outline-layout: (0 : -1 -1 0) ;;;End: will, modulo the above-mentioned conditions, cause the mode to be activated when the file is visited, followed by the equivalent of `(outline-expose-topic 0 : -1 -1 0)'. (This is the layout used for the allout.el, itself.) 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 `outline-use-mode-specific- leader', which see. (defvar outline-layout nil (#$ . -1492)) (make-variable-buffer-local (quote outline-layout)) #@376 *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 outline-primary-bullet. Many outlines start at level 2 to avoid this discrepancy. (defvar outline-header-prefix "." (#$ . -2776)) (make-variable-buffer-local (quote outline-header-prefix)) #@452 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 outline-*-bullets-string vars. The value of an asterisk ('*') provides for backwards compatability with the original emacs outline mode. See outline-plain-bullets-string and outline-distinctive-bullets-string for the range of available bullets. (defvar outline-primary-bullet "*" (#$ . 3265)) (make-variable-buffer-local (quote outline-primary-bullet)) #@286 *The bullets normally used in outline topic prefixes. See 'outline-distinctive-bullets-string' for the other kind of bullets. 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. (defvar outline-plain-bullets-string (concat outline-primary-bullet "+-:.;,") (#$ . -3831)) (make-variable-buffer-local (quote outline-plain-bullets-string)) #@505 *Persistent outline header bullets used to distinguish special topics. These bullets are not offered among the regular, level-specific rotation, and are not altered by automatic rebulleting, as when shifting the level of a topic. See `outline-plain-bullets-string' for the selection of alternating bullets. You must run 'set-outline-regexp' in order for changes to the value of this var to effect outline-mode operation. DO NOT include the close-square-bracket, ']', on either of the bullet strings. (defvar outline-distinctive-bullets-string "=>([{}&!?#%\"X@$~\\" (#$ . -4281)) (make-variable-buffer-local (quote outline-distinctive-bullets-string)) #@1083 *When non-nil, use mode-specific topic-header prefixes. Allout outline mode will use the mode-specific `outline-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 `outline-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 `outline-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 `outline-mode-leaders' to override this behavior, when incorrect.] (defvar outline-use-mode-specific-leader t (#$ . -4944)) #@426 Specific outline-prefix leading strings per major modes. Entries will be used in the stead (or lieu) of mode-specific comment-start strings. See also `outline-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. (defvar outline-mode-leaders nil (#$ . 6090)) #@364 *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. (defvar outline-old-style-prefixes nil (#$ . -6568)) (make-variable-buffer-local (quote outline-old-style-prefixes)) #@1433 *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 prefixes: * 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 outline-old-style-prefixes is non-nil. (defvar outline-stylish-prefixes t (#$ . -7056)) (make-variable-buffer-local (quote outline-stylish-prefixes)) #@313 *String designating bullet of topics that have auto-numbering; nil for none. Topics having this bullet have automatic maintainence 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 maintainence. (defvar outline-numbered-bullet "#" (#$ . -8606)) (make-variable-buffer-local (quote outline-numbered-bullet)) #@195 *Bullet signifying file cross-references, for `outline-resolve-xref'. Set this var to the bullet you want to use for file cross-references. Set it 'nil' if you want to inhibit this capability. (defvar outline-file-xref-bullet "@" (#$ . -9036)) #@70 *Non-nil turns on page numbering for LaTeX formatting of an outline. (defvar outline-number-pages nil (#$ . -9287)) #@62 *Font and size of labels for LaTeX formatting of an outline. (defvar outline-label-style "\\large\\bf" (#$ . -9409)) #@63 *Font and size of entries for LaTeX formatting of an outline. (defvar outline-head-line-style "\\large\\sl " (#$ . -9532)) #@63 *Font and size of entries for LaTeX formatting of an outline. (defvar outline-body-line-style " " (#$ . -9661)) #@62 *Font and size of titles for LaTeX formatting of an outline. (defvar outline-title-style "\\Large\\bf" (#$ . -9779)) #@78 *Expression to be evaluated to determine the title for LaTeX formatted copy. (defvar outline-title (quote (or buffer-file-name (current-buffer-name))) (#$ . -9902)) #@58 *Space between lines for LaTeX formatting of an outline. (defvar outline-line-skip ".05cm" (#$ . -10073)) #@40 *LaTeX formatted depth-indent spacing. (defvar outline-indent ".3cm" (#$ . -10185)) #@268 *List of outline-mode key / function bindings. These bindings will be locally bound on the outline-mode-map. The keys will be prefixed by outline-command-prefix, unless the cell contains a third, no-nil element, in which case the initial string will be used as is. (defvar outline-keybindings-list nil (#$ . -10276)) (byte-code "‡" [(("?t" outline-latexify-exposed) ("" outline-next-visible-heading) ("" outline-previous-visible-heading) ("" outline-up-current-level) ("" outline-forward-current-level) ("" outline-backward-current-level) ("" outline-beginning-of-current-entry) ("" outline-end-of-current-entry) (" " outline-show-children) ("" outline-show-current-subtree) ("" outline-hide-current-subtree) ("" outline-show-current-entry) ("!" outline-show-all) (" " outline-open-sibtopic) ("." outline-open-subtopic) ("," outline-open-supertopic) ("'" outline-shift-in) (">" outline-shift-in) ("<" outline-shift-out) (" " outline-rebullet-topic) ("*" outline-rebullet-current-heading) ("#" outline-number-siblings) (" " outline-kill-line t) ("" outline-yank t) ("" outline-yank-pop t) (" " outline-kill-topic) ("" outline-mark-topic) ("@" outline-resolve-xref) ("?c" outline-copy-exposed)) outline-keybindings-list nil] 1) #@75 *Key sequence to be used as prefix for outline mode command key bindings. (defvar outline-command-prefix "" (#$ . -11526)) #@213 *Set non-nil to enable automatic exposure of concealed isearch targets. If non-nil, isearch will expose hidden text encountered in the course of a search, and to reconceal it if the search is continued past it. (defvar outline-enwrap-isearch-mode t (#$ . -11657)) #@321 *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. [This feature no longer depends in any way on the 'filladapt.el' lisp-archive package.] (defvar outline-use-hanging-indents t (#$ . -11929)) (make-variable-buffer-local (quote outline-use-hanging-indents)) #@430 *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. (defvar outline-reindent-bodies (byte-code "" [outline-use-hanging-indents text] 1) (#$ . -12374)) (make-variable-buffer-local (quote outline-reindent-bodies)) #@428 *Non-nil disables warnings and confirmation-checks for concealed-text edits. Outline mode uses emacs change-triggered functions to detect unruly changes to concealed regions. Set this var non-nil to disable the protection, potentially increasing text-entry responsiveness a bit. This var takes effect at outline-mode activation, so you may have to deactivate and then reactivate the mode if you want to toggle the behavior. (defvar outline-inhibit-protection nil (#$ . -12976)) #@67 Revision number of currently loaded outline package. (allout.el) (defvar outline-version (byte-code "ď)" ["Revision: 4.3" rcs-rev err (byte-code " Ž \" ƔƕO*" [match-data match-data ((store-match-data match-data)) string-match "Revision: \\([0-9]+\\.[0-9]+\\)" rcs-rev 1] 3) ((error rcs-rev))] 3) (#$ . 13463)) #@54 Return string describing the loaded outline version. (defalias 'outline-version #[(&optional here) " P \f\n!\n\"\n)" ["Allout Outline Mode v " outline-version msg here insert-string message "%s"] 3 (#$ . 13795) "P"]) #@215 *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-outline-regexp. (defvar outline-regexp "" (#$ . -14029)) (make-variable-buffer-local (quote outline-regexp)) #@249 A string dictating the valid set of outline topic bullets. This var should *not* be set by the user - it is set by 'set-outline-regexp', and is produced from the elements of 'outline-plain-bullets-string' and 'outline-distinctive-bullets-string'. (defvar outline-bullets-string "" (#$ . 14343)) (make-variable-buffer-local (quote outline-bullets-string)) #@58 Length of current buffers' outline-plain-bullets-string. (defvar outline-bullets-string-len 0 (#$ . 14705)) (make-variable-buffer-local (quote outline-bullets-string-len)) #@259 Outline-regexp with outline-style beginning-of-line anchor. (Ie, C-j, *or* C-m, for prefixes of hidden topics). This is properly set when outline-regexp is produced by 'set-outline-regexp', so that (match-beginning 2) and (match-end 2) delimit the prefix. (defvar outline-line-boundary-regexp nil (#$ . 14884)) (make-variable-buffer-local (quote outline-line-boundary-regexp)) #@130 Like outline-line-boundary-regexp, for headers at beginning of buffer. (match-beginning 2) and (match-end 2) delimit the prefix. (defvar outline-bob-regexp nil (#$ . 15270)) (make-variable-buffer-local (quote outline-bob-regexp)) #@70 Outline-header prefix length to subtract when computing topic depth. (defvar outline-header-subtraction (byte-code "GS" [outline-header-prefix] 1) (#$ . 15506)) (make-variable-buffer-local (quote outline-header-subtraction)) #@72 Length of outline-plain-bullets-string, updated by set-outline-regexp. (defvar outline-plain-bullets-string-len (length outline-plain-bullets-string) (#$ . 15739)) (make-variable-buffer-local (quote outline-plain-bullets-string-len)) #@59 *Reset the leading string used to identify topic headers. (defalias 'outline-reset-header-lead #[(header-lead) "GS " [header-lead outline-header-prefix outline-header-subtraction set-outline-regexp] 2 (#$ . -15979) "sNew lead string: "]) #@171 *Set the topic-header leading string to specified string. Useful when for encapsulating outline structure in programming language comments. Returns the leading string. (defalias 'outline-lead-with-comment-string #[(&optional header-lead) "; !!" [header-lead read-string "String prefix for topic headers: " nil outline-reindent-bodies outline-reset-header-lead] 2 (#$ . -16230) "P"]) #@303 Determine appropriate `outline-header-prefix'. Works according to settings of: `comment-start' `outline-header-prefix' (default) `outline-use-mode-specific-leader' and `outline-mode-leaders'. Apply this via (re)activation of `outline-mode', rather than invoking it directly. (defalias 'outline-infer-header-lead #[nil "! ; > Éł]\f;(\f]\f>7A]\f>]\n]\nGSO˘V\nO[\nQP??s?s*" [boundp outline-use-mode-specific-leader (outline-mode-leaders comment-start t) t use-leader nil (t outline-mode-leaders) major-mode outline-mode-leaders (t comment-start) comment-start " " 0 -1 "_" leader outline-header-prefix] 4 (#$ . 16635)]) #@217 Determine proper setting for `outline-reindent-bodies'. Depends on default setting of `outline-reindent-bodies' (which see) and presence of setting for `comment-start', to tell whether the file is programming code. (defalias 'outline-infer-body-reindent #[nil " =?É" [outline-reindent-bodies comment-start force nil] 2 (#$ . 17361)]) #@161 Generate proper topic-header regexp form for outline functions. Works with respect to `outline-plain-bullets-string' and `outline-distinctive-bullets-string'. (defalias 'set-outline-regexp #[nil "Dĉ \n k @J\nG  Wb\nH =F΂W=QW!!PT- A .\nGGS ٰQQ" ["" outline-bullets-string outline-plain-bullets-string outline-distinctive-bullets-string nil new-string index cur-char-string cur-char cur-len cur-string strings 0 45 "--" 93 regexp-quote char-to-string outline-plain-bullets-string-len outline-header-prefix outline-header-subtraction "\\(\\" "[ ]*[" "]\\)\\|\\" outline-primary-bullet "+\\|\f" outline-regexp "\\([\n ]\\)\\(" "\\)" outline-line-boundary-regexp "\\(\\`\\)\\(" outline-bob-regexp] 8 (#$ . 17718) nil]) #@46 Keybindings for (allout) outline minor mode. (defvar outline-mode-map nil (#$ . 18546)) #@210 Produce keymap for use as outline-mode-map, from keymap-list. Built on top of optional BASE-MAP, or empty sparse map if none specified. See doc string for outline-keybindings-list for format of binding list. (defalias 'produce-outline-mode-map #[(keymap-list &optional base-map) "  \"\n)" [base-map make-sparse-keymap map mapcar #[(cell) "\n AA\f @P AB @ A@D#" [apply define-key map cell outline-command-prefix] 5] keymap-list] 3 (#$ . 18641)]) #@155 Variable for use in V18, with outline-added-bindings, for resurrecting, on mode deactivation, bindings that existed before activation. Being deprecated. (defvar outline-prior-bindings nil (#$ . 19113)) #@155 Variable for use in V18, with outline-prior-bindings, for resurrecting, on mode deactivation, bindings that existed before activation. Being deprecated. (defvar outline-added-bindings nil (#$ . 19323)) #@73 Internal outline mode use; settings to be resumed on mode deactivation. (defvar outline-mode-prior-settings nil (#$ . 19532)) (make-variable-buffer-local (quote outline-mode-prior-settings)) #@483 Registers or resumes settings over outline-mode activation/deactivation. First arg is NAME of variable affected. Optional second arg is list containing outline-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. (defalias 'outline-resumptions #[(name &optional value) "  '\f!JCD B! @Lb\f??b\fA@= @LA! ] @\f=V @ B AH )*" [name outline-mode-prior-settings nil prior-capsule on-list value boundp make-local-variable makunbound rebuild] 4 (#$ . 19730)]) #@212 Used to inhibit outline change-protection during file write. See also `outline-post-command-business', `outline-write-file-hook', `outline-before-change-protect', and `outline-post-command-business' functions. (defvar outline-during-write-cue nil (#$ . 20512)) #@347 Used in outline-mode for regulate of concealed-text protection mechanism. Allout outline mode regulates alteration of concealed text to protect against inadvertant, unnoticed changes. This is for use by specific, native outline functions to temporarily override that protection. It's automatically reset to nil after every buffer modification. (defvar outline-override-protect nil (#$ . 20781)) (make-variable-buffer-local (quote outline-override-protect)) #@68 Evaluate EXPRESSION with `outline-override-protect' let-bound 't'. (defalias 'outline-unprotected '(macro . #[(expr) "\nE" [let ((outline-override-protect t)) expr] 3 (#$ . 21246)])) #@201 Amount of successive self-insert actions to bunch together per undo. This is purely a kludge variable, regulating the compensation for a bug in the way that before-change-function and undo interact. (defvar outline-undo-aggregation 30 (#$ . 21439)) (make-variable-buffer-local (quote outline-undo-aggregation)) #@160 Horrible hack used to prevent invalid multiple triggering of outline mode from prop-line file-var activation. Used by outline-mode function to track repeats. (defvar outline-v18/9-file-var-hack nil (#$ . 21758)) #@181 In outline mode, run as a local-write-file-hooks activity. Currently just sets 'outline-during-write-cue', so outline-change- protection knows to keep inactive during file write. (defalias 'outline-write-file-hook #[nil "‡" [t outline-during-write-cue nil] 1 (#$ . 21978)]) #@38 Allout outline mode minor-mode flag. (defvar outline-mode nil (#$ . 22262)) (make-variable-buffer-local (quote outline-mode)) #@55 Return t if outline-mode is active in current buffer. (defalias 'outline-mode-p '(macro . #[nil "" [outline-mode] 1 (#$ . 22394)])) #@108 Outline-mode was last deliberately deactived. So outline-post-command-business should not reactivate it... (defvar outline-explicitly-deactivated nil (#$ . 22535)) (make-variable-buffer-local (quote outline-explicitly-deactivated)) #@1085 Prime outline-mode to enable/disable auto-activation, wrt `outline-layout'. MODE is one of the following symbols: - nil (or no argument) deactivate auto-activation/layou; - 'activate', enable auto-activation only; - 'ask', enable auto-activation, and enable auto-layout but with confirmation for layout operation solicitated 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 `outline-layout' variable. (See `outline-layout' and `outline-expose-topic' docstrings for more details on auto layout). `outline-init' works by setting up (or removing) the outline-mode find-file-hook, and giving `outline-auto-activation' a suitable setting. To prime your emacs session for full auto-outline operation, include the following two lines in your emacs init file: (require 'allout) (outline-init t) (defalias 'outline-init #[(&optional mode) "t P$ǘ !\f = \"t!=Z >R!\fJ! \"\f=q!Ԃ=!=P!ւ!L*" [completing-read "Select outline auto setup mode " "(empty for report, ? for options) " (("nil") ("full") ("activate") ("deactivate") ("ask") ("report") ("")) nil t mode "" report intern-soft outline-find-file-hook outline-auto-activation curr-mode hook delq find-file-hooks message "Allout outline mode auto-activation inhibited." outline-init add-hook activate "Outline mode auto-activation enabled." ask "Outline mode auto-activation and " "-layout (upon confirmation) enabled." "Outline mode auto-activation and -layout enabled." full] 6 (#$ . 22775) nil]) #@7383 Toggle minor mode for controlling exposure and editing of text outlines. Optional arg forces mode reactivation iff arg is positive num or symbol. Allout outline mode provides extensive outline formatting and manipulation capabilities. It is specifically aimed at supporting outline structuring and manipulation of syntax-sensitive text, eg programming languages. (For an example, see the allout code itself, which is organized in outline structure.) It also includes such things as topic-oriented repositioning, cut, and paste; integral outline exposure-layout; incremental search with dynamic exposure/conceament of concealed text; automatic topic-number maintenance; and many other features. See the docstring of the variable `outline-init' for instructions on priming your emacs session for automatic activation of outline-mode, according to file-var settings of the `outline-layout' variable. Below is a description of the bindings, and then explanation of special outline-mode features and terminology. The bindings themselves are established according to the values of variables `outline-keybindings-list' and `outline-command-prefix', each time the mode is invoked. Prior bindings are resurrected when the mode is revoked. Navigation: Exposure Control: ---------- ---------------- C-c C-n outline-next-visible-heading | C-c C-h outline-hide-current-subtree C-c C-p outline-previous-visible-heading | C-c C-i outline-show-children C-c C-u outline-up-current-level | C-c C-s outline-show-current-subtree C-c C-f outline-forward-current-level | C-c C-o outline-show-current-entry C-c C-b outline-backward-current-level | ^U C-c C-s outline-show-all C-c C-e outline-end-of-current-entry | outline-hide-current-leaves C-c C-a outline-beginning-of-current-entry, alternately, goes to hot-spot Topic Header Production: ----------------------- C-c outline-open-sibtopic Create a new sibling after current topic. C-c . outline-open-subtopic ... an offspring of current topic. C-c , outline-open-supertopic ... a sibling of the current topic's parent. Topic Level and Prefix Adjustment: --------------------------------- C-c > outline-shift-in Shift current topic and all offspring deeper. C-c < outline-shift-out ... less deep. C-c outline-rebullet-topic Reconcile bullets of topic and its' offspring - distinctive bullets are not changed, others alternated according to nesting depth. C-c * outline-rebullet-current-heading Prompt for alternate bullet for current topic. C-c # outline-number-siblings Number bullets of topic and siblings - the offspring are not affected. With repeat count, revoke numbering. Topic-oriented Killing and Yanking: ---------------------------------- C-c C-k outline-kill-topic Kill current topic, including offspring. C-k outline-kill-line Like kill-line, but reconciles numbering, etc. C-y outline-yank Yank, adjusting depth of yanked topic to depth of heading if yanking into bare topic heading (ie, prefix sans text). M-y outline-yank-pop Is to outline-yank as yank-pop is to yank Misc commands: ------------- C-c @ outline-resolve-xref pop-to-buffer named by xref (cf outline-file-xref-bullet) C-c c outline-copy-exposed Copy current topic outline sans concealed text, to buffer with name derived from current buffer - "XXX exposed" M-x outlineify-sticky Activate outline mode for current buffer, and establish a default file-var setting for `outline-layout'. ESC ESC (outline-init t) Setup emacs session for outline mode auto-activation. 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 outline-mode keymap control chars. For example, "f" would invoke the command typically bound to "C-c C-f" (\[outline-forward-current-level] `outline-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. Non-literal chars never get this special translation, so you can use them to get away from the hot-spot, and back to normal operation. Note that the command `outline-beginning-of-current-entry' (\[outline-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 can simply hit \[outline-beginning-of-current-entry] twice in a row to get to the hot-spot. Terminology Topic hierarchy constituents - TOPICS and SUBTOPICS: TOPIC: A basic, coherent component of an emacs outline. It can contain other topics, and it can be subsumed 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. ANCESTORS: The topics that contain a topic. PARENT: A topic's immediate ancestor. It has a depth one less than the topic. OFFSPRING: The topics contained by a topic; SUBTOPIC: An immediate offspring of a topic; CHILDREN: The immediate offspring of a topic. SIBLINGS: Topics having the same parent and depth. Topic text constituents: HEADER: The first line of a topic, include the topic PREFIX and header text. PREFIX: The leading text of a topic which 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. PREFIX-LEAD: The string at the beginning of a topic prefix, normally a '.'. It can be customized by changing the setting of `outline-header-prefix' and then reinitializing outline-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 `outline-use-mode-specific-leader' docstring for more detail. PREFIX-PADDING: Spaces or asterisks which separate the prefix-lead and the bullet, according to the depth of the topic. BULLET: A character at the end of the topic prefix, it must be one of the characters listed on 'outline-plain-bullets-string' or 'outline-distinctive-bullets-string'. (See the documentation for these variables for more details.) The default choice of bullet when generating varies in a cycle with the depth of the topic. ENTRY: The text contained in a topic before any offspring. BODY: Same as ENTRY. EXPOSURE: The state of a topic which determines the on-screen visibility of its' offspring and contained text. CONCEALED: Topics and entry text whose display is inhibited. Contiguous units of concealed text is represented by '...' ellipses. (Ref the 'selective-display' var.) 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. (defalias 'outline-mode #[(&optional toggle) "?\n\f\f<\f@\f,\f9,\f!,\fU? @=\n\f @\nT TT\" a\f\" \"!!)!!!!!!\"!#\"#!!\"!! \"\" !1!22M/%/B/%1C\" C\"1 \"!\"74\"\"\"EF:J;;C\":\"*!$?@RC\"!%?@RC\"ABABAC\fDE FG!Љ\f \fHC<HI=HJ=KLMN C#!OPN \"OQN \"bR STU)\n-" [major-mode outline outline-mode active toggle natnump 0 explicit-activation outline-v18/9-file-var-hack command-history same-complex-command nil do-layout string-match "^19.1[89]" emacs-version t outline-explicitly-deactivated "^18." current-local-map curr-loc mapcar #[(cell) " \n@\"\nA@= \n@\n@\f#" [lookup-key curr-loc cell define-key outline-prior-bindings] 5] outline-added-bindings outline-resumptions outline-prior-bindings outline-old-style-prefixes outline-primary-bullet selective-display boundp before-change-function delq outline-pre-command-business pre-command-hook outline-write-file-hook local-write-file-hooks paragraph-start paragraph-separate "^18" auto-fill-hook auto-fill-function outline-former-auto-filler ("*") (nil) outline-infer-header-lead outline-infer-body-reindent set-outline-regexp minor-mode-map-alist produce-outline-mode-map outline-keybindings-list outline-mode-map (outline-mode . outline-mode-map) (outline-mode . outline-mode-map) use-local-map (t) outline-inhibit-protection (outline-before-change-protect) add-hook fill-func-var fill-func (outline-auto-fill) make-local-variable "\\|\\(" outline-regexp "\\)" minor-mode-alist (outline-mode " Outl") outline-layout outline-enwrap-isearch-mode outline-enwrap-isearch run-hooks outline-mode-hook outline-auto-activation activate ask y-or-n-p format "Expose %s with layout '%s'? " buffer-name message "Skipped %s layout." "Adjusting '%s' exposure..." outline-this-or-next-heading err (byte-code "\nC\" \"" [apply outline-expose-topic outline-layout message "Adjusting '%s' exposure... done." buffer-name] 3) ((error (byte-code "\nA@\"!" [message "%s" err sit-for 1] 3)))] 7 (#$ . 24633) "P"]) #@65 Buffer point of the start of the last topic prefix encountered. (defvar outline-recent-prefix-beginning 0 (#$ . 34350)) (make-variable-buffer-local (quote outline-recent-prefix-beginning)) #@63 Buffer point of the end of the last topic prefix encountered. (defvar outline-recent-prefix-end 0 (#$ . 34545)) (make-variable-buffer-local (quote outline-recent-prefix-end)) #@63 Buffer point last returned by outline-end-of-current-subtree. (defvar outline-recent-end-of-subtree 0 (#$ . 34726)) (make-variable-buffer-local (quote outline-recent-end-of-subtree)) #@129 Register outline-prefix state data - BEGINNING and END of prefix. For reference by 'outline-recent' funcs. Returns BEGINNING. (defalias 'outline-prefix-data '(macro . #[(beg end) "\n\f" [setq outline-recent-prefix-end end outline-recent-prefix-beginning beg] 5 (#$ . 34916)])) #@312 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 outline-recent-prefix-beginning and outline-recent-prefix-end if successful. This function uses those settings to return the current depth. (defalias 'outline-recent-depth '(macro . #[nil "" [(max 1 (- outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction))] 1 (#$ . 35208)])) #@307 Like outline-recent-depth, but returns text of last encountered prefix. All outline functions which directly do string matches to assess headings set the variables outline-recent-prefix-beginning and outline-recent-prefix-end if successful. This function uses those settings to return the current depth. (defalias 'outline-recent-prefix '(macro . #[nil "" [(buffer-substring outline-recent-prefix-beginning outline-recent-prefix-end)] 1 (#$ . 35696)])) #@345 Like outline-recent-prefix, but returns bullet of last encountered prefix. All outline functions which directly do string matches to assess headings set the variables outline-recent-prefix-beginning and outline-recent-prefix-end if successful. This function uses those settings to return the current depth of the most recently matched topic. (defalias 'outline-recent-bullet '(macro . #[nil "" [(buffer-substring (1- outline-recent-prefix-end) outline-recent-prefix-end)] 1 (#$ . 36160)])) #@111 Return non-nil if point is on current visible topics' header line. Actually, returns prefix beginning point. (defalias 'outline-on-current-heading-p #[nil "y\n!)" [0 looking-at outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning] 2 (#$ . 36661)]) #@75 True if point is located where current topic prefix ends, heading begins. (defalias 'outline-e-o-prefix-p #[nil "y\n!)` `)U" [0 looking-at outline-regexp outline-end-of-prefix] 2 (#$ . 36951)]) #@34 True if point is in hidden text. (defalias 'outline-hidden-p '(macro . #[nil "" [(save-excursion (and (re-search-backward "[\n ]" nil t) (= 13 (following-char))))] 1 (#$ . 37162)])) #@38 True if point is not in hidden text. (defalias 'outline-visible-p '(macro . #[nil "" [(not (outline-hidden-p))] 1 (#$ . 37352) nil])) #@76 Like outline-current-depth, but respects hidden as well as visible topics. (defalias 'outline-depth '(macro . #[nil "" [(save-excursion (if (outline-goto-prefix) (outline-recent-depth) (progn (outline-prefix-data (point) (point)) 0)))] 1 (#$ . 37494)])) #@74 Return nesting depth of visible topic most immediately containing point. (defalias 'outline-current-depth '(macro . #[nil "" [(save-excursion (if (outline-back-to-current-heading) (max 1 (- outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction)) 0))] 1 (#$ . 37756)])) #@36 Topic prefix of the current topic. (defalias 'outline-get-current-prefix #[nil " \n{)" [outline-goto-prefix outline-recent-prefix-beginning outline-recent-prefix-end] 2 (#$ . 38064)]) #@53 Return bullet of containing topic (visible or not). (defalias 'outline-get-bullet #[nil " \n S {)" [outline-goto-prefix outline-recent-prefix-end] 2 (#$ . 38261)]) #@74 Return bullet of current (visible) topic heading, or none if none found. (defalias 'outline-current-bullet #[nil "" [err (byte-code " Z {)" [outline-back-to-current-heading outline-recent-prefix-end 1] 2) ((args-out-of-range))] 3 (#$ . 38436)]) #@55 Return the bullet of the header prefix string PREFIX. (defalias 'outline-get-prefix-bullet #[(prefix) " \n\"\nÕSÕO" [string-match outline-regexp prefix 0] 3 (#$ . 38698)]) #@133 Move to the heading for the topic (possibly invisible) before this one. Returns the location of the heading, or nil if none found. (defalias 'outline-next-heading '(macro . #[nil "" [(if (re-search-forward outline-line-boundary-regexp nil 0) (progn (outline-prefix-data (goto-char (or (match-beginning 2) outline-recent-prefix-beginning)) (or (match-end 2) outline-recent-prefix-end))))] 1 (#$ . 38884)])) #@45 Position cursor on current or next heading. (defalias 'outline-this-or-next-heading #[nil " ?\"\n#\"ŕŔb" [outline-goto-prefix re-search-forward outline-line-boundary-regexp nil 0 2 outline-recent-prefix-end outline-recent-prefix-beginning] 4 (#$ . 39299)]) #@129 Move to the prior (possibly invisible) heading line. Return the location of the beginning of the heading, or nil if not found. (defalias 'outline-previous-heading '(macro . #[nil "" [(if (bobp) nil (outline-goto-prefix) (if (or (re-search-backward outline-line-boundary-regexp nil 0) (looking-at outline-bob-regexp)) (progn (outline-prefix-data (goto-char (or (match-beginning 2) outline-recent-prefix-beginning)) (or (match-end 2) outline-recent-prefix-end)))))] 1 (#$ . 39589)])) #@923 Produce a location "chart" of subtopics of the containing topic. Optional argument LEVELS specifies the depth (releative to start depth) for the chart. Subsequent optional args are not for public use. 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 itself. 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. (defalias 'outline-chart-subtree #[(&optional levels orig-depth prev-depth) "?L Z Z]%``) 0T  #LΕ@ΔIbmZ Z]W \nU` BX\n!L\nZ Z]X #ΕΔb~ #ΕΔb \nWVS\n# BL\fmuh>`Z]`{H>u` +" [orig-depth nil curr-depth chart original outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 prev-depth re-search-forward outline-line-boundary-regexp 2 levels outline-next-sibling outline-chart-subtree -1 (10 13) 3 (10 13) outline-recent-end-of-subtree] 5 (#$ . 40081)]) #@170 Produce a list of locations of this and succeeding sibling topics. Effectively a top-level chart of siblings. See 'outline-chart-subtree' for an explanation of charts. (defalias 'outline-chart-siblings #[(&optional start end) " `C ` B  ))" [outline-goto-prefix chart outline-next-sibling] 2 (#$ . 41711)]) #@151 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. (defalias 'outline-chart-to-reveal #[(chart depth) " = VSS@<> =( S\"5\n\"A) bhUK \nBA\n*" [nil here result depth t 0 chart outline-chart-to-reveal further append 13] 5 (#$ . 42046)]) #@998 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 openned. - Lists signify the beginning and end points of regions that should be flagged, and the flag to employ. (For concealment: '(?r)', and exposure: (defalias 'outline-chart-spec #[(chart spec &optional exposing) "\fA" [spec nil] 2 (#$ . 42441)]) #@245 Put point at beginning of outline prefix for immediately containing topic. Goes to first subsequent topic if none immediately containing. Not sensitive to topic visibility. Returns a the point at the beginning of the prefix, or nil if none. (defalias 'outline-goto-prefix #[nil " ,#,u!&Ǖǔ uos!CǕǔ t\f#o͕S͔\\ b oǕǔ t t )" [nil done re-search-backward "[\n ]" 1 looking-at outline-regexp 0 outline-recent-prefix-end outline-recent-prefix-beginning -1 re-search-forward outline-line-boundary-regexp 2] 5 (#$ . 43554)]) #@173 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. (defalias 'outline-end-of-prefix #[(&optional ignore-decorations) " ??E •b +!ul+!+u !) C\n Z\fZ]D)" [outline-goto-prefix match-data 0 ignore-decorations looking-at "[0-9]" 1 "\\s-" store-match-data outline-back-to-current-heading outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction] 3 (#$ . 44160)]) #@54 Return position of current (visible) topic's bullet. (defalias 'outline-current-bullet-pos #[nil " \n Z\fZ])??ŕS" [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0] 3 (#$ . 44712)]) #@77 Move to heading line of current topic, or beginning if already on the line. (defalias 'outline-back-to-current-heading #[nil "y \fQ#ȕ Ȕ\nt# " [0 outline-on-current-heading-p re-search-backward "^\\(" outline-regexp "\\)" nil move 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-end-of-prefix] 4 (#$ . 44987)]) #@86 Skip forward to just before the next heading line. Returns that character position. (defalias 'outline-pre-next-preface #[nil " #ĔbŕŔ" [re-search-forward outline-line-boundary-regexp nil move 0 2 outline-recent-prefix-end outline-recent-prefix-beginning] 4 (#$ . 45347)]) #@71 Put point at the end of the last leaf in the currently visible topic. (defalias 'outline-end-of-current-subtree #[nil " \n Z\fZ]##ʕ\nʔ! bmN\n Z\fZ] VN##ʕB\nʔI b#mUuh>l`Z]`{H>lu`)" [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction level re-search-forward outline-line-boundary-regexp nil 0 2 -1 (10 13) 3 (10 13) outline-recent-end-of-subtree] 4 (#$ . 45640) nil]) #@208 When not already there, position point at beginning of current topic's body. If already there, move cursor to bullet for hot-spot operation. (See outline-mode doc string for details on hot-spot operation.) (defalias 'outline-beginning-of-current-entry #[nil "` t`U b)" [start-point outline-end-of-prefix outline-current-bullet-pos] 2 (#$ . 46142) nil]) #@61 Position the point at the end of the current topics' entry. (defalias 'outline-end-of-current-entry #[nil " o!u" [outline-show-entry outline-pre-next-preface looking-at "^$" -1] 3 (#$ . 46514) nil]) #@67 Ascend to depth DEPTH, returning depth if successful, nil if not. (defalias 'outline-ascend-to-depth #[(depth) "V \f ZZ]``)X` 7\f ZZ]<``)Ww`w wow \n#d !wΕj\fΔq b%\f ZZ]U bb)t " [depth 0 outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction last-good outline-beginning-of-level re-search-backward outline-line-boundary-regexp nil looking-at outline-bob-regexp 2 outline-end-of-prefix] 4 (#$ . 46734)]) #@90 Descend to depth DEPTH within current topic. Returning depth if successful, nil if not. (defalias 'outline-descend-to-depth #[(depth) "` \n Z\fZ]``) +\n Z\fZ]0``)Vl\n Z\fZ]Ul\n#l̕R\n̔Y bl\n Z\fZ]W |\n Z\fZ]``)V\n Z\fZ]Ub*" [outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 start-depth start-point depth re-search-forward outline-line-boundary-regexp nil 2] 4 (#$ . 47289)]) #@204 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. (defalias 'outline-up-current-level #[(arg &optional dont-complain) " \n Z\fZ]`ʼn \n Z\fZ]Vl\nVloll`\n Z\fZ] WO!4 4 _\n Z\fZ]`) \nZ\nx\nVbt !t łt ," [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction nil return failed last-good present-level arg 0 outline-previous-visible-heading outline-end-of-prefix dont-complain error "Can't ascend past outermost level."] 4 (#$ . 47819) "p"]) #@227 Like outline-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. (defalias 'outline-next-sibling #[(&optional depth backward) "o? $ \f ZZ]#``)` \n 4o5mfo  #S!ЕY\fД` b #Еu\fД| b\f ZZ]  V,m \f ZZ]``)V\f ZZ] U \nb ``)+" [backward depth outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 nil last-depth start-point start-depth re-search-backward outline-line-boundary-regexp looking-at outline-bob-regexp 2 re-search-forward] 4 (#$ . 48577)]) #@229 Like outline-forward-current-level,but backwards & respect invisible topics. Optional DEPTH specifies depth to traverse, default current depth. Optional BACKWARD reverses direction. Return depth if successful, nil otherwise. (defalias 'outline-previous-sibling #[(&optional depth backward) " \n?\"" [outline-next-sibling depth backward] 3 (#$ . 49386)]) #@93 Position cursor at end of previous topic Presumes point is at the start of a topic prefix. (defalias 'outline-snug-back #[nil "o m uo%h>%uo\"h>%u`" [-1 (10 13) (10 13)] 2 (#$ . 49751)]) #@61 Go back to the first sibling at this level, visible or not. (defalias 'outline-beginning-of-level #[nil "!" [outline-end-of-level backward] 2 (#$ . 49965)]) #@55 Go to the last sibling at this level, visible or not. (defalias 'outline-end-of-level #[(&optional backward) " \n Z\fZ]``)\"\n Z\fZ]t. )" [outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 depth outline-previous-sibling nil outline-end-of-prefix] 3 (#$ . 50131)]) #@180 Move to the next ARG'th visible heading line, backward if arg is negative. Move as far as possible in indicated direction (beginning or end of buffer) if headings are exhausted. (defalias 'outline-next-visible-heading #[(arg) "W\n[Â` VQ\n,o-mA yWA ! $ J S c\f }t\f }\n?}-" [arg 0 backward -1 1 step start-point nil prev got looking-at outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning outline-end-of-prefix] 3 (#$ . 50488) "p"]) #@172 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 outline-regexp matches). (defalias 'outline-previous-visible-heading #[(arg) " [!" [outline-next-visible-heading arg] 2 (#$ . 51036) "p"]) #@174 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. (defalias 'outline-forward-current-level #[(arg) " \n Z\fZ])`V` \n \f U4! >[U SoTmx b!e!x\n Z\fZ]\nVJ\n\nU om` S@>mU\n \n Z\fZ]``)V\n Z\fZ]U \f bt??\f  ׂ\n Z\fZ]\f!Z\f!%." [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 arg nil at-boundary last-good last-depth backward start-arg start-point start-depth error "No siblings, not in a topic..." outline-previous-visible-heading outline-next-visible-heading t outline-goto-prefix outline-end-of-prefix "Hit %s level %d topic, traversed %d of %d requested." "first" "last" abs] 8 (#$ . 51330) "p"]) #@45 Inverse of `outline-forward-current-level'. (defalias 'outline-backward-current-level #[(arg) "t\f[!)[!" [arg current-prefix-arg call-interactively outline-forward-current-level] 2 (#$ . 52299) "p"]) #@1067 Outline before-change hook, regulates changes to concealed text. Reveal concealed text that would be changed by current command, and offer user choice to commit or forego the change. Unchanged text is reconcealed. User has option to have changed text reconcealed. Undo commands are specially treated - the user is not prompted for choice, the undoes are always committed (based on presumption that the things being undone were already subject to this regulation routine), and undoes always leave the changed stuff exposed. Changes to concealed regions are ignored while file is being written. (This is for the sake of functions that do change the file during writes, like crypt and zip modes.) Locally bound in outline buffers to 'before-change-function', which in emacs 19 is run before any change to the buffer. (Has no effect in Emacs 18, which doesn't support before-change-function.) Any functions which set ['this-command' to 'undo', or which set] 'outline-override-protect' non-nil (as does, eg, outline-flag-chars) are exempt from this restriction. (defalias 'outline-before-change-protect #[(beg end) " ?\n? Ŏ>%T T b#5gU)U U?U bU#TgU)+ Ўњ!#vgU)} !̊ #gU*܏=b )\"#Z$Z]S! b ) !,*" [outline-mode outline-override-protect outline-during-write-cue match-data match-data ((store-match-data match-data)) this-command (newline open-line) beg end re-search-backward "[\n ]" nil t 13 match-data ((store-match-data match-data)) undo message "Undo! - exposing concealed target..." outline-show-children "Undo!" outline-goto-prefix rehide-place rehide-completely response err (byte-code "l  )Q! >$ʉV>2̉V>?Y=M!\f!!΃\f" [outline-goto-prefix rehide-place outline-show-entry message "Change inside concealed" " region - do it? " "(n or 'y'/'r'eclose)" read-char response (114 82) reclose (121 89 32) t (110 78 127) nil 63 "'r' means 'yes, then reclose" "Please answer y, n, or r" sit-for 1] 5) ((quit)) reclose outline-hide-current-entry-completely outline-hide-current-entry outline-ascend-to-depth 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-show-to-offshoot error "Change within concealed region prevented."] 5 (#$ . 52517)]) #@371 Outline internal var, for `outline-pre-command-business' hot-spot operation. When set, tells post-processing to reposition on topic bullet, and then unset it. Set by outline-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 outline-mode-map. (defvar outline-post-goto-bullet nil (#$ . 54954)) (make-variable-buffer-local (quote outline-post-goto-bullet)) #@362 Outline post-command-hook function. - Null outline-override-protect, so it's not left open. - Implement (and clear) outline-post-goto-bullet, for hot-spot outline commands. - Massages buffer-undo-list so successive, standard character self-inserts are aggregated. This kludge compensates for lack of undo bunching when before-change-function is used. (defalias 'outline-post-command-business #[nil "?? \f< ƚƚ\fAAA \n \f  @ @A@ \f@\n\n@ \nA\f\f ZU @ AZV\fB\fAAAB. b" [outline-mode nil outline-override-protect outline-during-write-cue buffer-undo-list this-command self-insert-command last-command prev-stuff before-prev-stuff cur-cell cur-from cur-to prev-cell prev-from prev-to 1 outline-undo-aggregation outline-post-goto-bullet outline-current-bullet-pos] 4 (#$ . 55444)]) #@661 Outline pre-command-hook function for outline buffers. Implements special behavior when cursor is on bullet char. Self-insert characters are reinterpreted control-character references into the outline-mode-map. The outline-mode post-command hook will position a cursor that has moved as a result of such reinterpretation, on the destination topic's bullet, when the cursor wound up in the The upshot is that you can get easy, single (unmodified) key outline maneuvering and general operations by positioning the cursor on the bullet char, and it continues until you deliberately some non-outline motion command to relocate the cursor off of a bullet char. (defalias 'outline-pre-command-business #[nil "!X X\n=X` =X  X/ZXKYKZ!P\"W*" [boundp outline-mode this-command self-insert-command outline-current-bullet-pos last-command-event this-key-num nil mapped-binding 96 32 64 lookup-key outline-mode-map outline-command-prefix char-to-string t outline-post-goto-bullet] 6 (#$ . 56371)]) #@130 Activate outline-mode when `outline-auto-activation' & `outline-layout' are non-nil. See `outline-init' for setup instructions. (defalias 'outline-find-file-hook #[nil " ?\n!" [outline-auto-activation outline-mode outline-layout t] 2 (#$ . 57430)]) (byte-code "\"\"" [add-hook post-command-hook outline-post-command-business pre-command-hook outline-pre-command-business] 3) #@131 Prompt for and return a bullet char as an alternative to the current one. Offer one suitable for current depth DEPTH as default. (defalias 'outline-solicit-alternate-bullet #[(depth &optional current-bullet) "\n! ! ## ̘$ & +" [current-bullet outline-bullet-for-depth depth default-bullet regexp-sans-escapes outline-bullets-string sans-escapes solicit-char-in-string format "Select bullet: %s ('%s' default): " t choice ""] 6 (#$ . 57834)]) #@219 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... (defalias 'outline-sibling-index #[(&optional depth) "Xe/ %\f ZZ]*``)UN\f ZZ]\"HT2)e\f ZZ]Wd! e)" [depth 0 outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction index outline-previous-sibling nil outline-ascend-to-depth outline-sibling-index] 4 (#$ . 58309)]) #@71 True if bullet is one of those on outline-distinctive-bullets-string. (defalias 'outline-distinctive-bullet #[(bullet) "\n! \"" [string-match regexp-quote bullet outline-distinctive-bullets-string] 3 (#$ . 58911)]) #@58 True if current header prefix bullet is numbered bullet. (defalias 'outline-numbered-type-prefix #[(&optional prefix) "  ! " [outline-numbered-bullet prefix outline-get-prefix-bullet outline-get-bullet] 3 (#$ . 59135)]) #@73 Return outline topic bullet suited to optional DEPTH, or current depth. (defalias 'outline-bullet-for-depth #[(&optional depth) "\n\fZ]H!" [outline-stylish-prefixes char-to-string outline-plain-bullets-string 0 depth 2 outline-plain-bullets-string-len outline-primary-bullet] 5 (#$ . 59376)]) #@1859 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 outline-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. Fourth arg SOLICIT non-nil provokes solicitation from the user of a choice among the valid bullets. (This overrides other all the options, including, eg, a distinctive PRIOR-BULLET.) Fifth arg, NUMBER-CONTROL, matters only if 'outline-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 requre this function counting back the index for each successive sibling). (defalias 'outline-make-topic-prefix #[(&optional prior-bullet new depth solicit number-control index) "\f% Z Z]$``) \f\fX8\f@L\f!\"\f͂@\fZ\"z\f!sj??s)@??@@\f!@\f Z Z]``)X \f Z Z]``)Y\f! ))@=!=88 ?=@\f!!\f !\nl]]ki\f!Tk \"R." [nil body numbering denumbering depth outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 outline-header-prefix header-lead "" outline-primary-bullet outline-old-style-prefixes make-string string-to-char 2 32 solicit outline-solicit-alternate-bullet got outline-numbered-bullet number-control index prior-bullet outline-bullet-for-depth new outline-ascend-to-depth outline-get-bullet sibling-bullet outline-distinctive-bullet bullet-char format "%d" outline-sibling-index] 8 (#$ . 59691)]) #@1153 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 complete empty (not even whitespace), in which case open is done on current line. Nuances: - 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 preceeding sibling, and then open forward from there. (defalias 'outline-open-topic #[(relative-depth &optional before) " \n Z\fZ])\\!\"ʉ ?\f W:!DYD \n Z\fZ]hXa!h h) `)\f bXyV!o) n)U U )? Y oo o  #! ޕ\nޔ b  o  !)XY+ $ނ%!) S gUBu6! !)  ni##ޕy\nޔ b\n Z\fZ]Vy!)y !)o V  !)V !) !)  !) !)m n u #P!ʉ%." [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 relative-depth depth looking-at "^$" nil before opening-on-blank opening-numbered ref-depth outline-ascend-to-depth outline-numbered-bullet outline-descend-to-depth outline-numbered-type-prefix ref-topic dbl-space doing-beginning -1 "^\\s-*$" outline-end-of-current-subtree outline-pre-next-preface outline-goto-prefix re-search-backward outline-line-boundary-regexp outline-bob-regexp 2 t outline-override-protect open-line 13 "[^ \n]" re-search-forward newline insert-string outline-make-topic-prefix " " outline-rebullet-heading] 6 (#$ . 62597)]) #@157 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. (defalias 'outline-open-subtopic #[(arg) " V\"" [outline-open-topic 1 0 arg] 4 (#$ . 65059) "p"]) #@136 Open new topic header at same level as the current one. Negative universal arg means to place the new topic prior to the current one. (defalias 'outline-open-sibtopic #[(arg) "\nV\"" [outline-open-topic 0 arg] 4 (#$ . 65324) "p"]) #@163 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. (defalias 'outline-open-supertopic #[(arg) " V\"" [outline-open-topic -1 0 arg] 4 (#$ . 65567) "p"]) #@65 Name of modal fill function being wrapped by outline-auto-fill. (defvar outline-former-auto-filler nil (#$ . 65840)) #@119 Outline-mode autofill function. Maintains outline hanging topic indentation if `outline-use-hanging-indents' is set. (defalias 'outline-auto-fill #[nil "y ! i\")!# )" [outline-use-hanging-indents 0 looking-at outline-regexp make-string outline-end-of-prefix 32 fill-prefix outline-former-auto-filler do-auto-fill] 3 (#$ . 65964)]) #@207 Reindent body lines which were indented at old-depth to new-depth. Optional arg NUMBER indicates numbering is being added, and it must be accomodated. Note that refill of indented paragraphs is not done. (defalias 'outline-reindent-body #[(old-depth new-depth &optional number) " i Z\\   Ύ#RєѕR!?Ri ZV!\f | \\j!.\n" [outline-end-of-prefix new-margin nil excess old-indent-begin old-indent-end curr-ind old-depth new-depth old-margin t outline-override-protect match-data match-data ((store-match-data match-data)) re-search-forward "[\n ]\\(\\s-*\\)" 1 looking-at outline-regexp 0] 4 (#$ . 66329)]) #@152 Like non-interactive version 'outline-rebullet-heading'. But (only) affects visible heading containing point. With repeat count, solicit for bullet. (defalias 'outline-rebullet-current-heading #[(arg) " ?ĉ%)" [outline-back-to-current-heading outline-end-of-prefix outline-rebullet-heading arg nil t] 6 (#$ . 66991) "P"]) #@1268 Adjust bullet of current topic prefix. All args are optional. If SOLICIT is non-nil then the choice of bullet is solicited from user. Otherwise the distinctiveness of the bullet or the topic depth determines it. Second arg DEPTH forces the topic prefix to that depth, regardless of the topics current depth. Third arg NUMBER-CONTROL can force the prefix to or away from numbered form. It has effect only if 'outline-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 outline-make-topic-prefix. Fifth arg DO-SUCCESSORS t means re-resolve count on succeeding siblings. Cf vars 'outline-stylish-prefixes', 'outline-old-style-prefixes', and 'outline-numbered-bullet', which all affect the behavior of this function. (defalias 'outline-rebullet-heading #[(&optional solicit new-depth number-control index do-successors) " \n Z\fZ]``) \n Z {\n\n &UX\nGSOXт |)b\n!Ŕŕ|)!)U\"\"T?  %)." [outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 current-depth new-depth mb me current-bullet outline-make-topic-prefix nil solicit number-control index new-prefix t outline-override-protect outline-numbered-bullet looking-at "[0-9]+" insert-string outline-reindent-bodies outline-reindent-body do-successors outline-next-sibling outline-sibling-index outline-numbered-type-prefix outline-rebullet-heading] 8 (#$ . 67334)]) #@190 Like outline-rebullet-topic-grunt, but start from topic visible at point. Descends into invisible as well as visible topics, however. With repeat count, shift topic depth by that amount. (defalias 'outline-rebullet-topic #[(arg) "il\n\n<\n@\nU !  Z\nZ]\n\\X8!\n!\nUF!) \n\\]!*" [was-eol start-col arg 0 message "Shifting..." outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction error "Attempt to shift topic below level 1" outline-rebullet-topic-grunt "Shifting... done." move-to-column] 4 (#$ . 69427) "P"]) #@379 Rebullet the topic at point, visible or invisible, and all contained subtopics. See outline-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 itself. The are STARTING-DEPTH, STARTING-POINT, and INDEX. (defalias 'outline-rebullet-topic-grunt #[(&optional relative-depth starting-depth starting-point index do-successors) " \f ZZ]``)& ?\n @U>\n?@  W  M` \nf f\\Vf!U\\ % #ԕ\fԔ bm\f ZZ]W T T  $W  $\nU\f ZZ]U\f ZZ]\\Uщ% bU?щ%." [relative-depth 0 outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction new-depth starting-depth starting-point on-starting-call index outline-sibling-index moving-outwards error "Attempt to shift topic out beyond level 1." outline-rebullet-heading nil re-search-forward outline-line-boundary-regexp 2 outline-rebullet-topic-grunt do-successors t] 6 (#$ . 70056)]) #@134 Renumber siblings at current depth. Affects superior topics if optional arg DEPTH is less than current depth. Returns final depth. (defalias 'outline-renumber-to-depth #[(&optional depth) " \n Z\fZ]``)m ,\n Z\fZ]1``)\n Z\fZ]YYmv\n Z\fZ]Vv #J˕j\n˔q bJ\n Z\fZ]S\n Z\fZ]Yʉ%)\n Z\fZ]" [outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 ascender depth re-search-forward outline-line-boundary-regexp nil 2 outline-rebullet-heading t] 6 (#$ . 71272)]) #@259 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. (defalias 'outline-number-siblings #[(&optional denumber) " \fZ Z]?ǚ \n \f H\n\f % < T \f\" '-" [outline-back-to-current-heading outline-beginning-of-level 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction denumber (16) t more use-bullet index depth outline-rebullet-heading nil outline-next-sibling] 7 (#$ . 71871) "P"]) #@71 Increase depth of current heading and any topics collapsed within it. (defalias 'outline-shift-in #[(arg) " !" [outline-rebullet-topic arg] 2 (#$ . 72540) "p"]) #@71 Decrease depth of current heading and any topics collapsed within it. (defalias 'outline-shift-out #[(arg) " [!" [outline-rebullet-topic arg] 2 (#$ . 72709) "p"]) #@66 Kill line, adjusting subsequent lines suitably for outline mode. (defalias 'outline-kill-line #[(&optional arg) " n ! ! ) Z\nZ]0`` )\f !! !^#^ѕRє[ b \f!*" [outline-mode outline-numbered-bullet looking-at outline-regexp kill-line arg outline-goto-prefix 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 depth sit-for re-search-forward outline-line-boundary-regexp nil 2 outline-renumber-to-depth] 4 (#$ . 72880) "*P"]) #@99 Kill topic together with subtopics. Leaves primary topic's trailing vertical whitespace, if any. (defalias 'outline-kill-topic #[nil " y\f ZZ] mL!I\f#EΕ-\fΔ4 bE\f ZZ]Y)Lu\n`\"!!+" [outline-back-to-current-heading 0 beg 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction depth outline-end-of-current-subtree looking-at "^$" re-search-forward outline-line-boundary-regexp nil 2 kill-region sit-for outline-renumber-to-depth] 4 (#$ . 73407) nil]) #@721 Incidental outline-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 appropropriate. 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-outline-specific yanks. (defalias 'outline-yank-processing #[(&optional arg) " `W\n `  'Q!'ɕ\nɔ \f5n5! \fhɕ\nZ\n ZZ]\nS\n{ bl\nb!y`\nU?!ҕ\nҔ \n ZZ]) c!!\n }db!!) \n ZZ]`\n` )S!Z! `\n` *o?~u\n`})!!'\"<y`\n| ԓ\nb f``Z\\\\|!V!I!f!f . !!\nb Ԋ \n ZZ]`\n` )ԉ%!)\f? ," [mark-marker exchange-point-and-mark subj-beg subj-end outline-e-o-prefix-p looking-at "\\(" outline-regexp "\\)" 1 outline-recent-prefix-end outline-recent-prefix-beginning resituate rectify-numbering prefix-len outline-header-subtraction subj-depth prefix-bullet 0 adjust-to-depth nil done t more outline-numbered-bullet message "... yanking" sit-for "^$" outline-override-protect delete-char -1 outline-back-to-current-heading outline-ascend-to-depth outline-goto-prefix outline-rebullet-topic-grunt "" string-match regexp-quote outline-distinctive-bullets-string outline-end-of-prefix "[0-9]" " " "... reconciling numbers" outline-rebullet-heading] 7 (#$ . 73949) "*P"]) #@1100 Outline-mode yank, with depth and numbering adjustment of yanked topics. Non-topic yanks work no differntly than normal yanks. If a topic is being yanked into a bare topic prefix, the depth of the yanked topic is adjusted to the depth of the topic prefix. 1 we're yanking in an outline-mode buffer 2 the stuff being yanked starts with a valid outline header prefix, and 3 it is being yanked at the end of a line which consists of only a valid topic prefix. If these conditions hold then the depth of the yanked topics are all adjusted the amount it takes to make the first one at 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, (ones that don't qualify for adjustment) are handled exactly like normal yanks. Numbering of yanked topics, and the succesive siblings at the depth into which they're being yanked, is adjusted. Outline-yank-pop works with outline-yank just like normal yank-pop works with normal yank in non-outline buffers. (defalias 'outline-yank #[(&optional arg) "\n! \f " [yank this-command arg outline-mode outline-yank-processing] 2 (#$ . 75865) "*P"]) #@236 Yank-pop like outline-yank when popping to bare outline prefixes. Adapts level of popped topics to level of fresh prefix. Note - prefix changes to distinctive bullets will stick, if followed by pops to non-distinctive yanks. Bug... (defalias 'outline-yank-pop #[(&optional arg) " !\f\f " [yank this-command yank-pop arg outline-mode outline-yank-processing] 2 (#$ . 77114) "*p"]) #@133 Pop to file associated with current heading, if it has an xref bullet. (Works according to setting of `outline-file-xref-bullet'). (defalias 'outline-resolve-xref #[nil "! \" `\nb\n#4ΔΕ{+HUG![O#ZA@)!}!u\"!z\"܏\")" [outline-file-xref-bullet error "outline cross references disabled - no 'outline-file-xref-bullet'" outline-current-bullet "current heading lacks cross-reference bullet '%s'" nil file-name outline-recent-prefix-end text-start outline-pre-next-preface heading-end re-search-forward "\\s-\\(\\S-*\\)" t 1 0 58 expand-file-name reference-registered-file reg-ref file-exists-p file-writable-p y-or-n-p format "%s not there, create one? " "%s not found and can't be created" failure (find-file-other-window file-name) ((error failure)) "%s not found"] 5 (#$ . 77512) nil]) #@204 Hide or show lines from FROM to TO, via emacs selective-display FLAG char. Ie, text following flag C-m (carriage-return) is hidden until the next C-j (newline) char. Returns the endpoint of the region. (defalias 'outline-flag-region '(macro . #[(from to flag) " \fBBBBBBBBBE" [let ((buffer-read-only nil) (outline-override-protect t)) subst-char-in-region from to if = flag (10) (13 10) (t)] 9 (#$ . 78405)])) #@95 Hide or show subtree of currently-visible topic. See `outline-flag-region' for more details. (defalias 'outline-flag-current-subtree #[(flag) " ` `SUɂ%+" [outline-back-to-current-heading nil t outline-override-protect buffer-read-only subst-char-in-region outline-end-of-current-subtree flag 10 13] 6 (#$ . 78835)]) #@559 Produce a list representing exposed topics in current region. This list can then be used by 'outline-process-exposed' to manipulate the subject region. List is composed of elements that may themselves be lists representing exposed components in subtopic. Each component list contains: - a number representing the depth of the topic, - a string representing the header-prefix (ref. 'outline-header-prefix'), - a string representing the bullet character, - and a series of strings, each containing one line of the exposed portion of the topic entry. (defalias 'outline-listify-exposed #[(&optional start end) " by $!m`VZZ]S{!`!?y`b`VՊ`)#hU~`S`{ B`Wy`_\f E \" B$ . " [nil strings pad result depth bullet beg next done start 0 outline-goto-prefix outline-next-visible-heading 1 end outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-end-of-prefix t search-forward " " 13 append outline-header-prefix] 5 (#$ . 79183) "r"]) #@511 Map function on exposed parts of current topic; results to another buffer. Apply FUNCTION (default 'outline-insert-listified) to exposed portions FROM position TO position (default region, or the entire buffer if no region active) in buffer FROMBUF (default current buffer) to buffer TOBUF (default is buffer named like frombuf but with "*" prepended and " exposed*" appended). The function must as its arguments the elements of the list representations of topic entries produced by outline-listify-exposed. (defalias 'outline-process-exposed #[(&optional func from to frombuf tobuf) "\n \f  edH!K!\n@Q!D\n)Kp`!i!i!Qq\n \"q@A@A@AA@AAAF\"~!+" [func outline-insert-listified from to mark-active region-beginning region-end frombuf bufferp get-buffer got error "outline-process-exposed: source buffer " " not found." tobuf get-buffer-create "*" buffer-name " exposed*" outline-listify-exposed listified outline-header-prefix prefix nil curr apply pop-to-buffer] 7 (#$ . 80275)]) #@354 Like `outline-show-current-entry', reveals entries nested in hidden topics. This is a way to give restricted peek at a concealed locality without the expense of exposing its context, but can leave the outline with aberrant exposure. outline-hide-current-entry-completely or outline-show-offshoot should be used after the peek to rectify the exposure. (defalias 'outline-show-entry #[nil " o``S `%+" [outline-goto-prefix nil t outline-override-protect buffer-read-only subst-char-in-region outline-pre-next-preface 13 10] 6 (#$ . 81384) nil]) #@562 If point is visible, show all direct subheadings of this heading. Otherwise, do outline-show-to-offshoot, and then show subheadings. Optional LEVEL specifies how many levels below the current level should be shown, or all levels if t. Default is 1. Optional STRICT means don't resort to -show-to-offshoot, no matter what. This is basically so -show-to-offshoot, which is called by this function, can employ the pure offspring-revealing capabilities of it. Returns point at end of subtree that was opened, if any. (May get a point of non-opened subtree?) (defalias 'outline-show-children #[(&optional level strict) "\n##gU)#  \"`\n /!   ;\"\nb\n\\hU\\` %*@b` %*Aa-)" [nil max-pos strict re-search-backward "[\n ]" t 13 outline-show-to-offshoot outline-show-children level start-pt outline-chart-subtree 1 chart outline-chart-to-reveal to-reveal outline-override-protect buffer-read-only subst-char-in-region outline-snug-back 10] 7 (#$ . 81957) "p"]) #@400 This command was misnamed, use `outline-show-children' instead. (The "current" in the name is supposed to imply that it works on the visible topic containing point, while it really works with respect to the most immediate topic, concealed or not. I'll leave this old name around for a bit, but i'll soon activate an annoying message to warn people about the change, and then deprecate this alias. (defalias 'outline-show-current-children #[(&optional level strict) " \n\"" [outline-show-children level strict] 3 (#$ . 83011) "p"]) #@228 Like `outline-hide-current-entry'; hides completely if within hidden region. Specifically intended for aberrant exposure states, like entries that were exposed by outline-show-entry but are within otherwise concealed regions. (defalias 'outline-hide-reconcile #[nil " o`S` gU `\"`S%+" [outline-goto-prefix nil t outline-override-protect buffer-read-only subst-char-in-region outline-pre-next-preface 13 10] 6 (#$ . 83553) nil]) #@205 Like outline-show-entry, but reveals opens all concealed ancestors, as well. As with outline-hide-current-entry-completely, useful for rectifying aberrant exposure states produced by outline-show-entry. (defalias 'outline-show-to-offshoot #[nil "` `\nhU<y `U3y b # \fb\n b-#LgU)R " [outline-goto-prefix nil bag-it last-at orig-pref orig-pt 13 0 outline-show-current-subtree t beep message "%s: %s" "outline-show-to-offshoot: " "Aberrant nesting encountered." outline-show-children re-search-backward "[\n ]" outline-show-entry] 4 (#$ . 84014) nil]) #@48 Hide the body directly following this heading. (defalias 'outline-hide-current-entry #[nil " ` `%+" [outline-back-to-current-heading nil t outline-override-protect buffer-read-only subst-char-in-region outline-end-of-current-entry 10 13] 6 (#$ . 84622) nil]) #@73 Show body following current heading, or hide the entry if repeat count. (defalias 'outline-show-current-entry #[(&optional arg) " ` `%+" [arg outline-hide-current-entry nil t outline-override-protect buffer-read-only subst-char-in-region outline-end-of-current-entry 13 10] 6 (#$ . 84901) "P"]) #@214 Like outline-hide-current-entry, but conceal topic completely. Specifically intended for aberrant exposure states, like entries that were exposed by outline-show-entry but are within otherwise concealed regions. (defalias 'outline-hide-current-entry-completely #[nil " o`S` gU `\"`S%+" [outline-goto-prefix nil t outline-override-protect buffer-read-only subst-char-in-region outline-pre-next-preface 13 10] 6 (#$ . 85221) nil]) #@102 Show everything within the current topic. With a repeat-count, expose this topic and its' siblings. (defalias 'outline-show-current-subtree #[(&optional arg) " \n Z\fZ])XO#4ɕ'\nɔ. b:!`!ed%*`Z!` !)" [outline-back-to-current-heading 1 outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 re-search-forward outline-line-boundary-regexp nil 2 error "No topics." message "Above outermost topic - exposing all." t outline-override-protect buffer-read-only subst-char-in-region 13 10 arg outline-flag-current-subtree outline-beginning-of-level outline-expose-topic (* :)] 6 (#$ . 85683) "P"]) #@287 Close the current topic, or containing topic if this one is already closed. If this topic is closed and it's a top level topic, close this topic and its' siblings. If optional arg JUST-CLOSE is non-nil, do not treat the parent or siblings, even if the target topic is already closed. (defalias 'outline-hide-current-subtree #[(&optional just-close) "` !`! b\fb`Uee be\"Sb!!P!)eZZ]Ue b*" [nil outline-goto-prefix error "No topics found." orig-eol from outline-flag-current-subtree 13 just-close outline-up-current-level 1 t 0 "Top-level topic already closed - closing siblings..." msg message outline-expose-topic (0 :) " Done." outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-hide-current-subtree] 3 (#$ . 86375) nil]) #@61 Show all subheadings of this heading, but not their bodies. (defalias 'outline-show-current-branches #[nil "y!" [0 outline-show-children t] 2 (#$ . 87220) nil]) #@62 Hide the bodies of the current topic and all its' offspring. (defalias 'outline-hide-current-leaves #[nil " ` `\"" [outline-back-to-current-heading outline-hide-region-body outline-end-of-current-subtree] 3 (#$ . 87392) nil]) #@37 Show all of the text in the buffer. (defalias 'outline-show-all #[nil "!ed%*!" [message "Exposing entire buffer..." nil t outline-override-protect buffer-read-only subst-char-in-region 13 10 "Exposing entire buffer... Done."] 6 (#$ . 87630) nil]) #@37 Hide all of buffer except headings. (defalias 'outline-hide-bodies #[nil "ed\"" [outline-hide-region-body] 3 (#$ . 87899) nil]) #@54 Hide all body lines in the region, but not headings. (defalias 'outline-hide-region-body #[(start end) " }ebm?2` `%*m !,̂-u *" [start end nil t outline-override-protect buffer-read-only subst-char-in-region outline-pre-next-preface 10 13 looking-at "[\n ][\n ]" 2 1] 6 (#$ . 88035)]) #@2449 Apply exposure specs to successive outline topic items. Use the more convenient frontend, `outline-new-exposure', if you don't need evaluation of the arguments, or even better, the `outline-layout' variable-keyed mode-activation/auto-exposure feature of allout outline mode. See the respective documentation strings for more details. Cursor is left at start position. SPEC is either a number or a list. Successive specs on a list are applied to successive sibling topics. A simple spec (either a number, one of a few symbols, or the null list) dictates the exposure for the corresponding topic. Non-null lists recursively designate exposure specs for respective subtopics of the current topic. The ':' repeat spec is used to specify exposure for any number of successive siblings, up to the trailing ones for which there are explicit specs following the ':'. Simple (numeric and null-list) specs are interpreted as follows: Numbers indicate the relative depth to open the corresponding topic. - 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 offspring. : - 'repeat' apply prior 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 the last ones. (Only first of multiple colons at same level is respected - subsequent ones are discarded.) * - completely opens the topic, including bodies. + - shows all the sub headers, but not the bodies - - exposes the body of the corresponding topic. Examples: (outline-expose-topic '(-1 : 0)) Close this and all following topics at current level, exposing only their immediate children, but close down the last topic at this current level completely. (outline-expose-topic '(-1 () : 1 0)) Close current topic so only the immediate subtopics are shown; show the children in the second to last topic, and completely close the last one. (outline-expose-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 open the last one. (defalias 'outline-expose-topic #[(spec) "#gU);#!u#-gU)5`7`C ) " [outline-mode re-search-backward "[\n ]" nil t 13 outline-line-boundary-regexp 1 outline-show-entry outline-search-reconceal] 4 (#$ . 97188)]) #@116 Do outline business like deexposing current point, if necessary. Works according to reconceal state registration. (defalias 'outline-isearch-advancing-business #[nil "  < @b  b )" [outline-mode outline-search-reconceal outline-hide-current-entry outline-hide-current-entry-completely] 1 (#$ . 97947)]) (defalias 'isearch-terminate/outline-provisions #[nil "  *" [outline-mode outline-enwrap-isearch-mode outline-isearch-advancing-business t nil outline-search-reconceal outline-search-quitting real-isearch-terminate] 2 nil nil]) (defalias 'isearch-done/outline-provisions #[(&optional nopush) "` `\nO\n