;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:36:37 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/allout.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`allout.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301!\210\300\302!\210\303\302\304\305\306\307\310\311&\207" [provide outline allout custom-declare-group nil "Extensive outline mode for use alone and with other modes." :prefix "outline-" :group outlines] 8) #@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. (custom-declare-variable 'outline-auto-activation 'nil '(#$ . -842) :type '(choice (const :tag "On" t) (const :tag "Ask about layout" "ask") (const :tag "Mode only" "activate") (const :tag "Off" nil)) :group 'allout) #@1183 *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 (#$ . -1970)) (make-variable-buffer-local 'outline-layout) #@83 *If non-nil, show entire body when exposing a topic, rather than just the header. (custom-declare-variable 'outline-show-bodies 'nil '(#$ . -3244) :type 'boolean :group 'allout) (make-variable-buffer-local 'outline-show-bodies) #@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. (custom-declare-variable 'outline-header-prefix '"." '(#$ . -3479) :type 'string :group 'allout) (make-variable-buffer-local '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 compatibility with the original emacs outline mode. See outline-plain-bullets-string and outline-distinctive-bullets-string for the range of available bullets. (custom-declare-variable 'outline-primary-bullet '"*" '(#$ . 4010) :type 'string :group 'allout) (make-variable-buffer-local '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. (custom-declare-variable 'outline-plain-bullets-string '".:,;" '(#$ . -4618) :type 'string :group 'allout) (make-variable-buffer-local 'outline-plain-bullets-string) #@1052 *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 quote `=' value settings `~' "more or less" ... just for example. (`#' typically has a special meaning to the software, according to the value of `outline-numbered-bullet'.) See `outline-plain-bullets-string' for the selection of alternating bullets. You must run `set-outline-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 strings. (custom-declare-variable 'outline-distinctive-bullets-string '"*+-=>([{}&!?#%\"X@$~_\\" '(#$ . -5077) :type 'string :group 'allout) (make-variable-buffer-local 'outline-distinctive-bullets-string) #@1081 *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.] (custom-declare-variable 'outline-use-mode-specific-leader 't '(#$ . -6333) :type '(choice (const t) (const nil) string (const outline-mode-leaders) (const comment-start)) :group 'allout) #@422 Specific outline-prefix leading strings per major modes. Entries will be used instead or in 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 (#$ . 7608)) #@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. (custom-declare-variable 'outline-old-style-prefixes 'nil '(#$ . -8082) :type 'boolean :group 'allout) (make-variable-buffer-local '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. (custom-declare-variable 'outline-stylish-prefixes 't '(#$ . -8613) :type 'boolean :group 'allout) (make-variable-buffer-local 'outline-stylish-prefixes) #@311 *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. (custom-declare-variable 'outline-numbered-bullet '"#" '(#$ . -10206) :type '(choice (const nil) string) :group 'allout) (make-variable-buffer-local 'outline-numbered-bullet) #@142 *Bullet signifying file cross-references, for `outline-resolve-xref'. Set this var to the bullet you want to use for file cross-references. (custom-declare-variable 'outline-file-xref-bullet '"@" '(#$ . -10698) :type '(choice (const nil) string) :group 'allout) #@70 *Presentation-format white-space padding factor, for greater indent. (custom-declare-variable 'outline-presentation-padding '2 '(#$ . -10967) :type 'integer :group 'allout) (make-variable-buffer-local 'outline-presentation-padding) #@157 *If non-nil, `outline-flatten-exposed-to-buffer' abbreviates topic numbers to minimal amount with some context. Otherwise, entire numbers are always used. (custom-declare-variable 'outline-abbreviate-flattened-numbering 'nil '(#$ . -11206) :type 'boolean :group 'allout) #@70 *Non-nil turns on page numbering for LaTeX formatting of an outline. (custom-declare-variable 'outline-number-pages 'nil '(#$ . -11484) :type 'boolean :group 'allout) #@62 *Font and size of labels for LaTeX formatting of an outline. (custom-declare-variable 'outline-label-style '"\\large\\bf" '(#$ . -11657) :type 'string :group 'allout) #@63 *Font and size of entries for LaTeX formatting of an outline. (custom-declare-variable 'outline-head-line-style '"\\large\\sl " '(#$ . -11830) :type 'string :group 'allout) #@63 *Font and size of entries for LaTeX formatting of an outline. (custom-declare-variable 'outline-body-line-style '" " '(#$ . -12009) :type 'string :group 'allout) #@62 *Font and size of titles for LaTeX formatting of an outline. (custom-declare-variable 'outline-title-style '"\\Large\\bf" '(#$ . -12177) :type 'string :group 'allout) #@78 *Expression to be evaluated to determine the title for LaTeX formatted copy. (custom-declare-variable 'outline-title ''(or buffer-file-name (current-buffer-name)) '(#$ . -12350) :type 'sexp :group 'allout) #@58 *Space between lines for LaTeX formatting of an outline. (custom-declare-variable 'outline-line-skip '".05cm" '(#$ . -12562) :type 'string :group 'allout) #@40 *LaTeX formatted depth-indent spacing. (custom-declare-variable 'outline-indent '".3cm" '(#$ . -12723) :type 'string :group 'allout) #@75 *Key sequence to be used as prefix for outline mode command key bindings. (custom-declare-variable 'outline-command-prefix '"" '(#$ . -12862) :type 'string :group 'allout) #@189 *List of outline-mode key / function bindings, for outline-mode-map. String or vector key will be prefaced with outline-command-prefix, unless optional third, non-nil element is present. (defvar outline-keybindings-list nil (#$ . -13042)) (byte-code "\301\302\207" [outline-keybindings-list (("" 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) ("\371" outline-yank-pop t) (" " outline-kill-topic) ("@" outline-resolve-xref) ("=c" outline-copy-exposed-to-buffer) ("=i" outline-indented-exposed-to-buffer) ("=t" outline-latexify-exposed) ("=p" outline-flatten-exposed-to-buffer)) nil] 1) #@95 *Non-nil enable dynamic exposure of hidden incremental-search targets as they're encountered. (custom-declare-variable 'outline-isearch-dynamic-expose 't '(#$ . -14293) :type 'boolean :group 'allout) (make-variable-buffer-local 'outline-isearch-dynamic-expose) #@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.] (custom-declare-variable 'outline-use-hanging-indents 't '(#$ . -14561) :type 'boolean :group 'allout) (make-variable-buffer-local '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. (custom-declare-variable 'outline-reindent-bodies '(if outline-use-hanging-indents 'text) '(#$ . -15049) :type '(choice (const nil) (const t) (const text) (const force)) :group 'allout) (make-variable-buffer-local '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. (custom-declare-variable 'outline-inhibit-protection 'nil '(#$ . -15725) :type 'boolean :group 'allout) #@67 Revision number of currently loaded outline package. (allout.el) (defvar outline-version (byte-code "\301\302\303\304\217)\207" [rcs-rev "$Revision: 1.29.4.2 $" err (byte-code "\302 \303\216\304\305 \"\210 \306\224\306\225O*\207" [save-match-data-internal rcs-rev match-data ((set-match-data save-match-data-internal)) string-match "Revision: \\([0-9]+\\.[0-9]+\\)" 1] 3) (('error rcs-rev))] 3) (#$ . 16262)) #@54 Return string describing the loaded outline version. (defalias 'outline-version #[(&optional here) "\303P\n\203\f\304 !\210\305\306 \"\210 )\207" [outline-version msg here "Allout Outline Mode v " insert-string message "%s"] 3 (#$ . 16680) "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 "" (#$ . -16936)) (make-variable-buffer-local '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 "" (#$ . 17243)) (make-variable-buffer-local 'outline-bullets-string) #@58 Length of current buffers' outline-plain-bullets-string. (defvar outline-bullets-string-len 0 (#$ . 17598)) (make-variable-buffer-local '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 (#$ . 17770)) (make-variable-buffer-local '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 (#$ . 18149)) (make-variable-buffer-local 'outline-bob-regexp) #@70 Outline-header prefix length to subtract when computing topic depth. (defvar outline-header-subtraction (byte-code "GS\207" [outline-header-prefix] 1) (#$ . 18378)) (make-variable-buffer-local '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) (#$ . 18607)) (make-variable-buffer-local 'outline-plain-bullets-string-len) #@59 *Reset the leading string used to identify topic headers. (defalias 'outline-reset-header-lead #[(header-lead) "\211GS\303 \207" [header-lead outline-header-prefix outline-header-subtraction set-outline-regexp] 2 (#$ . -18840) "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) ";\204 \302\303!\304\305!\210\207" [header-lead outline-reindent-bodies read-string "String prefix for topic headers: " nil outline-reset-header-lead] 2 (#$ . -19100) "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 "\306\300!\205;\204\307>\203\202\310\211\204\311\202W ;\203( \202W \312>\2035\n \236A\206W \313>\205W\f\205W\f\211GS\311O\314\230\203Q\f\315\316O\202U\f\211\211Q\317P\211\205h \230?\205h \211*\207" [outline-use-mode-specific-leader use-leader major-mode outline-mode-leaders comment-start leader boundp (outline-mode-leaders comment-start t) t nil (t outline-mode-leaders) (t comment-start) " " 0 -1 "_" outline-header-prefix] 4 (#$ . 19526)]) #@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 "\205 \205\302=?\205\303\211\207" [outline-reindent-bodies comment-start force nil] 2 (#$ . 20352)]) #@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 "\306\307\310\311E\312\211\211\211\211\211\211\203]\306\313@J\211G\n W\203T\nH\f\314=\203<\315\202K\f\316=\203F\306\202K\317\320\f!!P\nT\211\202'A\211\204.GGS\321\322\323 \324\260\325\326Q\327\326Q\211\207" [outline-bullets-string new-string index cur-char-string cur-char cur-len "" outline-plain-bullets-string outline-distinctive-bullets-string outline-primary-bullet nil 0 45 "--" 93 regexp-quote char-to-string "\\(\\" "[ ]*[" "]\\)\\|\\" "+\\|\f" "\\([\n ]\\)\\(" "\\)" "\\(\\`\\)\\(" cur-string strings outline-plain-bullets-string-len outline-header-prefix outline-header-subtraction outline-regexp outline-line-boundary-regexp outline-bob-regexp] 8 (#$ . 20730) nil]) #@46 Keybindings for (allout) outline minor mode. (defvar outline-mode-map nil (#$ . 21670)) #@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) "\206\305 C\306\307\f\"\210 *\207" [base-map outline-command-prefix pref map keymap-list make-sparse-keymap mapcar #[(cell) "AA?@C\305\306 \305\307\n\203\310\f \"\202 \"A@E\"*\207" [cell key-suff add-pref map pref apply define-key concat append] 8]] 3 (#$ . 21765)]) #@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 (#$ . 22334)) #@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 (#$ . 22544)) (defalias 'produce-outline-mode-menubar-entries #[nil "\305\306!\210\307\300\310\311#\210\312\300!\204\313\314\300 \311\315$\210\307\302\310\316#\210\312\302!\204'\313\314\302 \316\317$\210\307\303\310\320#\210\312\303!\204<\313\314\303 \320\321$\210\307\304\310\322#\210\312\304!\204Q\313\314\304 \322\323$\207" [outline-mode-exposure-menu outline-mode-map outline-mode-editing-menu outline-mode-navigation-menu outline-mode-misc-menu require easymenu put variable-documentation "Allout outline exposure menu." boundp nil easy-menu-do-define ("Exposure" ["Show Entry" outline-show-current-entry t] ["Show Children" outline-show-children t] ["Show Subtree" outline-show-current-subtree t] ["Hide Subtree" outline-hide-current-subtree t] ["Hide Leaves" outline-hide-current-leaves t] "----" ["Show All" outline-show-all t]) "Allout outline editing menu." ("Headings" ["Open Sibling" outline-open-sibtopic t] ["Open Subtopic" outline-open-subtopic t] ["Open Supertopic" outline-open-supertopic t] "----" ["Shift Topic In" outline-shift-in t] ["Shift Topic Out" outline-shift-out t] ["Rebullet Topic" outline-rebullet-topic t] ["Rebullet Heading" outline-rebullet-current-heading t] ["Number Siblings" outline-number-siblings t]) "Allout outline navigation menu." ("Navigation" ["Next Visible Heading" outline-next-visible-heading t] ["Previous Visible Heading" outline-previous-visible-heading t] "----" ["Up Level" outline-up-current-level t] ["Forward Current Level" outline-forward-current-level t] ["Backward Current Level" outline-backward-current-level t] "----" ["Beginning of Entry" outline-beginning-of-current-entry t] ["End of Entry" outline-end-of-current-entry t] ["End of Subtree" outline-end-of-current-subtree t]) "Allout outlines miscellaneous bindings." ("Misc" ["Version" outline-version t] "----" ["Duplicate Exposed" outline-copy-exposed-to-buffer t] ["Duplicate Exposed, numbered" outline-flatten-exposed-to-buffer t] ["Duplicate Exposed, indented" outline-indented-exposed-to-buffer t] "----" ["Set Header Lead" outline-reset-header-lead t] ["Set New Exposure" outline-expose-topic t])] 5]) #@73 Internal outline mode use; settings to be resumed on mode deactivation. (defvar outline-mode-prior-settings nil (#$ . 24874)) (make-variable-buffer-local '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) " \236\306\f\203' \204\307!\205JCD B\310!\210\f@L\202\\ \205\\ A@\211\203;\n@L\210\202?\311!\210\306 \203X @ =\204Q @ B A\211\204E \211)*\207" [name outline-mode-prior-settings prior-capsule on-list value rebuild nil boundp make-local-variable makunbound] 4 (#$ . 25065)]) #@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 (#$ . 25911)) #@98 Cue for isearch-dynamic-exposure mechanism, implemented in outline-pre- and -post-command-hooks. (defvar outline-pre-was-isearching nil (#$ . 26179)) (make-variable-buffer-local 'outline-pre-was-isearching) #@76 Cue for isearch-dynamic-exposure tracking, used by outline-isearch-expose. (defvar outline-isearch-prior-pos nil (#$ . 26392)) (make-variable-buffer-local 'outline-isearch-prior-pos) #@191 Distinguishes isearch conclusion and cancellation. Maintained by outline-isearch-abort (which is wrapped around the real isearch-abort), and monitored by outline-isearch-expose for action. (defvar outline-isearch-did-quit nil (#$ . 26582)) (make-variable-buffer-local 'outline-isearch-did-quit) #@347 Used in outline-mode for regulate of concealed-text protection mechanism. Allout outline mode regulates alteration of concealed text to protect against inadvertent, 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 (#$ . 26885)) (make-variable-buffer-local 'outline-override-protect) #@68 Evaluate EXPRESSION with `outline-override-protect' let-bound `t'. (defalias 'outline-unprotected '(macro . #[(expr) "\301\302E\207" [expr let ((outline-override-protect t))] 3 (#$ . 27343)])) #@202 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-functions and undo interact. (defvar outline-undo-aggregation 30 (#$ . 27544)) (make-variable-buffer-local '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/19-file-var-hack nil (#$ . 27857)) #@180 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 "\301\302\207" [outline-during-write-cue t nil] 1 (#$ . 28078)]) #@38 Allout outline mode minor-mode flag. (defvar outline-mode nil (#$ . 28370)) (make-variable-buffer-local 'outline-mode) #@55 Return t if outline-mode is active in current buffer. (defalias 'outline-mode-p '(macro . #[nil "\300\207" [outline-mode] 1 (#$ . 28495)])) #@110 Outline-mode was last deliberately deactivated. So outline-post-command-business should not reactivate it... (defvar outline-explicitly-deactivated nil (#$ . 28642)) (make-variable-buffer-local 'outline-explicitly-deactivated) #@1084 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/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 `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\203\304\305\306\307\310$\211\311\230\203\312\202\313!\314\315\2041\316\n \"t\205\200\317\320!\202\200\312=\203J\n >\204C\321\307!\202\200\321 J!\202\200\322\303\n\"\210 \323=\203^\317\324!\210\323\202\312=\203j\321!\202\325=\203x\317\326!\210\325\202\317\327!\205\330L*\207" [mode curr-mode hook find-file-hooks completing-read "Select outline auto setup mode (empty for report, ? for options) " (("nil") ("full") ("activate") ("deactivate") ("ask") ("report") ("")) nil t "" report intern-soft outline-find-file-hook outline-auto-activation delq 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 (#$ . 28877) nil]) #@71 Populate the current buffer's menubar with allout outline-mode stuff. (defalias 'outline-setup-menubar #[nil " \n F\306 \205 @ A\307\f!\210\202*\207" [outline-mode-exposure-menu outline-mode-editing-menu outline-mode-navigation-menu outline-mode-misc-menu cur menus nil easy-menu-add] 4 (#$ . 30879)]) #@7653 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 outline.) In addition to outline navigation and exposure, allout includes: - topic-oriented repositioning, cut, and paste - integral outline exposure-layout - incremental search with dynamic exposure and reconcealment of hidden text - automatic topic-number maintenance - "Hot-spot" operation, for single-keystroke maneuvering and exposure control. (See the outline-mode docstring.) and many other features. Below is a description of the bindings, and then explanation of special outline-mode features and terminology. See also the outline menubar additions for quick reference to many of the features, and see the docstring of the variable `outline-init' for instructions on priming your emacs session for automatic activation of outline-mode. The bindings are dictated by the `outline-keybindings-list' and `outline-command-prefix' variables. 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 b 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: ------------- M-x outlineify-sticky Activate outline mode for current buffer, and establish a default file-var setting for `outline-layout'. C-c C-SPC outline-mark-topic C-c = c outline-copy-exposed-to-buffer Duplicate outline, sans concealed text, to buffer with name derived from derived from that of current buffer - "*XXX exposed*". C-c = p outline-flatten-exposed-to-buffer Like above 'copy-exposed', but convert topic prefixes to section.subsection... numeric format. 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) "\306\232?\205  \205 <\203 @\206 \211\205, 9\206,\307 !\205,\310 !? @@=A\311B@@A\203P\n\203P\f\204P\312\313C\"\204\264\f\204\302\n\204\\ \203\302\314D\312\315C\"\203z\316 E\317\320\"\210\321\322!\210\321\323!\210)\203\207\321\324!\210\321\325!\210\321\326!\210\327\330!\203\232\203\232\321\330!\210\331\3324\"4\321\333!\210\321\334!\210\321\312\335C\"\203\266\336\202\267\337!\210\321\340!\210\311\202\264\n\204\252\311D\203\330\321\324\341\"\210\321\325\342\"\210\343 \210\344 \210\345 \210\327\346!\203\347F!)\350 \210\351)M\210\352&\235\204\353&B&\202\321\322FC\"\210\321\323\316 C\"\210\354\347F\316 \"!\210\321\326\355\"\210G\204+\321\330\356\"\210\357\360\361\"\210\357\362\363\"\210\357\364\332\"\210\312\335C\"\203F\336\202G\337\211HJI\321\340IC\"\210\321H\365\"\210*\366\333!\210\321\333\367J\370RC\"\210\366\334!\210\321\334\367J\370RC\"\210\301K\236\204\210\371KBK\372 \210L\203\223\314BM\203\241\373\374!\204\241\375 \210\376\377!\210\314\202\264\314\211B\203\264\344 \210B\203N\203L<\203N\201O=\204N\201P=\203\371\201Q\201R\201S\201T L#!\204\371\201U\201V\201T \"\210\202\212\201U\201W\201T \"\210\201Xb\210\201Y \210\201Z\201[\201\\\217\210) -\207" [major-mode outline-mode active toggle explicit-activation outline-v18/19-file-var-hack outline natnump zerop nil string-match "^19.1[89]" t "^18." current-local-map mapcar #[(cell) "\303 @\" A@=\205\304 @ @\n\236#\207" [curr-loc cell outline-prior-bindings lookup-key define-key] 5] outline-resumptions outline-added-bindings outline-prior-bindings outline-primary-bullet outline-old-style-prefixes selective-display boundp before-change-functions delq outline-write-file-hook 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 produce-outline-mode-menubar-entries outline-mode-map (outline-mode . outline-mode-map) (outline-mode . outline-mode-map) use-local-map (t) (outline-before-change-protect) add-hook pre-command-hook outline-pre-command-business post-command-hook outline-post-command-business local-write-file-hooks (outline-auto-fill) make-local-variable "\\|^\\(" "\\)" (outline-mode " Outl") outline-setup-menubar fboundp outline-real-isearch-abort outline-enwrap-isearch run-hooks outline-mode-hook command-history same-complex-command do-layout emacs-version outline-explicitly-deactivated curr-loc outline-keybindings-list outline-inhibit-protection fill-func-var fill-func outline-regexp minor-mode-alist outline-layout outline-isearch-dynamic-expose outline-auto-activation activate ask y-or-n-p format "Expose %s with layout '%s'? " buffer-name message "Skipped %s layout." "Adjusting '%s' exposure..." 0 outline-this-or-next-heading err (byte-code "\301\302C\"\210\303\304\305 \"\207" [outline-layout apply outline-expose-topic message "Adjusting '%s' exposure... done." buffer-name] 3) ((error (byte-code "\301\302A@\"\210\303\304!\207" [err message "%s" sit-for 1] 3)))] 7 (#$ . 31198) "P"]) (defalias 'outline-minor-mode 'outline-mode) #@65 Buffer point of the start of the last topic prefix encountered. (defvar outline-recent-prefix-beginning 0 (#$ . 42144)) (make-variable-buffer-local 'outline-recent-prefix-beginning) #@63 Buffer point of the end of the last topic prefix encountered. (defvar outline-recent-prefix-end 0 (#$ . 42332)) (make-variable-buffer-local 'outline-recent-prefix-end) #@63 Buffer point last returned by outline-end-of-current-subtree. (defvar outline-recent-end-of-subtree 0 (#$ . 42506)) (make-variable-buffer-local '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) "\302\303\304 \257\207" [end beg setq outline-recent-prefix-end outline-recent-prefix-beginning] 5 (#$ . 42689)])) #@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 "\300\207" [(max 1 (- outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction))] 1 (#$ . 42994)])) #@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 "\300\207" [(buffer-substring outline-recent-prefix-beginning outline-recent-prefix-end)] 1 (#$ . 43488)])) #@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 "\300\207" [(buffer-substring (1- outline-recent-prefix-end) outline-recent-prefix-end)] 1 (#$ . 43958)])) #@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 "\212\303 \210\304!\205\305\225\305\224\211)\207" [outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning beginning-of-line looking-at 0] 2 (#$ . 44465)]) (defalias 'outline-on-heading-p 'outline-on-current-heading-p) #@75 True if point is located where current topic prefix ends, heading begins. (defalias 'outline-e-o-prefix-p #[nil "\212\301 \210\302!)\205`\212\303 \210`)U\207" [outline-regexp beginning-of-line looking-at outline-end-of-prefix] 2 (#$ . 44868)]) #@34 True if point is in hidden text. (defalias 'outline-hidden-p '(macro . #[nil "\300\207" [(save-excursion (and (re-search-backward "[\n ]" nil t) (= 13 (following-char))))] 1 (#$ . 45121)])) #@38 True if point is not in hidden text. (defalias 'outline-visible-p '(macro . #[nil "\300\207" [(not (outline-hidden-p))] 1 (#$ . 45317) nil])) #@76 Like outline-current-depth, but respects hidden as well as visible topics. (defalias 'outline-depth #[nil "\212\303 \203\304 Z\nZ]\202``\305)\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-goto-prefix 1 0] 3 (#$ . 45465)]) (put 'outline-depth 'byte-optimizer 'byte-compile-inline-expand) #@74 Return nesting depth of visible topic most immediately containing point. (defalias 'outline-current-depth '(macro . #[nil "\300\207" [(save-excursion (if (outline-back-to-current-heading) (max 1 (- outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction)) 0))] 1 (#$ . 45818)])) #@36 Topic prefix of the current topic. (defalias 'outline-get-current-prefix #[nil "\212\302 \205  {)\207" [outline-recent-prefix-beginning outline-recent-prefix-end outline-goto-prefix] 2 (#$ . 46132)]) #@53 Return bullet of containing topic (visible or not). (defalias 'outline-get-bullet #[nil "\212\301 \205\nS{)\207" [outline-recent-prefix-end outline-goto-prefix] 2 (#$ . 46340)]) #@74 Return bullet of current (visible) topic heading, or none if none found. (defalias 'outline-current-bullet #[nil "\300\301\302\217\207" [err (byte-code "\212\301 \210S{)\207" [outline-recent-prefix-end outline-back-to-current-heading] 2) (('args-out-of-range))] 3 (#$ . 46527)]) #@55 Return the bullet of the header prefix string PREFIX. (defalias 'outline-get-prefix-bullet #[(prefix) "\302 \"\205 \303\225S\303\225O\207" [outline-regexp prefix string-match 0] 3 (#$ . 46814)]) #@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) "\212\203\305X\203\305\202^\203.\212\306 \203$\307 \nZ Z]\202)``\305)U\203H\307\310\307 \nZ Z]\311\"\203C\fT\2020\f)\202^\307 \nZ Z]W\203]\312!\210\313 \202^\305)\207" [depth outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction index 0 outline-goto-prefix 1 outline-previous-sibling nil outline-ascend-to-depth outline-sibling-index] 4 (#$ . 47019)]) #@92 Return a list indicating point's numeric section.subsect.subsubsect... Outermost is first. (defalias 'outline-topic-flat-index #[nil "\212\306 \203\307 Z\nZ]\202``\310)\311 !\312\f\310V\2032\f B S\311 !\211\202 +\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction depth next-index rev-sibls outline-goto-prefix 1 0 outline-sibling-index nil] 4 (#$ . 47703)]) #@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 #[nil "o\203 m\204 \303u\210\304\305\306#\205#\307\225\206 \307\224\206 \nb\211\207" [outline-line-boundary-regexp outline-recent-prefix-end outline-recent-prefix-beginning 1 re-search-forward nil 0 2] 4 (#$ . 48125)]) (put 'outline-next-heading 'byte-optimizer 'byte-compile-inline-expand) #@45 Position cursor on current or next heading. (defalias 'outline-this-or-next-heading #[nil "\303 ?\205)o\203m\204\304u\210\305\306\307#\205)\310\225\206 \310\224\206&\nb\211\207" [outline-line-boundary-regexp outline-recent-prefix-end outline-recent-prefix-beginning outline-goto-prefix 1 re-search-forward nil 0 2] 4 (#$ . 48595)]) #@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 "\300\207" [(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 (#$ . 48946)])) #@922 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 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) "?\306\211\211\203O\212\307 \203\310\f ZZ]\202!``\311)\204,To\2037m\2047\310u\210\312\306\311#\203O\313\225\206F\f\313\224\206M bm\204\310\f ZZ]\211W\203 U\203\335`\nB\203\266\310X\203\266\314 !\204O \310\f ZZ]X\203o\203\227m\204\227\310u\210\312\306\311#\203\313\225\206\246\f\313\224\206\255 b\211\203\202o\203\301m\204\301\310u\210\312\306\311#\203\313\225\206\320\f\313\224\206\327 b\211\202 W\203\203\360\311V\203\315\205\371S #\nB\211\204O \203(m\204\316u\210h\317>\203%\310`\320Z]`{\310H\321>\203%\316u\210`\n+\207" [orig-depth curr-depth chart original outline-recent-prefix-end outline-recent-prefix-beginning nil outline-goto-prefix 1 0 re-search-forward 2 outline-next-sibling outline-chart-subtree -1 (10 13) 3 (10 13) outline-header-subtraction prev-depth outline-line-boundary-regexp levels outline-recent-end-of-subtree] 5 (#$ . 49444)]) #@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) "\212\301 \205`C\302 \203`B\202 \205\237\211))\207" [chart outline-goto-prefix outline-next-sibling] 2 (#$ . 51404)]) #@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) "\305\211\n\306=\204\n\307V\203K \203K @\211<\2038\310\n\306=\206&\nS\"\211\2031\311\f \" A)\202b\210h\312U\203E B A\202 *\207" [here result depth chart further nil t 0 outline-chart-to-reveal append 13] 5 (#$ . 51769)]) #@997 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: (defalias 'outline-chart-spec #[(chart spec &optional exposing) "\205\210A\211\204\301\207" [spec nil] 2 (#$ . 52221)]) #@241 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. (defalias 'outline-goto-prefix #[nil "\305\204)\306\307\305\310#\203)\310u\210\311 !\203#\312\225\312\224\211\211\202\313u\210\202o\203g\311 !\203=\312\225\312\224\211\202ho\203Hm\204H\310u\210\314\f\305\312#\203c\315\225\206V\n\315\224\206] b\211\206h\202h)\207" [done outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning outline-line-boundary-regexp nil re-search-backward "[\n ]" 1 looking-at 0 -1 re-search-forward 2] 5 (#$ . 53352)]) #@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) "\305 \205@\300 \306\225b\210 \204)\307\310!\203\311u\210\202l\204)\307\312!\203)\311u\210\313!\210)\212\314 \203>\311\n Z\fZ]\202?\306)\207" [match-data ignore-decorations outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-goto-prefix 0 looking-at "[0-9]" 1 "\\s-" store-match-data outline-back-to-current-heading] 3 (#$ . 54086)]) #@54 Return position of current (visible) topic's bullet. (defalias 'outline-current-bullet-pos #[nil "\212\303 \203\304 Z\nZ]\202\305)\205\305\225S\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-back-to-current-heading 1 0] 3 (#$ . 54717)]) #@77 Move to heading line of current topic, or beginning if already on the line. (defalias 'outline-back-to-current-heading #[nil "\303 \210\304 \206\305\306\307Q\310\311#\205\312\225\312\224\211t\203!\313 \210\207" [outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning beginning-of-line outline-on-current-heading-p re-search-backward "^\\(" "\\)" nil move 1 outline-end-of-prefix] 4 (#$ . 55019)]) (defalias 'outline-back-to-heading 'outline-back-to-current-heading) #@86 Skip forward to just before the next heading line. Returns that character position. (defalias 'outline-pre-next-preface #[nil "\303\304\305#\205\306\224b\307\225\307\224\207" [outline-line-boundary-regexp outline-recent-prefix-end outline-recent-prefix-beginning re-search-forward nil move 0 2] 4 (#$ . 55517)]) #@71 Put point at the end of the last leaf in the currently visible topic. (defalias 'outline-end-of-current-subtree #[nil "\306 \210\307 Z\nZ]o\203m\204\307u\210\310\f\311\312#\203-\313\225\206$\313\224\206+ bm\204b\307 Z\nZ] V\203bo\203Hm\204H\307u\210\310\f\311\312#\203-\313\225\206V\313\224\206] b\202-m\204i\314u\210h\315>\203\200\307`\316Z]`{\307H\317>\203\200\314u\210`\211)\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction level outline-line-boundary-regexp outline-recent-end-of-subtree outline-back-to-current-heading 1 re-search-forward nil 0 2 -1 (10 13) 3 (10 13)] 4 (#$ . 55841) 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 "`\301 \210t\205`U\205\302 b)\207" [start-point outline-end-of-prefix outline-current-bullet-pos] 2 (#$ . 56513) nil]) #@61 Position the point at the end of the current topics' entry. (defalias 'outline-end-of-current-entry #[nil "\300 \210\301 o\204\302\303!\203\304u\210\207" [outline-show-entry outline-pre-next-preface looking-at "^$" -1] 3 (#$ . 56903) nil]) (defalias 'outline-end-of-current-heading #[nil "\300 \210\301y\210\302\207" [outline-beginning-of-current-entry -1 nil] 1 nil nil]) (defalias 'outline-end-of-heading 'outline-end-of-current-heading) #@67 Ascend to depth DEPTH, returning depth if successful, nil if not. (defalias 'outline-ascend-to-depth #[(depth) "\306V\203\213\212\307 \203\310 \nZ Z]\202``\306)X\203\213`\212\307 \2034\310 \nZ Z]\2029``\306)W\203r`\211\203r\311 \203ro\204r\307 \210\312 \313\306#\204_\314!\203r\315\225\206e \315\224\206l\nb\211\204#\310 \nZ Z]U\203\205\nb\210\202\211\fb\210\313)\207t\205\221\316 \207" [depth outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction last-good outline-line-boundary-regexp 0 outline-goto-prefix 1 outline-beginning-of-level re-search-backward nil looking-at 2 outline-end-of-prefix outline-bob-regexp] 4 (#$ . 57354)]) #@58 Ascend one level, returning t if successful, nil if not. (defalias 'outline-ascend #[nil "\304 \205+o?\205+\305 \210\306\307\310#\204\311 !\205+\312\225\206!\n\312\224\206( b\211t\2032\313 \210\207" [outline-line-boundary-regexp outline-bob-regexp outline-recent-prefix-end outline-recent-prefix-beginning outline-beginning-of-level outline-goto-prefix re-search-backward nil 0 looking-at 2 outline-end-of-prefix] 4 (#$ . 58059)]) #@90 Descend to depth DEPTH within current topic. Returning depth if successful, nil if not. (defalias 'outline-descend-to-depth #[(depth) "`\212\306 \203\307 Z\nZ]\202``\310)\212\306 \203)\307 Z\nZ]\202.``\310)\310V\203s \307 Z\nZ]U\204so\203Km\204K\307u\210\311\f\312\310#\203s\313\225\206Z\313\224\206a b\211\203s \307 Z\nZ]W\204\212\306 \203\203\307 Z\nZ]\202\210``\310)\310V\203\236\307 Z\nZ] U\203\236 \202\242\fb\210\312*\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction start-depth start-point depth outline-goto-prefix 1 0 re-search-forward nil 2 outline-line-boundary-regexp] 4 (#$ . 58507)]) #@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) "\306 \210\307 Z\nZ]`\310\211\307 Z\nZ]\307V\203e\311V\203eo\204e\f\204e`\307 Z\nZ]W\204I\312\307!\204/\211\203/\212\306 \203Y\307 Z\nZ]\202Z\311)S\202\f\204p\311V\203\220 b\210t\203z\313 \210\204\205\314\315!\202\230t\203\214\313 \210\310\202\230t\203\227\313 \210 ,\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction return failed last-good outline-back-to-current-heading 1 nil 0 outline-previous-visible-heading outline-end-of-prefix error "Can't ascend past outermost level" present-level arg dont-complain] 4 (#$ . 59194) "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) "\205o?\205\365 \206#\212\306 \203\307\n Z\fZ]\202\"``\310)`\311\2032o\2023m\204\232\203do\204\232\306 \210\312\311\310#\204Q\313!\203\232\314\225\206W\n\314\224\206^ b\211\202\210o\203om\204o\307u\210\315\311\310#\203\232\314\225\206~\n\314\224\206\205 b\211\203\232\307\n Z\fZ]\211V\204*m\204\316 \206\270\212\306 \203\262\307\n Z\fZ]\202\267``\310)\310V\203\316\307\n Z\fZ]U\203\316 \202\364b\210 \203\360\212\306 \203\346\307\n Z\fZ]\202\353``\310)\210\202\363\210\311+\207" [backward depth outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction last-depth outline-goto-prefix 1 0 nil re-search-backward looking-at 2 re-search-forward start-point start-depth outline-line-boundary-regexp outline-bob-regexp] 4 (#$ . 60092)]) #@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) "\302 ?\"\207" [depth backward outline-next-sibling] 3 (#$ . 61213)]) #@93 Position cursor at end of previous topic Presumes point is at the start of a topic prefix. (defalias 'outline-snug-back #[nil "o\204 m\204 \300u\210o\204%h\301>\203%\300u\210o\204\"h\302>\204%\300u\210`\207" [-1 (10 13) (10 13)] 2 (#$ . 61583)]) #@61 Go back to the first sibling at this level, visible or not. (defalias 'outline-beginning-of-level #[nil "\300\301!\207" [outline-end-of-level backward] 2 (#$ . 61842)]) #@55 Go to the last sibling at this level, visible or not. (defalias 'outline-end-of-level #[(&optional backward) "\212\304 \203\305 Z\nZ]\202``\306)\307 \310\"\204\305 Z\nZ]t\203,\311 \210)\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction depth outline-goto-prefix 1 0 outline-previous-sibling nil outline-end-of-prefix] 3 (#$ . 62017)]) #@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) "\306W\205\f\306\\[\211\211\203\307\202\310`\311\311\306V\203L \203+o\202,m\204?\307\nyW\203?\312\f!\211\203# \203E S\211\202 \203]\306\225 \306\224\313 \202v\f\203m\306\225 \306\224\211\202v ?\205v\311\210\311-\207" [arg backward step start-point prev got 0 -1 1 nil looking-at outline-end-of-prefix outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning] 3 (#$ . 62412) "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) "\301[!\207" [arg outline-next-visible-heading] 2 (#$ . 63082) "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) "\212\306 \203\307 Z\nZ]\202\310)` \310 V\311`\311\211\310U\2030\312\313!\210\203: \310\\[\314 !\204\231\f\204\231\203Mo\202Nm\204r\203\\\315\307!\202_\316\307!\203r\307 Z\nZ]\211V\204D\203\224U\203\224\203\210o\202\211m\204\224` S\202:\317\202:m\204\324 \310U\203\324\206\276\212\320 \203\270\307 Z\nZ]\202\275``\310)\310V\203\324\307 Z\nZ]U\203\324 \202\374 b\210t\205\374\321 \210\312\322\203\351\323\202\352\324\307 Z\nZ]\325! Z\325!%.\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction arg at-boundary last-good outline-back-to-current-heading 1 0 nil error "No siblings, not in a topic..." zerop 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 last-depth backward start-arg start-point start-depth] 8 (#$ . 63382) "p"]) #@45 Inverse of `outline-forward-current-level'. (defalias 'outline-backward-current-level #[(arg) "t\203\302\\[\303\304!)\207\304\302\\[!\207" [arg current-prefix-arg 0 call-interactively outline-forward-current-level] 3 (#$ . 64592) "p"]) #@991 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-functions', which in emacs 19 is run before any change to the buffer. 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) "\205\366 ?\205\366\n?\205\366\306 \307\216\212\f\310>\203\" T T b\210\212\311\312\313\314#\2051g\315U)\206P  U?\205P b\205P\212\311\312\313\314#\205Og\315U)+\205\366\306 \316\216\f\317\232\203|\320\321!\210\212\311\312\313\314#\205og\315U)\203v\322 \210\320\323!\202\365\313\212\324 \210\212\311\312\313\314#\205\215g\315U*\313!\"#\212\325\326\327\217\203\330#\330=\203\276\212!\203\256!b\210\"\203\270\331 \202\272\332 )\202\364\333\334$%Z&Z]S!\203\323\322 \202\364\335 \202\364\"\203\356\212!\203\347!b\210\331 \210)\202\361\332 \210\336\337!,*\207" [outline-mode outline-override-protect outline-during-write-cue save-match-data-internal this-command beg match-data ((set-match-data save-match-data-internal)) (newline open-line) re-search-backward "[\n ]" nil t 13 ((set-match-data save-match-data-internal)) undo message "Undo! - exposing concealed target..." outline-show-children "Undo!" outline-goto-prefix err (byte-code "\212l\203\302 \303 \210)\304\305!\210\306 \211\307>\203\310\211\202L \311>\203+\312\211\202L \313>\2036\314\202O \315=\203C\304\316!\210\202\f\304\317!\210\320\321!\210\314\203\f \207" [rehide-place response outline-goto-prefix outline-show-entry message "Change inside concealed region - do it? (n or 'y'/'r'eclose)" read-char (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] 3) (('quit)) reclose outline-hide-current-entry-completely outline-hide-current-entry outline-ascend-to-depth 1 outline-show-to-offshoot error "Change within concealed region prevented." end rehide-place rehide-completely response outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction] 5 (#$ . 64840)]) #@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 (#$ . 67671)) (make-variable-buffer-local 'outline-post-goto-bullet) #@363 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-functions is used. (defalias 'outline-post-command-business #[nil "\205\277\306\n\203 \307 \210 \203\306\f<\203\255 \310\232\203\255 \310\232\203\255\fA\211\fAA \306\306\306\306\306\306 \203\253\f@\204\253 @\204\253\fA@\211\203\253\f@\211\203\253@\211\247\203\253A\211\247\203\253Z\311U\203\253@\211\247\203\253A\211\247\203\253ZV\203\253B\fAAAB.\205\277\312 \205\277\312 b\210\306\211\207" [outline-mode outline-override-protect outline-isearch-dynamic-expose outline-during-write-cue buffer-undo-list this-command nil outline-isearch-rectification self-insert-command 1 outline-current-bullet-pos last-command prev-stuff before-prev-stuff cur-cell cur-from cur-to prev-cell prev-from prev-to outline-undo-aggregation outline-post-goto-bullet] 4 (#$ . 68154)]) #@779 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 outline-mode map. The outline-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. (defalias 'outline-pre-command-business #[nil "\205y\306\301!\203 \203\307\202\310 \311=\205y`\312 =\205y\f\247\203+\f\202>\313\314!\203=\314\f!\203=\315\f!\202>\316\310\317 !?\205x\320 X\203S \321Z\322 X\203l\320 Y\203l\323\324\325 \322Z!P\"\205x\307\211*\207" [outline-mode isearch-mode outline-pre-was-isearching this-command last-command-char this-key-num boundp t nil self-insert-command outline-current-bullet-pos fboundp characterp char-to-int 0 zerop 96 32 64 lookup-key outline-mode-map char-to-string mapped-binding outline-command-prefix outline-post-goto-bullet] 6 (#$ . 69348)]) #@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 "\205 ?\205\n\205\301\303!\207" [outline-auto-activation outline-mode outline-layout t] 2 (#$ . 70762)]) #@110 Rectify outline exposure before, during, or after isearch. Called as part of outline-post-command-business. (defalias 'outline-isearch-rectification #[nil "\305\300!\205\211\203\n\204\306\307!\2027 \203$\n\203$\306\310!\2027 \2042\n\2032\306\311!\2027\312\312\211)\207" [isearch-mode isearching outline-pre-was-isearching outline-isearch-prior-pos outline-isearch-did-quit boundp outline-isearch-expose start continue final nil] 3 (#$ . 71050)]) (byte-code "\302B\303\302!\204\303\301!\205 \302\207" [current-load-list font-lock-mode outline-isearch-was-font-lock boundp] 2) #@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) "\303\304\305 \306\307\n\310BB\311BB\n\312BBBBBE\207" [from to flag let ((buffer-read-only nil) (outline-override-protect t)) subst-char-in-region if = (10) (13 10) (t)] 9 (#$ . 71657)])) #@54 Mode is either 'clear, 'start, 'continue, or 'final. (defalias 'outline-isearch-expose #[(mode) "\306=\203\307\301!\205 \310\2026\311=\203\n \2036 <\2036\310\312\313 A@ AA@\314\315\312%\210*\212\316\317\310\312#\205Bg\315U)\204K\310\202c\311=\204Y`\320 B\202c\204c\310\321 \210\310\211\207" [mode font-lock-mode outline-isearch-was-font-lock outline-isearch-prior-pos outline-override-protect buffer-read-only start boundp nil final t subst-char-in-region 10 13 re-search-backward "[\n ]" outline-show-entry outline-show-children outline-isearch-did-quit] 6 (#$ . 72113)]) #@145 Impose outline-mode isearch-abort wrapper for dynamic exposure in isearch. The function checks to ensure that the rebinding is done only once. (defalias 'outline-enwrap-isearch #[nil "\300\301\302\"\210\303\304!?\205'\303\305!\203\303\306!\204\307\310\311\217\205'\304\306KM\210\306\312M\207" [add-hook isearch-mode-end-hook outline-isearch-rectification fboundp outline-real-isearch-abort isearch-mode isearch-abort error (load-library "isearch-mode") (('file-error (byte-code "\302\303A@AA@#\210\304\305!\210\306\211\207" [error outline-isearch-dynamic-expose message "Skipping isearch-mode provisions - %s '%s'" sit-for 1 nil] 4))) outline-isearch-abort] 3 (#$ . 72723)]) #@79 Wrapper for outline-real-isearch-abort (which see), to register actual quits. (defalias 'outline-isearch-abort #[nil "\301\302\303\304\217\207" [outline-isearch-did-quit nil what (outline-real-isearch-abort) (('quit (byte-code "\301\302\303\304\"\207" [outline-isearch-did-quit t signal quit nil] 3)))] 3 (#$ . 73414) nil]) (byte-code "\301B\302\301!\204\f\303\303\207" [current-load-list isearch-was-font-locking boundp nil] 2) #@68 Inhibit font-lock while isearching - for use on isearch-mode-hook. (defalias 'isearch-inhibit-font-lock #[nil "\205\303\301!\205 \205\304\305\211\207" [outline-mode font-lock-mode isearch-was-font-locking boundp t nil] 2 (#$ . 73855)]) (add-hook 'isearch-mode-hook 'isearch-inhibit-font-lock) #@73 Reenable font-lock after isearching - for use on isearch-mode-end-hook. (defalias 'isearch-reenable-font-lock #[nil "\303\300!\205\205 \205\n\205\304\305\211\207" [font-lock-mode outline-mode isearch-was-font-locking boundp nil t] 2 (#$ . 74163)]) (add-hook 'isearch-mode-end-hook 'isearch-reenable-font-lock) #@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) ";\203 \206\f\306 !\307 !\310\212\311 b\210\312\313\314\f\n#\f\315#)\316\317!\210 \317\230\2031\n\2022 +\207" [current-bullet depth default-bullet outline-bullets-string sans-escapes choice outline-bullet-for-depth regexp-sans-escapes nil outline-current-bullet-pos solicit-char-in-string format "Select bullet: %s ('%s' default): " t message ""] 5 (#$ . 74491)]) #@71 True if bullet is one of those on outline-distinctive-bullets-string. (defalias 'outline-distinctive-bullet #[(bullet) "\302\303! \"\207" [bullet outline-distinctive-bullets-string string-match regexp-quote] 3 (#$ . 75080)]) #@58 True if current header prefix bullet is numbered bullet. (defalias 'outline-numbered-type-prefix #[(&optional prefix) "\205 \203\302 !\202\303 \230\207" [outline-numbered-bullet prefix outline-get-prefix-bullet outline-get-bullet] 3 (#$ . 75312)]) #@73 Return outline topic bullet suited to optional DEPTH, or current depth. (defalias 'outline-bullet-for-depth #[(&optional depth) "\203\305 \306\n\307Z] \246H!\207\f\207" [outline-stylish-prefixes outline-plain-bullets-string depth outline-plain-bullets-string-len outline-primary-bullet char-to-string 0 2] 5 (#$ . 75574)]) #@2037 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. 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 `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 require this function counting back the index for each successive sibling). (defalias 'outline-make-topic-prefix #[(&optional prior-bullet new depth solicit number-control index) "\306\306\306 \206!\212\307 \203\310\f ZZ]\202 ``\311) \310X\2034\312\202!\203H\313 \314!\"\312\312\202!\313 \315Z\316\"\203x\317 \"\205q \205h!??\205q\230)\202!\203\252 \203\252!?\211?\211\203\222\202!\"\203\244\"\230\204\244\"\202!\320 !\202!#\203\371 \212\307 \203\301\310\f ZZ]\202\306``\311)X\203\371\203\371\n\204\371\212 \321 Y\204\340\322 !\210\323 )\211$\205\365$\230\205\365$\211)\206!\"\203\324\"!\203\203\"\230\203\n?\211\203\"\206!\320 !%% \205M\325\326!\203>!\247\203>!\202L#\203J\327 !T\202L\327 \"R.\207" [body numbering denumbering depth outline-recent-prefix-end outline-recent-prefix-beginning nil outline-goto-prefix 1 0 "" make-string string-to-char 2 32 outline-solicit-alternate-bullet outline-bullet-for-depth outline-depth outline-ascend-to-depth outline-get-bullet outline-distinctive-bullet format "%d" outline-sibling-index outline-header-subtraction outline-header-prefix header-lead outline-primary-bullet outline-old-style-prefixes solicit got outline-numbered-bullet number-control index prior-bullet new sibling-bullet bullet-char] 8 (#$ . 75908)]) #@1217 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. If USE_SIB_BULLET is true, use the bullet of the prior sibling. 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 preceding sibling, and then open forward from there. (defalias 'outline-open-topic #[(relative-depth &optional before use_sib_bullet) "\212\306 \203\307 Z\nZ]\202\310) \\\311\312!\205\313\211?!\313\"\313#\313$\212 \310W\2038\314\f!\210\202A \307Y\204A\306 \210\307 Z\nZ]#\307V\203WS{\202X\315$\212%\205s \310X\204l\316\f!\205s\317 \205s%)\"`)&\313'\313(!\204&b\210 \310X\203\253\212\310\320yV\206\236\311\321!\206\236o)\203\253\212\322 \210n)\206\301#\307U\205\301 \206\301\f\307U\206\301\212\323 )?' \203 \310Y\203\306 \210o(o\204o\204\324 \210\325)\313\310#\204\356\311*!\203\326\225\206\364\326\224\206\373 b\202 \203o\203\327+\330\307!\210) \310X\203\\(\203/\327+\330'\203(\326\202)\307!\210)\202\265 \203V\313\210\323 \210g\331U\203E\307u\210\2029\311\312!\204\265\327+\330\307!\210)\202\265\322 \210\202\265\313\210\323 \210n\203l\325\332\313\327#\210\212o\203xm\204x\307u\210\333)\313\310#\203\220\326\225\206\207\326\224\206\216 b\307 Z\nZ]#V\205\243\320y\210\311\321!)\203\262\307y\210\327+\330\307!\210)\313\210o\204\f#V\204\317 \204\317\327+\330\307!\210)\202\375\f#V\203\341\327+\334\307!\210)\202\375'\203\361\327+\330\307!\210)\202\375 \204\375\327+\334\307!\210)'\203\n\327+\334\307!\210)m\204n\204\307u\210\335\336\"\327\f#\337P!\210\340,\205($\f\313\211\327%\210\313.\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction relative-depth depth before outline-back-to-current-heading 1 0 looking-at "^$" nil outline-ascend-to-depth "" outline-descend-to-depth outline-numbered-type-prefix -1 "^\\s-*$" outline-end-of-current-subtree outline-pre-next-preface outline-goto-prefix re-search-backward 2 t open-line 13 "[^ \n]" re-search-forward newline insert-string outline-make-topic-prefix " " outline-rebullet-heading opening-on-blank opening-numbered ref-depth ref-bullet outline-numbered-bullet ref-topic dbl-space doing-beginning outline-line-boundary-regexp outline-bob-regexp outline-override-protect use_sib_bullet] 6 (#$ . 79271)]) #@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) "\301\302\303V\"\207" [arg outline-open-topic 1 0] 4 (#$ . 82570) "p"]) #@206 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 one. (defalias 'outline-open-sibtopic #[(arg) "\301\302\211V\303W#\207" [arg outline-open-topic 0 1] 5 (#$ . 82847) "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) "\301\302\303V\"\207" [arg outline-open-topic -1 0] 4 (#$ . 83178) "p"]) #@65 Name of modal fill function being wrapped by outline-auto-fill. (defvar outline-former-auto-filler nil (#$ . 83463)) #@119 Outline-mode autofill function. Maintains outline hanging topic indentation if `outline-use-hanging-indents' is set. (defalias 'outline-auto-fill #[nil "\205\212\304 \210\305 !\205\306\307 \210i\310\") \204\205!\311 )\207" [outline-use-hanging-indents outline-regexp fill-prefix outline-former-auto-filler beginning-of-line looking-at make-string outline-end-of-prefix 32 do-auto-fill] 3 (#$ . 83587)]) #@208 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. (defalias 'outline-reindent-body #[(old-depth new-depth &optional number) "\212\306 \210i\307\307\307\307 Z\\\310\311 \312\216\313\314\307\310#\205P\315\224\315\225\211\205P\316!?\205P\317iZ\211V\204\n |\210 \\j\210\202.\n\207" [new-margin excess old-indent-begin old-indent-end curr-ind old-depth outline-end-of-prefix nil t match-data ((set-match-data save-match-data-internal)) re-search-forward "[\n ]\\(\\s-*\\)" 1 looking-at 0 new-depth old-margin outline-override-protect save-match-data-internal outline-regexp] 4 (#$ . 84008)]) #@49 Solicit new bullet for current visible heading. (defalias 'outline-rebullet-current-heading #[(arg) "i`\304 =\305W\205\305\\[\211\305V\203J\212\306 \210\307 \210\310\311\312\211\211\311%\210)S\211\305X\204\312 \204@\313\314!\210\202\315 \210\313\316!\210\202\317\320!\210\n\203X\304 b\202_ \205_\321 !+\207" [arg backwards on-bullet initial-col outline-current-bullet-pos 0 outline-back-to-current-heading outline-end-of-prefix outline-rebullet-heading t nil outline-next-visible-heading 1 outline-goto-prefix -1 message "Done." move-to-column] 7 (#$ . 84787) "p"]) #@1408 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 `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) "\212\306 \203\307 Z\nZ]\202``\310)\f\206  \211S{\311\312\f& \fU\203O\211GS\312O\230\203O\313\202\307\313 |\210) b\210\203x\230\203x\314\315!\203x\313\310\224\310\225|\210)\313\316!\210)\203\221\f U\204\221\317 \f\"\210\205\307\212\320\f\312\"\205\306\247\203\252T\202\262?\205\262\321 \322 \203\227\323\312\f\312%\210\202\227).\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction current-depth new-depth mb outline-goto-prefix 1 0 outline-make-topic-prefix nil t looking-at "[0-9]+" insert-string outline-reindent-body outline-next-sibling outline-sibling-index outline-numbered-type-prefix outline-rebullet-heading me current-bullet solicit number-control index new-prefix outline-override-protect outline-numbered-bullet outline-reindent-bodies do-successors] 8 (#$ . 85384)]) #@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\212\n\204\306\202\n<\203\n@\307\n!\204 \310\311!\210\312 \210\313 \fZ Z]\n\\\306X\2035\314\315!\210\316\n!\210\307\n!\204C\310\317!\210)\320\306 \n\\]!*\207" [was-eol start-col arg outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction 0 zerop message "Shifting..." outline-back-to-current-heading 1 error "Attempt to shift topic below level 1" outline-rebullet-topic-grunt "Shifting... done." move-to-column] 4 (#$ . 87802) "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) "\206\306\212\307 \203\310 \nZ Z]\202``\306) \206\"\f?\206;\311!\2049?\205;\312 \306W\206H`\203`\203`\306 \\V\203`\313\314!\210 \fU\203\271\315\316 \\\316\316%\210\306o\203m\204\310u\210\317\316\306#\203\227\320\225\206\216 \320\224\206\225\nbm\204\310 \310 \nZ Z]W\203\310T\321 T$\210\202\227 \fW\203\310\321\f$\210\205\f\204\362\311!\204\372\310 \nZ Z] U\204\362\310 \nZ Z] \\U\203\372\315\316\211\211\211\322%\210b\210\311!?\205\f\315\316\211\211\211\322%.\207" [relative-depth outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction new-depth starting-depth 0 outline-goto-prefix 1 zerop outline-sibling-index error "Attempt to shift topic out beyond level 1" outline-rebullet-heading nil re-search-forward 2 outline-rebullet-topic-grunt t starting-point on-starting-call index moving-outwards outline-line-boundary-regexp do-successors] 6 (#$ . 88518)]) #@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) "\212\306 \203\307 Z\nZ]\202``\310)\311m\204\247\212\306 \203-\307 Z\nZ]\2022``\310)\203\247\307 Z\nZ] Y\203\247\f Y\203\247m\211\204\200\307 Z\nZ]\fV\203\200o\203em\204e\307u\210\312\311\310#\203H\313\225\206t\313\224\206{ b\202H\307 Z\nZ]S\307 Z\nZ] Y\203\235\314\311\211\211\211\315%\210 \203db\210\202*\307 Z\nZ]\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction was-eobp ascender depth outline-goto-prefix 1 0 nil re-search-forward 2 outline-rebullet-heading t outline-line-boundary-regexp] 6 (#$ . 90004)]) #@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) "\212\306 \210\307 \210\310 Z\nZ] ?\205\310 \311\232\312\f\205A\313 \312\314%\210\2036T\315\314\"\211\204\"\314-\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction denumber more use-bullet outline-back-to-current-heading outline-beginning-of-level 1 (16) t outline-rebullet-heading nil outline-next-sibling index depth] 7 (#$ . 90798) "P"]) #@71 Increase depth of current heading and any topics collapsed within it. (defalias 'outline-shift-in #[(arg) "\301!\207" [arg outline-rebullet-topic] 2 (#$ . 91526) "p"]) #@71 Decrease depth of current heading and any topics collapsed within it. (defalias 'outline-shift-out #[(arg) "\301\302\\[!\207" [arg outline-rebullet-topic 0] 3 (#$ . 91701) "p"]) #@66 Kill line, adjusting subsequent lines suitably for outline mode. (defalias 'outline-kill-line #[(&optional arg) "\203 \203n\203\306\n!\204\307 !\207\212\310 \203'\311\f ZZ]\202,``\312)\307 !\210\313\312!\210\212\306\n!\204ao\203Im\204I\311u\210\314\315\312#\203a\316\225\206X\f\316\224\206_ b\317!*\207" [outline-mode outline-numbered-bullet outline-regexp arg outline-recent-prefix-end outline-recent-prefix-beginning looking-at kill-line outline-goto-prefix 1 0 sit-for re-search-forward nil 2 outline-renumber-to-depth outline-header-subtraction depth outline-line-boundary-regexp] 4 (#$ . 91886) "*P"]) #@99 Kill topic together with subtopics. Leaves primary topic's trailing vertical whitespace, if any. (defalias 'outline-kill-topic #[nil "\306 \307 \210\310 \nZ Z]\311 \210m\204R\312\313!\203O\212o\203'm\204'\310u\210\314 \315\316#\205K\317\225\2065 \317\224\206<\nb\211\205K\310 \nZ Z]\fY)\203R\310u\210\320`\"\210\321\316!\210\212\322\f!+\207" [beg outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction depth outline-line-boundary-regexp outline-back-to-current-heading beginning-of-line 1 outline-end-of-current-subtree looking-at "^$" re-search-forward nil 0 2 kill-region sit-for outline-renumber-to-depth] 4 (#$ . 92528) nil]) #@718 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 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-outline-specific yanks. (defalias 'outline-yank-processing #[(&optional arg) "\306\307!`W\203 \310 \210`\306\307!\311 \205&\312\313\n\314Q!\205&\315\225\315\224\211\211\2062n\2052\312\n!# \203c\315\225Z$\315 \fZ%Z]& S {'\212 b\205\205l\205\205b\205\205\312\n!\205\205\316 \210`U?\205\205\312\n!\205\205\317\225\317\224\211\205\205\315 \fZ%Z])(\320)\307*+#(\203^\321\322!\210\323\317!\210\214 }\210db\210\312\324!\203\265\307,\325\326!\210)*\203\327 \210\330\212\331 \203\317\315 \fZ%Z]\202\324``\317)S!\204\275\212\332(&Z!\210\212\331 \203\364\315 \fZ%Z]\202\371``\317)\210)o?\211*\203\265~\210\326u\210`}\210\202\265)\321\333!\210\334\335'!-\"\2037\316 \210`|\210\306\307! \320\223\210b\210\336 \210\202a``$\\(&Z\\|\210\312\337!\203Q\325\315!\210\202D\312\340!\203a\325\315!\210\202a\310 \210.#\203\234\212\321\341!\210\323\317!\210b\210\331 \203\227\342\320\212\331 \203\214\315 \fZ%Z]\202\221``\317)\320\211\307%\210\321\333!\210) ?\205\243\310 ,\207" [subj-beg subj-end outline-regexp outline-recent-prefix-end outline-recent-prefix-beginning resituate my-mark-marker t exchange-point-and-mark outline-e-o-prefix-p looking-at "\\(" "\\)" 1 beginning-of-line 0 nil message "... yanking" sit-for "^$" delete-char -1 outline-back-to-current-heading outline-ascend-to-depth outline-goto-prefix outline-rebullet-topic-grunt "" string-match regexp-quote outline-end-of-prefix "[0-9]" " " "... reconciling numbers" outline-rebullet-heading rectify-numbering prefix-len outline-header-subtraction subj-depth prefix-bullet adjust-to-depth done more outline-numbered-bullet outline-override-protect outline-distinctive-bullets-string] 7 (#$ . 93210) "*P"]) #@1102 Outline-mode yank, with depth and numbering adjustment of yanked topics. Non-topic yanks work no differently 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 successive 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) "\303\303 !\210\n\205\f\304 \207" [this-command arg outline-mode yank outline-yank-processing] 2 (#$ . 95645) "*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) "\303\304 !\210\n\205\f\305 \207" [this-command arg outline-mode yank yank-pop outline-yank-processing] 2 (#$ . 96914) "*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 "\204\306\307!\207\310 \230\204\306\311\"\207\312\212\n\312\210` b\210\313\314\f\315#\205.\316\224\316\225{+ \317H\320U\204>\321 !\202O\322 \316\312O\312\315#\211\205N A@)\323 !\204l\324 !\203e\325\326\327 \"!\202i\306\330 \"\203s\331\332\333\217\202w\306\334 \")\207" [outline-file-xref-bullet file-name outline-recent-prefix-end text-start heading-end reg-ref error "outline cross references disabled - no `outline-file-xref-bullet'" outline-current-bullet "current heading lacks cross-reference bullet `%s'" nil re-search-forward "\\s-\\(\\S-*\\)" t 1 0 58 expand-file-name reference-registered-file 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 (#$ . 97330) nil]) #@95 Hide or show subtree of currently-visible topic. See `outline-flag-region' for more details. (defalias 'outline-flag-current-subtree #[(flag) "\212\303 \210\304\305\306`\307 \210`S\n\310U\203\311\202\310\n\305%+\207" [outline-override-protect buffer-read-only flag outline-back-to-current-heading nil t subst-char-in-region outline-end-of-current-subtree 10 13] 6 (#$ . 98342)]) #@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 "\212`\305\211\306 \210h\307U\203`S\202`\310\311\305\312#\210\n`W\203'`\202/ \313 \206.`]S\305\312\314 \307\315\312%\210* ,D\207" [end beg at outline-override-protect buffer-read-only nil outline-goto-prefix 13 re-search-forward "[\n ]" t outline-pre-next-preface subst-char-in-region 10] 6 (#$ . 98735) 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) "\306 \204\"\212\307\310\306\311#\205g\312U)\203\"\313 \210\314\n\311\"\211\202\215\212\214`\315\n\206,\316!\317\f\n\2065\316\" b\210 \203`h\312U\203`\306\311\320`\321 \312\322\311%\210*\203` @b\210\323 \210 \205\214 @b\210\306\311\320`\321 \312\322\311%\210*\203\204 @b\210\323 \210 A\211\204d\306-)\207" [max-pos strict level start-pt chart to-reveal nil re-search-backward "[\n ]" t 13 outline-show-to-offshoot outline-show-children outline-chart-subtree 1 outline-chart-to-reveal subst-char-in-region outline-snug-back 10 outline-show-current-entry outline-override-protect buffer-read-only outline-show-bodies] 7 (#$ . 99457) "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 "\212\302 \210\303\304\305o\204`S\202`\306 \210g\307U\203 `\202\"`S\310\307\304%+\207" [outline-override-protect buffer-read-only outline-goto-prefix nil t subst-char-in-region outline-pre-next-preface 13 10] 6 (#$ . 100753) nil]) #@199 Like outline-show-entry, but reveals 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 "\212`\304 `\305\204h\306U\203<\307 \210 `\211U\2033\307 \210\310 \210 b\210\311\312 \210\313\314\315\316#\210\317 \210\nb\210\202\n b\210-\212\320\321\305\311#\205Lg\306U)\205R\322 \207" [bag-it last-at orig-pref orig-pt outline-goto-prefix nil 13 beginning-of-line 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 (#$ . 101266) nil]) #@48 Hide the body directly following this heading. (defalias 'outline-hide-current-entry #[nil "\302 \210\212\303\304\305`\306 \210`\307\310\304%+\207" [outline-override-protect buffer-read-only outline-back-to-current-heading nil t subst-char-in-region outline-end-of-current-entry 10 13] 6 (#$ . 101998) nil]) #@73 Show body following current heading, or hide the entry if repeat count. (defalias 'outline-show-current-entry #[(&optional arg) "\203\303 \207\212\304\305\306`\307 \210`\310\311\305%+\207" [arg outline-override-protect buffer-read-only outline-hide-current-entry nil t subst-char-in-region outline-end-of-current-entry 13 10] 6 (#$ . 102314) "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 "\212\302 \210\303\304\305o\204`S\202`\306 \210g\307U\203 `\202\"`S\310\307\304%+\207" [outline-override-protect buffer-read-only outline-goto-prefix nil t subst-char-in-region outline-pre-next-preface 13 10] 6 (#$ . 102674) nil]) #@101 Show everything within the current topic. With a repeat-count, expose this topic and its siblings. (defalias 'outline-show-current-subtree #[(&optional arg) "\212\212\306 \203\307 Z\nZ]\202\310)\310X\203Wo\203#m\204#\307u\210\311 \312\310#\203>\313\225\2061\313\224\2068 b\211\204D\314\315!\202h\316\317!\210\312\320\321ed\322\323\320%*\202h\204b\324\323!\202h\325 \210\326\327!)\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction outline-line-boundary-regexp outline-override-protect buffer-read-only outline-back-to-current-heading 1 0 re-search-forward nil 2 error "No topics" message "Above outermost topic - exposing all." t subst-char-in-region 13 10 outline-flag-current-subtree outline-beginning-of-level outline-expose-topic (* :) arg] 6 (#$ . 103188) "P"]) #@286 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) "`\306\210\307 \204\310\311!\202\306\210`\312\313!\210 b\210\211b\210\306\210`U\203_\n\204_ b\203_\314\315\316\"\204O\317b\210\320\321 !\210\322\323!\210\321 \324P!\210)\202_\315\f ZZ]\317U\204_\325 \210 b*\207" [orig-eol from just-close msg outline-recent-prefix-end outline-recent-prefix-beginning nil outline-goto-prefix error "No topics found" outline-flag-current-subtree 13 outline-up-current-level 1 t 0 "Top-level topic already closed - closing siblings..." message outline-expose-topic (0 :) " Done." outline-hide-current-subtree outline-header-subtraction] 3 (#$ . 104026) nil]) #@61 Show all subheadings of this heading, but not their bodies. (defalias 'outline-show-current-branches #[nil "\300 \210\301\302!\207" [beginning-of-line outline-show-children t] 2 (#$ . 104991) nil]) #@61 Hide the bodies of the current topic and all its offspring. (defalias 'outline-hide-current-leaves #[nil "\300 \210\301`\302 \210`\"\207" [outline-back-to-current-heading outline-hide-region-body outline-end-of-current-subtree] 3 (#$ . 105195) nil]) #@37 Show all of the text in the buffer. (defalias 'outline-show-all #[nil "\302\303!\210\304\305\306ed\307\310\305%\210*\302\311!\207" [outline-override-protect buffer-read-only message "Exposing entire buffer..." nil t subst-char-in-region 13 10 "Exposing entire buffer... Done."] 6 (#$ . 105451) nil]) #@37 Hide all of buffer except headings. (defalias 'outline-hide-bodies #[nil "\300ed\"\207" [outline-hide-region-body] 3 (#$ . 105760) nil]) #@54 Hide all body lines in the region, but not headings. (defalias 'outline-hide-region-body #[(start end) "\212\214 }\210eb\210m?\2052\304\305\306`\307 \210`\310\311\305%\210*m\204 \312\313!\203,\314\202-\315u\210\202 *\207" [start end outline-override-protect buffer-read-only nil t subst-char-in-region outline-pre-next-preface 10 13 looking-at "[\n ][\n ]" 2 1] 6 (#$ . 105903)]) #@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) "<\205w\212\306 \203\307 \nZ Z]\202``\310)\310\311\211\211\211\211 !\"#$\203s!\"@!A!\203'!9\203\255!\312=\203`\313 \210%#V\203'%#\202'!\314=\203y\315 \210%#V\203'%#\202'!\316=\203\206\317 \210\202'!\320=\203'\321 \322 GGZ&\310&W\203\251\323\324&\"\"\")\202'!\247\203\310!Y\203\343\212\325\326\311\321#\205\306g\327U)\204\343\212\330\321!\210\310!V\204\342%#V\203\342%#)\331!!\310V\203'\332\331!!!\210%#V\203'%#\202'!<\203'\333$T!\203'\334!!\211'\203&'#V\203&'#) \2032\311 \202-@<\204-#`V\203kd#^b\210o\203Pm\204P\307u\210\335(\311\310#\203-\336\225\206_ \336\224\206f\nb\202-\337$!\210\202-#.\207" [spec outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction snug-back done outline-goto-prefix 1 0 nil * outline-show-current-subtree + outline-show-current-branches - outline-show-current-entry : t outline-chart-siblings append make-list re-search-backward "[\n ]" 13 outline-hide-current-subtree abs outline-show-children outline-descend-to-depth outline-expose-topic re-search-forward 2 outline-next-sibling stay curr-elem prev-elem max-pos depth outline-recent-end-of-subtree residue got outline-line-boundary-regexp] 8 (#$ . 106299) "xExposure spec: "]) #@1456 Deprecated. Use outline-expose-topic (with different schema format) instead. Dictate wholesale exposure scheme for current topic, according to SPEC. SPEC is either a number or a list. Optional successive args dictate exposure for subsequent siblings of current topic. A simple spec (either a number, a special symbol, or the null list) dictates the overall exposure for a topic. Non null lists are composite specs whose first element dictates the overall exposure for a topic, with the subsequent elements in the list interpreted as specs that dictate the exposure for the successive offspring of the topic. 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 close before opening to the absolute value of the number. - positive numbers just open to the relative depth indicated by the number. - 0 just closes - `*' completely opens the topic, including bodies. - `+' shows all the sub headers, but not the bodies - `-' exposes the body and immediate offspring of the corresponding topic. If the spec is a list, the first element must be a number, which dictates the exposure depth of the topic as a whole. Subsequent elements of the list are nested SPECs, dictating the specific exposure for the corresponding offspring of the topic. Optional FOLLOWER arguments dictate exposure for succeeding siblings. (defalias 'outline-old-expose-topic #[(spec &rest followers) "\212\306 \203\307 Z\nZ]\202\310)\311\211\203\3409\203C\312=\203,\313 \210\314=\2036\315 \210\316=\203\340\317 \210\202\340\247\203\202\310Y\203s\212\320\321!\210\311\210 \203b` V\203d`\310V\203r\310\\[)\310V\203\340\322!\210\202\340<\203\340\212\306 \203\230\307 Z\nZ]\202\231\310)T\311\323@!A\211\203\337\324!\203\337\212\325\326\311\321#\205\302g\327U)\204\337\330\323\"\211\203\337 \203\334 V\203\337*\203\f \203\364` W\203\364 b\210\311\311\210\331 !\203\f\323@!\210A\211\204\345 +\207" [outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction max-pos done depth outline-back-to-current-heading 1 0 nil * outline-show-current-subtree + outline-show-current-branches - outline-show-current-entry outline-hide-current-subtree t outline-show-children outline-old-expose-topic outline-descend-to-depth re-search-backward "[\n ]" 13 apply outline-next-sibling spec got new-depth followers] 5 (#$ . 110099) "xExposure spec: "]) #@925 Literal frontend for `outline-expose-topic', doesn't evaluate arguments. Some arguments that would need to be quoted in outline-expose-topic need not be quoted in outline-new-exposure. Cursor is left at start position. Use this instead of obsolete `outline-exposure'. Examples: (outline-exposure (-1 () () () 1) 0) Close current topic at current level so only the immediate subtopics are shown, except also show the children of the third subtopic; and close the next topic at the current level. (outline-exposure : -1 0) Close all topics at current level to expose only their immediate children, except for the last topic at the current level, in which even its immediate children are hidden. (outline-exposure -2 : -1 *) Expose children and grandchildren of first topic at current level, and expose children of subsequent topics at current level *except* for the last, which should be opened completely. (defalias 'outline-new-exposure '(macro . #[(&rest spec) "\301\302\303\304DDE\207" [spec save-excursion (if (not (or (outline-goto-prefix) (outline-next-heading))) (error "outline-new-exposure: Can't find any outline topics")) outline-expose-topic quote] 5 (#$ . 112675)])) #@173 Being deprecated - use more recent `outline-new-exposure' instead. Literal frontend for `outline-old-expose-topic', doesn't evaluate arguments and retains start position. (defalias 'outline-exposure '(macro . #[(&rest spec) "\301\302\303\304\305\"BE\207" [spec save-excursion (if (not (or (outline-goto-prefix) (outline-next-heading))) (error "Can't find any outline topics")) outline-old-expose-topic mapcar #[(x) "\301D\207" [x quote] 2]] 6 (#$ . 113881)])) #@130 Convert list representing section/subsection/... to document string. Optional arg CONTEXT indicates interior levels to include. (defalias 'outline-stringify-flat-index #[(flat-index &optional context) "\306\307\211\203 \310\202\f\311 \312V\203=\313 @! A\211\203*\f\n BB\202-\n B \2037 S\2028\312\211\202\314 \203k \203h\f\315\316\317 @!\203U\311\202Y\320 @!!T\321\" BB A\211\204G A\322\323 \",\207" [context context-depth numstr result delim flat-index "." nil 2 1 0 int-to-string " " make-string truncate zerop log10 32 apply concat] 6 (#$ . 114351)]) #@70 Convert list representing section/subsection/... to document string. (defalias 'outline-stringify-flat-index-plain #[(flat-index) "\303\304\n\203\305\n@!\205 BB\nA\211\204\306\307\"*\207" [result delim flat-index "." nil int-to-string apply concat] 4 (#$ . 114938)]) #@70 Convert list representing section/subsection/... to document string. (defalias 'outline-stringify-flat-index-indented #[(flat-index) "\304\305\211\306 @! A\211\203\n BB\202 B\307 \203L \203I\n\310\311\312 @!\2036\313\202:\314 @!!T\315\" BB A\211\204( A\316\317 \"+\207" [numstr result delim flat-index "." nil int-to-string " " make-string truncate zerop 1 log10 32 apply concat] 6 (#$ . 115224)]) #@925 Produce a list representing exposed topics in current region. This list can then be used by `outline-process-exposed' to manipulate the subject region. Optional START and END indicate bounds of region. optional arg, FORMAT, designates an alternate presentation form for the prefix: list - Present prefix as numeric section.subsection..., starting with section indicated by the list, innermost nesting first. `indent' (symbol) - Convert header prefixes to all white space, except for distinctive bullets. The elements of the list produced are lists that represents a topic header and body. The elements of that list are: - a number representing the depth of the topic, - a string representing the header-prefix, including trailing whitespace and bullet. - 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 format) "\212\306\306\306\306\306\306\306\306\306\306 \306!\306\"#b\210\307 \210\310 #V\2039\311\312\306#`S{FC\"\204\200m\204\200`$V\204\200\313%&Z'Z]%S%{&%{\314\315!\210` \316\313!?\"\313%&Z'Z] \fW\307 \210`! b\210\306!`V\203\303 \317\320\212\306\210`)\313#\210h\321U\203\256`S\202\257`{B`!W\203\275\313y\210` \202\217\237(\203*\322\323!)\"\205\330*(<\203\372\f+\203\357\324(\"\202\363\325(!*F\202&(\326=\203 *\203\f\327\fT\330\" \331\306OPE\202&\f\327\f\330\"E\202&\332\333\334(#)\202.\f E B(\2039(<\2039 \fU\203O(@T(AB(\2029 \fV\203^\313(B(\2029 \fW\203o(A(\fS\202^(@\206v\331T(AB(\2029 \237. \207" [strings prefix pad result depth new-depth nil beginning-of-line outline-goto-prefix 0 "" 1 outline-end-of-prefix t outline-next-visible-heading search-forward " " 13 string-match regexp-quote outline-stringify-flat-index outline-stringify-flat-index-plain indent make-string 32 -1 error "outline-listify-exposed: %s %s" "invalid format" out gone-out bullet beg next done start end outline-recent-prefix-end outline-recent-prefix-beginning outline-header-subtraction format outline-distinctive-bullets-string special outline-abbreviate-flattened-numbering] 5 (#$ . 115650) "r"]) #@993 Map function on exposed parts of current topic; results to another buffer. All args are options; default values itemized below. Apply FUNCTION to exposed portions FROM position TO position in buffer FROMBUF to buffer TOBUF. Sixth optional arg, FORMAT, designates an alternate presentation form: `flat' - Present prefix as numeric section.subsection..., starting with section indicated by the start-num, innermost nesting first. X`flat-indented' - Prefix is like `flat' for first topic at each X level, but subsequent topics have only leaf topic X number, padded with blanks to line up with first. `indent' (symbol) - Convert header prefixes to all white space, except for distinctive bullets. Defaults: FUNCTION: `outline-insert-listified' FROM: region start, if region active, else start of buffer TO: region end, if region active, else end of buffer FROMBUF: current buffer TOBUF: buffer name derived: "*current-buffer-name exposed*" FORMAT: nil (defalias 'outline-process-exposed #[(&optional func from to frombuf tobuf format &optional start-num) "\204\306 \203\n\204 \307 \203\310 \311 \202 ed \203B\312 !\204D\313 !\211\204<\314\315 \316Q!\210\202>\f)\202Dp \203U\312 !\204\\\317 !\202\\\320\321 !\322Q<\203f\237\210 q\210\323 \n# q\210\324\"\210\325 !)\207" [func from to frombuf got tobuf outline-insert-listified my-region-active-p region-beginning region-end bufferp get-buffer error "outline-process-exposed: source buffer " " not found." get-buffer-create "*" buffer-name " exposed*" outline-listify-exposed mapcar pop-to-buffer format listified] 5 (#$ . 117942)]) #@266 Insert contents of listified outline portion in current buffer. Listified is a list representing each topic header and body: `(depth prefix text)' or `(depth prefix text bullet-plus)' If `bullet-plus' is specified, it is inserted just after the entire prefix. (defalias 'outline-insert-listified #[(listified) "A\211@A\211@A\211@\304 !\210 \203 \304\305 P!\210\n\2037\304\n@!\210\nA\211\203 \304\306!\210\202 \304\306!+\207" [listified bullet-plus text prefix insert-string " " "\n"] 4 (#$ . 119609)]) #@744 Duplicate exposed portions of current outline to another buffer. Other buffer has current buffers name with " exposed" appended to it. With repeat count, copy the exposed parts of only the current topic. Optional second arg TOBUF is target buffer name. Optional third arg FORMAT, if non-nil, symbolically designates an alternate presentation format for the outline: `flat' - Convert topic header prefixes to numeric section.subsection... identifiers. `indent' - Convert header prefixes to all white space, except for distinctive bullets. `indent-flat' - The best of both - only the first of each level has the full path, the rest have only the section number of the leaf, preceded by the right amount of indentation. (defalias 'outline-copy-exposed-to-buffer #[(&optional arg tobuf format) "\204\f\306\307\310 \311Q!`\n\203\312 \202e\n\203\"\313 \202#dp\314\315=\203A\n\203>\212 b\210\316 )\202?\317\212q\210\320 \210)\321\322 \fp&\210eb\210\323 !\210 b-\207" [tobuf start-pt arg beg end buf get-buffer-create "*" buffer-name " exposed*" outline-back-to-current-heading outline-end-of-current-subtree nil flat outline-topic-flat-index (1) erase-buffer outline-process-exposed outline-insert-listified pop-to-buffer start-list format] 8 (#$ . 120137) "P"]) #@481 Present numeric outline of outline's exposed portions in another buffer. The resulting outline is not compatable with outline mode - use `outline-copy-exposed-to-buffer' if you want that. Use `outline-indented-exposed-to-buffer' for indented presentation. With repeat count, copy the exposed portions of only current topic. Other buffer has current buffers name with " exposed" appended to it, unless optional second arg TOBUF is specified, in which case it is used verbatim. (defalias 'outline-flatten-exposed-to-buffer #[(&optional arg tobuf) "\302 \303#\207" [arg tobuf outline-copy-exposed-to-buffer flat] 4 (#$ . 121455) "P"]) #@490 Present indented outline of outline's exposed portions in another buffer. The resulting outline is not compatable with outline mode - use `outline-copy-exposed-to-buffer' if you want that. Use `outline-flatten-exposed-to-buffer' for numeric sectional presentation. With repeat count, copy the exposed portions of only current topic. Other buffer has current buffers name with " exposed" appended to it, unless optional second arg TOBUF is specified, in which case it is used verbatim. (defalias 'outline-indented-exposed-to-buffer #[(&optional arg tobuf) "\302 \303#\207" [arg tobuf outline-copy-exposed-to-buffer indent] 4 (#$ . 122099) "P"]) #@175 Return copy of STRING for literal reproduction across latex processing. Expresses the original characters (including carriage returns) of the string across latex processing. (defalias 'outline-latex-verb-quote #[(str &optional flow) "\301\302\303#\207" [str mapconcat #[(char) "\301>\203 \302\303!\304Q\207\305U\203\306\207\307!\207" [char (92 36 37 35 38 123 125 95 94 45 42) "\\char" number-to-string "{}" 10 "\\\\" char-to-string] 3] ""] 4 (#$ . 122755)]) #@251 Express line for exact (literal) representation across latex processing. Adjust line contents so it is unaltered (from the original line) across latex processing, within the context of a `verbatim' environment. Leaves point at the end of the line. (defalias 'outline-latex-verbatim-quote-curr-line #[nil "\302 \210`\303\210`\211b\210\304\305\306#\205(\307\224b\210\310\311!\210T\307\225Tb\210\202 *\207" [end beg beginning-of-line nil re-search-forward "\\\\" 1 0 insert-string "\\"] 5 (#$ . 123229)]) #@51 Insert initial latex commands at point in BUFFER. (defalias 'outline-insert-latex-header #[(buf) "q\210\306\307\310\" \203\311\202\312\313\306\314\n\"\306\315 \"\306\316\f\"\306\317 \"\306\320\321\322*\323%\306\324\325\326\327\330\331+\332&\306\333\334\326\335\336+\332&\337\306\320\340\341,\203Q\342\343\344\217\202R\345!\323\346%\347\350\351-./0123456789:\211;:876543210/.-\260c.\207" [buf outline-number-pages outline-title-style outline-label-style outline-head-line-style outline-body-line-style format "\n\\documentstyle{%s}\n" "report" "\\pagestyle{empty}\n" "" "\\def\\beginlines{\\par\\begingroup\\nobreak\\medskip\\parindent=0pt\n \\kern1pt\\nobreak \\obeylines \\obeyspaces \\everypar{\\strut}}\n\\def\\endlines{\\kern1pt\\endgroup\\medbreak\\noindent}\n" "\\newcommand{\\titlecmd}[1]{{%s #1}}\n" "\\newcommand{\\labelcmd}[1]{{%s #1}}\n" "\\newcommand{\\headlinecmd}[1]{{%s #1}}\n" "\\newcommand{\\bodylinecmd}[1]{{%s #1}}\n" "%s%s%s%s" "\\newlength{\\stepsize}\n" "\\setlength{\\stepsize}{" "}\n" "%s%s%s%s%s%s%s" "\\newcommand{\\OneHeadLine}[3]{%\n" "\\noindent%\n" "\\hspace*{#2\\stepsize}%\n" "\\labelcmd{#1}\\hspace*{.2cm}" "\\headlinecmd{#3}\\\\[" "]\n}\n" "%s%s%s%s%s%s" "\\newcommand{\\OneBodyLine}[2]{%\n" "\\hspace*{#1\\stepsize}%\n" "\\bodylinecmd{#2}\\\\[" "\\begin{document}\n\\begin{center}\n" "\\titlecmd{" outline-latex-verb-quote err (eval outline-title) (('error "")) "Unnamed Outline" "\\end{center}\n\n" "\\hsize = 7.5 true in\n" "\\hoffset = -1.5 true in\n" "\\vspace{.1cm}\n\n" outline-indent outline-line-skip outline-title vspace hoffset hsize title begindoc onebodyline oneheadline setlength bodylinecmd headlinecmd labelcmd titlecmd linesdef page-numbering doc-style] 19 (#$ . 123747)]) #@54 Insert concluding latex commands at point in BUFFER. (defalias 'outline-insert-latex-trailer #[(buf) "q\210\301c\207" [buf "\n\\end{document}\n"] 1 (#$ . 125536)]) #@183 Insert LaTeX commands for formatting one outline item. Args are the topics numeric DEPTH, the header PREFIX lead string, the BULLET string, and a list of TEXT strings for the body. (defalias 'outline-latexify-one-item #[(depth prefix bullet text) "\205@A\306\306\306\307\310\311!\312\313 \203$\311 !\202%\314\315\260!\210\n\205\206\307\316!\210\n\203p\n@\f\204F\317\320 \"\204F\321\f\203^\317\322 \"\211\203^ \323 O\324 \306OQ\307 !\210\325 \210\307\326!\210\nA\211\2046\f\203y\306\202\203\327u\210\307\330!\210\331u\210\307\332!-\207" [text head-line body-lines curr-line body-content bop nil insert-string "\\OneHeadLine{\\verb " outline-latex-verb-quote "}{" "}{\\verb " "" "}\n" "\\begin{verbatim}\n" string-match "^\\s-*$" t "\\end{verbatim}" 0 ">" outline-latex-verbatim-quote-curr-line "\n" -1 "\\ " 1 "\\end{verbatim}\n" bullet depth] 9 (#$ . 125708)]) #@254 Format current topics exposed portions to TOBUF for latex processing. TOBUF defaults to a buffer named the same as the current buffer, but with "*" prepended and " latex-formed*" appended. With repeat count, copy the exposed portions of entire buffer. (defalias 'outline-latexify-exposed #[(arg &optional tobuf) "\204\f\306\307\310 \311Q!`\n\203e\202\312 \n\203!d\202#\313 pq\210\314 \210\315!\210db\210\316\317 \f %\210db\210\320!\210eb\210\321 !\210 b,\207" [tobuf start-pt arg beg end buf get-buffer-create "*" buffer-name " latexified*" outline-back-to-current-heading outline-end-of-current-subtree erase-buffer outline-insert-latex-header outline-process-exposed outline-latexify-one-item outline-insert-latex-trailer pop-to-buffer] 6 (#$ . 126614) "P"]) #@57 Put the region around topic currently containing point. (defalias 'outline-mark-topic #[nil "\300 \210\301 \210\302`!\210\303 \210\304 \207" [beginning-of-line outline-goto-prefix push-mark outline-end-of-current-subtree exchange-point-and-mark] 2 (#$ . 127399) nil]) (defalias 'outlinify-sticky 'outlineify-sticky) #@172 Activate outline mode and establish file var so it is started subsequently. See doc-string for `outline-layout' and `outline-init' for details on setup for auto-startup. (defalias 'outlineify-sticky #[(&optional arg) "\302\303!\210\212eb\210\304!\203\303\202R\305\306!\210\307\310!\210\311y\210db\210\312\311!\210\305\313!\210\307\314!\210\305\311!\210\307\315!\210\305\313!\210\307\316!\210\305\313!\210\307\317\320 \206H\321\"!\210\305\313!\210\307\322!)\207" [outline-regexp outline-layout outline-mode t looking-at outline-open-topic 2 insert-string "Dummy outline topic header - see`outline-mode' docstring: `^Hm'." 1 open-line 0 "Local emacs vars.\n" "(`outline-layout' is for allout.el outline-mode)\n" "Local variables:\n" format "outline-layout: %s\n" (-1 : 0) "End:\n"] 4 (#$ . 127722) "P"]) #@141 Solicit (with first arg PROMPT) choice of a character from string STRING. Optional arg DO-DEFAULTING indicates to accept empty input (CR). (defalias 'solicit-char-in-string #[(prompt string &optional do-defaulting) "\306 \204K\307\310\n\"\210\311\306\312 )!\313\314 !\f\"\203\" \202F \2030 \315\230\2030\316\202F \317\230\203=\320\321\306\"\202F \322\f\316\260\306\211\203 *\207" [prompt got new-prompt cursor-in-echo-area string do-defaulting nil message "%s" char-to-string read-char string-match regexp-quote " " "" "" signal quit " ...pick from: "] 6 (#$ . 128537)]) #@219 Return a copy of REGEXP with all character escapes stripped out. Representations of actual backslashes - '\\\\' - are left as a single backslash. Optional arg SUCCESSIVE-BACKSLASHES is used internally for recursion. (defalias 'regexp-sans-escapes #[(regexp &optional successive-backslashes) "\302\230\203\302\207\303H\304U\205 \203 T\202\305\211\203% \306U\2031\303\305O\307\305\310O!P\207\307\305\310O \"\207" [regexp successive-backslashes "" 0 92 1 2 regexp-sans-escapes nil] 6 (#$ . 129136)]) (defalias 'my-region-active-p '(macro . #[nil "\300\301!\203\302\207\303\207" [fboundp region-active-p (region-active-p) mark-active] 2])) (byte-code "\300\301!\204\n\301\302M\210\300\207" [fboundp add-hook #[(hook function &optional append) "\304!\204\n\305L\210 :\203\306 AJ\" \n\232)\202! J>\2066 \2031J C\244\2025 JBL\207" [hook function tail append boundp nil assoc] 3 "Add to the value of HOOK the function FUNCTION unless already present.\n(It becomes the first hook on the list unless optional APPEND is non-nil, in\nwhich case it becomes the last). HOOK should be a symbol, and FUNCTION may be\nany valid function. HOOK's value should be a list of functions, not a single\nfunction. If HOOK is void, it is first set to nil."]] 2) #@177 Accomodate the different signature for mark-marker across emacsen. GNU XEmacs takes two optional args, while mainline GNU Emacs does not, so pass them along when appropriate. (defalias 'my-mark-marker #[(&optional force buffer) "\303\304\"\203\f\305 \n\"\207\305 \207" [emacs-version force buffer string-match " XEmacs " mark-marker] 3 (#$ . 130418)]) #@48 Isearch (regexp) for topic with bullet BULLET. (defalias 'outline-bullet-isearch #[(&optional bullet) "\204 \305\306\307 !\"\310\311\n\312R\313\314!\210\315\310!*\207" [bullet outline-bullets-string outline-header-prefix isearch-string isearch-regexp solicit-char-in-string "ISearch for topic with bullet: " regexp-sans-escapes t "^" "[ ]*" isearch-repeat forward isearch-mode] 5 (#$ . 130779) nil])