;;; outline.el --- outline mode commands for Emacs
-;; Copyright (C) 1986, 93, 94, 95, 97, 2000, 2001
+;; Copyright (C) 1986, 1993, 1994, 1995, 1997, 2000, 2001, 2004
;; Free Software Foundation, Inc.
;; Maintainer: FSF
(cons '(--- "---") (cdr x))))
outline-mode-menu-bar-map))))))
map))
-
+
(defvar outline-mode-map
(let ((map (make-sparse-keymap)))
0 '(outline-font-lock-face) nil t)))
"Additional expressions to highlight in Outline mode.")
-(defface outline-1 '((t :inherit font-lock-function-name-face)) "Level 1.")
-(defface outline-2 '((t :inherit font-lock-variable-name-face)) "Level 2.")
-(defface outline-3 '((t :inherit font-lock-keyword-face)) "Level 3.")
-(defface outline-4 '((t :inherit font-lock-builtin-face)) "Level 4.")
-(defface outline-5 '((t :inherit font-lock-comment-face)) "Level 5.")
-(defface outline-6 '((t :inherit font-lock-constant-face)) "Level 6.")
-(defface outline-7 '((t :inherit font-lock-type-face)) "Level 7.")
-(defface outline-8 '((t :inherit font-lock-string-face)) "Level 8.")
+(defface outline-1
+ '((t :inherit font-lock-function-name-face))
+ "Level 1."
+ :group 'outlines)
+
+(defface outline-2
+ '((t :inherit font-lock-variable-name-face))
+ "Level 2."
+ :group 'outlines)
+
+(defface outline-3
+ '((t :inherit font-lock-keyword-face))
+ "Level 3."
+ :group 'outlines)
+
+(defface outline-4
+ '((t :inherit font-lock-builtin-face))
+ "Level 4."
+ :group 'outlines)
+
+(defface outline-5
+ '((t :inherit font-lock-comment-face))
+ "Level 5."
+ :group 'outlines)
+
+(defface outline-6
+ '((t :inherit font-lock-constant-face))
+ "Level 6."
+ :group 'outlines)
+
+(defface outline-7
+ '((t :inherit font-lock-type-face))
+ "Level 7."
+ :group 'outlines)
+
+(defface outline-8
+ '((t :inherit font-lock-string-face))
+ "Level 8."
+ :group 'outlines)
(defvar outline-font-lock-faces
[outline-1 outline-2 outline-3 outline-4
(defvar outline-view-change-hook nil
"Normal hook to be run after outline visibility changes.")
+(defvar outline-mode-hook nil
+ "*This hook is run when outline mode starts.")
+
+(defvar outline-blank-line nil
+ "*Non-nil means to leave unhidden blank line before heading.")
+
;;;###autoload
(define-derived-mode outline-mode text-mode "Outline"
"Set major mode for editing outlines with selective display.
(if (re-search-forward (concat "\n\\(?:" outline-regexp "\\)")
nil 'move)
(goto-char (match-beginning 0)))
- (if (and (bolp) (not (bobp)))
+ (if (and (bolp) (or outline-blank-line (eobp)) (not (bobp)))
(forward-char -1)))
(defun outline-next-heading ()
(or (caar outline-heading-alist) "")
(match-string 0)))))
(unless (or (string-match "[ \t]\\'" head)
- (not (string-match outline-regexp (concat head " "))))
+ (not (string-match (concat "\\`\\(?:" outline-regexp "\\)")
+ (concat head " "))))
(setq head (concat head " ")))
(unless (bolp) (end-of-line) (newline))
(insert head)
(save-match-data
(outline-up-heading 1 t)
(match-string 0))))))
-
+
(unless (rassoc level outline-heading-alist)
(push (cons head level) outline-heading-alist))
-
+
(replace-match up-head nil t)))))
(defun outline-demote (&optional children)
;; Bummer!! There is no lower heading in the buffer.
;; Let's try to invent one by repeating the first char.
(let ((new-head (concat (substring head 0 1) head)))
- (if (string-match (concat "\\`" outline-regexp) new-head)
+ (if (string-match (concat "\\`\\(?:" outline-regexp "\\)")
+ new-head)
;; Why bother checking that it is indeed lower level ?
new-head
;; Didn't work: keep it as is so it's still a heading.
(defun outline-move-subtree-down (&optional arg)
"Move the currrent subtree down past ARG headlines of the same level."
(interactive "p")
- (let ((re (concat "^" outline-regexp))
- (movfunc (if (> arg 0) 'outline-get-next-sibling
+ (let ((re (concat "^\\(?:" outline-regexp "\\)"))
+ (movfunc (if (> arg 0) 'outline-get-next-sibling
'outline-get-last-sibling))
(ins-point (make-marker))
(cnt (abs arg))
;; Select the tree
(outline-back-to-heading)
(setq beg (point))
- (save-match-data
- (save-excursion (outline-end-of-heading)
+ (save-match-data
+ (save-excursion (outline-end-of-heading)
(setq folded (outline-invisible-p)))
(outline-end-of-subtree))
(if (= (char-after) ?\n) (forward-char 1))
(setq cnt (1- cnt)))
(if (> arg 0)
;; Moving forward - still need to move over subtree
- (progn (outline-end-of-subtree)
+ (progn (outline-end-of-subtree)
(if (= (char-after) ?\n) (forward-char 1))))
(move-marker ins-point (point))
(insert (delete-and-extract-region beg end))
;; reveal do the rest, by simply doing:
;; (remove-overlays (overlay-start o) (overlay-end o)
;; 'invisible 'outline)
- ;;
+ ;;
;; That works fine as long as everything is in sync, but if the
;; structure of the document is changed while revealing parts of it,
;; the resulting behavior can be ugly. I.e. we need to make
"Hide the body directly following this heading."
(interactive)
(outline-back-to-heading)
- (outline-end-of-heading)
(save-excursion
+ (outline-end-of-heading)
(outline-flag-region (point) (progn (outline-next-preface) (point)) t)))
(defun show-entry ()
(progn (outline-next-preface) (point)) nil)))
(defun hide-body ()
- "Hide all of buffer except headings."
+ "Hide all body lines in buffer, leaving all headings visible."
(interactive)
(hide-region-body (point-min) (point-max)))
(narrow-to-region start end)
(goto-char (point-min))
(if (outline-on-heading-p)
- (outline-end-of-heading))
+ (outline-end-of-heading)
+ (outline-next-preface))
(while (not (eobp))
(outline-flag-region (point)
(progn (outline-next-preface) (point)) t)
(defun outline-show-heading ()
"Show the current heading and move to its end."
(outline-flag-region (- (point)
- (if (bobp) 0
- (if (eq (char-before (1- (point))) ?\n)
- 2 1)))
+ (if (bobp) 0
+ (if (and outline-blank-line
+ (eq (char-before (1- (point))) ?\n))
+ 2 1)))
(progn (outline-end-of-heading) (point))
nil))
(save-excursion
(outline-back-to-heading t)
(show-entry)
- (while (condition-case nil (progn (outline-up-heading 1) (not (bobp)))
+ (while (condition-case nil (progn (outline-up-heading 1 t) (not (bobp)))
(error nil))
(outline-flag-region (1- (point))
(save-excursion (forward-line 1) (point))
(progn
;; Go to end of line before heading
(forward-char -1)
- (if (bolp)
- ;; leave blank line before heading
- (forward-char -1))))))
+ (if (and outline-blank-line (bolp))
+ ;; leave blank line before heading
+ (forward-char -1))))))
\f
(defun show-branches ()
"Show all subheadings of this heading, but not their bodies."
With argument, move up ARG levels.
If INVISIBLE-OK is non-nil, also consider invisible lines."
(interactive "p")
+ (and (eq this-command 'outline-up-heading)
+ (or (eq last-command 'outline-up-heading) (push-mark)))
(outline-back-to-heading invisible-ok)
(let ((start-level (funcall outline-level)))
(if (eq start-level 1)
(provide 'outline)
(provide 'noutline)
+;;; arch-tag: 1724410e-7d4d-4f46-b801-49e18171e874
;;; outline.el ends here
HCoop / bpt / emacs.git / blobdiff