(require 'easymenu)
(defgroup hideshow nil
"Minor mode for hiding and showing program and comment blocks."
:prefix "hs-"
:group 'languages)
(defcustom hs-hide-comments-when-hiding-all t
"*Hide the comments too when you do an `hs-hide-all'."
:type 'boolean
:group 'hideshow)
(defcustom hs-minor-mode-hook nil
"*Hook called when hideshow minor mode is activated or deactivated."
:type 'hook
:group 'hideshow
:version "21.1")
(defcustom hs-isearch-open 'code
"*What kind of hidden blocks to open when doing `isearch'.
One of the following symbols:
code -- open only code blocks
comment -- open only comment blocks
t -- open both code and comment blocks
nil -- open neither code nor comment blocks
This has effect iff `search-invisible' is set to `open'."
:type '(choice (const :tag "open only code blocks" code)
(const :tag "open only comment blocks" comment)
(const :tag "open both code and comment blocks" t)
(const :tag "don't open any of them" nil))
:group 'hideshow)
(defvar hs-special-modes-alist
'((c-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning)
(c++-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning)
(bibtex-mode ("^@\\S(*\\(\\s(\\)" 1))
(java-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning)
)
"*Alist for initializing the hideshow variables for different modes.
Each element has the form
(MODE START END COMMENT-START FORWARD-SEXP-FUNC ADJUST-BEG-FUNC).
If non-nil, hideshow will use these values as regexps to define blocks
and comments, respectively for major mode MODE.
START, END and COMMENT-START are regular expressions. A block is
defined as text surrounded by START and END.
As a special case, START may be a list of the form (COMPLEX-START
MDATA-SELECTOR), where COMPLEX-START is a regexp w/ multiple parts and
MDATA-SELECTOR an integer that specifies which sub-match is the proper
place to adjust point, before calling `hs-forward-sexp-func'. For
example, see the `hs-special-modes-alist' entry for `bibtex-mode'.
For some major modes, `forward-sexp' does not work properly. In those
cases, FORWARD-SEXP-FUNC specifies another function to use instead.
See the documentation for `hs-adjust-block-beginning' to see what is the
use of ADJUST-BEG-FUNC.
If any of the elements is left nil or omitted, hideshow tries to guess
appropriate values. The regexps should not contain leading or trailing
whitespace. Case does not matter.")
(defvar hs-hide-all-non-comment-function nil
"*Function called if non-nil when doing `hs-hide-all' for non-comments.")
(defvar hs-hide-hook nil
"*Hook called (with `run-hooks') at the end of commands to hide text.
These commands include the toggling commands (when the result is to hide
a block), `hs-hide-all', `hs-hide-block' and `hs-hide-level'.")
(defvar hs-show-hook nil
"*Hook called (with `run-hooks') at the end of commands to show text.
These commands include the toggling commands (when the result is to show
a block), `hs-show-all' and `hs-show-block'..")
(defvar hs-minor-mode nil
"Non-nil if using hideshow mode as a minor mode of some other mode.
Use the command `hs-minor-mode' to toggle or set this variable.")
(defvar hs-minor-mode-map nil
"Keymap for hideshow minor mode.")
(defvar hs-minor-mode-menu nil
"Menu for hideshow minor mode.")
(defvar hs-c-start-regexp nil
"Regexp for beginning of comments.
Differs from mode-specific comment regexps in that
surrounding whitespace is stripped.")
(defvar hs-block-start-regexp nil
"Regexp for beginning of block.")
(defvar hs-block-start-mdata-select nil
"Element in `hs-block-start-regexp' match data to consider as block start.
The internal function `hs-forward-sexp' moves point to the beginning of this
element (using `match-beginning') before calling `hs-forward-sexp-func'.")
(defvar hs-block-end-regexp nil
"Regexp for end of block.")
(defvar hs-forward-sexp-func 'forward-sexp
"Function used to do a `forward-sexp'.
Should change for Algol-ish modes. For single-character block
delimiters -- ie, the syntax table regexp for the character is
either `(' or `)' -- `hs-forward-sexp-func' would just be
`forward-sexp'. For other modes such as simula, a more specialized
function is necessary.")
(defvar hs-adjust-block-beginning nil
"Function used to tweak the block beginning.
The block is hidden from the position returned by this function,
as opposed to hiding it from the position returned when searching
for `hs-block-start-regexp'.
For example, in c-like modes, if we wish to also hide the curly braces
(if you think they occupy too much space on the screen), this function
should return the starting point (at the end of line) of the hidden
region.
It is called with a single argument ARG which is the the position in
buffer after the block beginning.
It should return the position from where we should start hiding.
It should not move the point.
See `hs-c-like-adjust-block-beginning' for an example of using this.")
(defvar hs-headline nil
"Text of the line where a hidden block begins, set during isearch.
You can display this in the mode line by adding the symbol `hs-headline'
to the variable `mode-line-format'. For example,
(unless (memq 'hs-headline mode-line-format)
(setq mode-line-format
(append '(\"-\" hs-headline) mode-line-format)))
Note that `mode-line-format' is buffer-local.")
(defalias 'hs-match-data 'match-data)
(defun hs-discard-overlays (from to)
"Delete hideshow overlays in region defined by FROM and TO."
(when (< to from)
(setq from (prog1 to (setq to from))))
(let ((ovs (overlays-in from to)))
(while ovs
(let ((ov (car ovs)))
(when (overlay-get ov 'hs)
(delete-overlay ov)))
(setq ovs (cdr ovs)))))
(defun hs-isearch-show (ov)
"Delete overlay OV, and set `hs-headline' to nil.
This function is meant to be used as the `isearch-open-invisible'
property of an overlay."
(setq hs-headline nil)
(delete-overlay ov))
(defun hs-isearch-show-temporary (ov hide-p)
"Hide or show overlay OV, and set `hs-headline', all depending on HIDE-P.
If HIDE-P is non-nil, `hs-headline' is set to nil and overlay OV is hidden.
Otherwise, `hs-headline' is set to the line of text at the head of OV, and
OV is shown.
This function is meant to be used as the `isearch-open-invisible-temporary'
property of an overlay."
(setq hs-headline
(if hide-p
nil
(or hs-headline
(let ((start (overlay-start ov)))
(buffer-substring
(save-excursion (goto-char start)
(beginning-of-line)
(skip-chars-forward " \t")
(point))
start)))))
(force-mode-line-update)
(overlay-put ov 'invisible (and hide-p 'hs)))
(defun hs-flag-region (from to flag)
"Hide or show lines from FROM to TO, according to FLAG.
If FLAG is nil then text is shown, while if FLAG is non-nil the text is
hidden. FLAG must be one of the symbols `code' or `comment', depending
on what kind of block is to be hidden."
(save-excursion
(hs-discard-overlays from to)
(when flag
(let ((overlay (make-overlay from to)))
(overlay-put overlay 'invisible 'hs)
(overlay-put overlay 'hs flag)
(when (or (eq hs-isearch-open t)
(eq hs-isearch-open flag)
(and (eq 'block hs-isearch-open)
(eq 'code flag)))
(overlay-put overlay 'isearch-open-invisible 'hs-isearch-show)
(overlay-put overlay
'isearch-open-invisible-temporary
'hs-isearch-show-temporary))
overlay))))
(defun hs-forward-sexp (match-data arg)
"Adjust point based on MATCH-DATA and call `hs-forward-sexp-func' w/ ARG.
Original match data is restored upon return."
(save-match-data
(set-match-data match-data)
(goto-char (match-beginning hs-block-start-mdata-select))
(funcall hs-forward-sexp-func arg)))
(defun hs-hide-comment-region (beg end &optional repos-end)
"Hide a region from BEG to END, marking it as a comment.
Optional arg REPOS-END means reposition at end."
(hs-flag-region (progn (goto-char beg) (end-of-line) (point))
(progn (goto-char end) (end-of-line) (point))
'comment)
(goto-char (if repos-end end beg)))
(defun hs-hide-block-at-point (&optional end comment-reg)
"Hide block iff on block beginning.
Optional arg END means reposition at end.
Optional arg COMMENT-REG is a list of the form (BEGIN END) and
specifies the limits of the comment, or nil if the block is not
a comment.
The block beginning is adjusted by `hs-adjust-block-beginning'
and then further adjusted to be at the end of the line."
(if comment-reg
(hs-hide-comment-region (car comment-reg) (cadr comment-reg) end)
(if (looking-at hs-block-start-regexp)
(let* ((mdata (hs-match-data t))
(pure-p (match-end 0))
(p
(save-excursion
(goto-char (funcall (or hs-adjust-block-beginning
'identity)
pure-p))
(end-of-line)
(point)))
(q
(progn (hs-forward-sexp mdata 1)
(end-of-line)
(point))))
(if (and (< p (point)) (> (count-lines p q) 1))
(overlay-put (hs-flag-region p q 'code)
'hs-ofs
(- pure-p p)))
(goto-char (if end q (min p pure-p)))))))
(defun hs-safety-is-job-n ()
"Warn if `buffer-invisibility-spec' does not contain symbol `hs'."
(unless (and (listp buffer-invisibility-spec)
(assq 'hs buffer-invisibility-spec))
(message "Warning: `buffer-invisibility-spec' does not contain hs!!")
(sit-for 2)))
(defun hs-inside-comment-p ()
"Return non-nil if point is inside a comment, otherwise nil.
Actually, return a list containing the buffer position of the start
and the end of the comment. A comment block can be hidden only if on
its starting line there is only whitespace preceding the actual comment
beginning. If we are inside of a comment but this condition is not met,
we return a list having a nil as its car and the end of comment position
as cdr."
(save-excursion
(let ((q (point)))
(when (or (looking-at hs-c-start-regexp)
(re-search-backward hs-c-start-regexp (point-min) t))
(forward-comment (- (buffer-size)))
(skip-chars-forward " \t\n\f")
(let ((p (point))
(not-hidable nil))
(beginning-of-line)
(unless (looking-at (concat "[ \t]*" hs-c-start-regexp))
(goto-char p)
(forward-comment 1)
(skip-chars-forward " \t\n\f")
(setq p (point))
(while (and (< (point) q)
(> (point) p)
(not (looking-at hs-c-start-regexp)))
(setq p (point)) (forward-comment 1)
(skip-chars-forward " \t\n\f"))
(if (or (not (looking-at hs-c-start-regexp))
(> (point) q))
(setq not-hidable t)))
(forward-comment (buffer-size))
(skip-chars-backward " \t\n\f")
(end-of-line)
(if (>= (point) q)
(list (if not-hidable nil p) (point))))))))
(defun hs-grok-mode-type ()
"Set up hideshow variables for new buffers.
If `hs-special-modes-alist' has information associated with the
current buffer's major mode, use that.
Otherwise, guess start, end and `comment-start' regexps; `forward-sexp'
function; and adjust-block-beginning function."
(if (and (boundp 'comment-start)
(boundp 'comment-end)
comment-start comment-end)
(let* ((lookup (assoc major-mode hs-special-modes-alist))
(start-elem (or (nth 1 lookup) "\\s(")))
(if (listp start-elem)
(setq hs-block-start-regexp (car start-elem)
hs-block-start-mdata-select (cadr start-elem))
(setq hs-block-start-regexp start-elem
hs-block-start-mdata-select 0))
(setq hs-block-end-regexp (or (nth 2 lookup) "\\s)")
hs-c-start-regexp (or (nth 3 lookup)
(let ((c-start-regexp
(regexp-quote comment-start)))
(if (string-match " +$" c-start-regexp)
(substring c-start-regexp
0 (1- (match-end 0)))
c-start-regexp)))
hs-forward-sexp-func (or (nth 4 lookup) 'forward-sexp)
hs-adjust-block-beginning (nth 5 lookup)))
(progn
(setq hs-minor-mode nil)
(error "%s Mode doesn't support Hideshow Minor Mode" mode-name))))
(defun hs-find-block-beginning ()
"Reposition point at block-start.
Return point, or nil if original point was not in a block."
(let ((done nil)
(here (point)))
(if (looking-at hs-block-start-regexp)
(point)
(while (and (re-search-backward hs-block-start-regexp nil t)
(not (setq done
(< here (save-excursion
(hs-forward-sexp (hs-match-data t) 1)
(point)))))))
(if done
(point)
(goto-char here)
nil))))
(defun hs-hide-level-recursive (arg minp maxp)
"Recursively hide blocks ARG levels below point in region (MINP MAXP)."
(when (hs-find-block-beginning)
(setq minp (1+ (point)))
(funcall hs-forward-sexp-func 1)
(setq maxp (1- (point))))
(hs-flag-region minp maxp nil) (goto-char minp)
(while (progn
(forward-comment (buffer-size))
(and (< (point) maxp)
(re-search-forward hs-block-start-regexp maxp t)))
(if (> arg 1)
(hs-hide-level-recursive (1- arg) minp maxp)
(goto-char (match-beginning hs-block-start-mdata-select))
(hs-hide-block-at-point t)))
(hs-safety-is-job-n)
(goto-char maxp))
(defmacro hs-life-goes-on (&rest body)
"Evaluate BODY forms iff variable `hs-minor-mode' is non-nil.
In the dynamic context of this macro, `inhibit-point-motion-hooks'
and `case-fold-search' are both t."
`(when hs-minor-mode
(let ((inhibit-point-motion-hooks t)
(case-fold-search t))
,@body)))
(put 'hs-life-goes-on 'edebug-form-spec '(&rest form))
(defun hs-already-hidden-p ()
"Return non-nil if point is in an already-hidden block, otherwise nil."
(save-excursion
(let ((c-reg (hs-inside-comment-p)))
(if (and c-reg (nth 0 c-reg))
(goto-char (nth 0 c-reg))
(if (and (not c-reg)
(hs-find-block-beginning)
(looking-at hs-block-start-regexp))
(goto-char (match-end 0)))))
(end-of-line)
(let ((overlays (overlays-at (point)))
(found nil))
(while (and (not found) (overlayp (car overlays)))
(setq found (overlay-get (car overlays) 'hs)
overlays (cdr overlays)))
found)))
(defun hs-c-like-adjust-block-beginning (initial)
"Adjust INITIAL, the buffer position after `hs-block-start-regexp'.
Actually, point is never moved; a new position is returned that is
the end of the C-function header. This adjustment function is meant
to be assigned to `hs-adjust-block-beginning' for C-like modes."
(save-excursion
(goto-char (1- initial))
(forward-comment (- (buffer-size)))
(point)))
(defun hs-hide-all ()
"Hide all top level blocks, displaying only first and last lines.
Move point to the beginning of the line, and run the normal hook
`hs-hide-hook'. See documentation for `run-hooks'.
If `hs-hide-comments-when-hiding-all' is non-nil, also hide the comments."
(interactive)
(hs-life-goes-on
(message "Hiding all blocks ...")
(save-excursion
(hs-flag-region (point-min) (point-max) nil) (goto-char (point-min))
(let ((count 0)
(re (concat "\\("
hs-block-start-regexp
"\\)"
(if hs-hide-comments-when-hiding-all
(concat "\\|\\("
hs-c-start-regexp
"\\)")
""))))
(while (progn
(unless hs-hide-comments-when-hiding-all
(forward-comment (point-max)))
(re-search-forward re (point-max) t))
(if (match-beginning 1)
(progn
(goto-char (match-beginning 1))
(if hs-hide-all-non-comment-function
(funcall hs-hide-all-non-comment-function)
(hs-hide-block-at-point t)))
(let ((c-reg (hs-inside-comment-p))) (when (and c-reg (car c-reg))
(if (> (count-lines (car c-reg) (nth 1 c-reg)) 1)
(hs-hide-block-at-point t c-reg)
(goto-char (nth 1 c-reg))))))
(message "Hiding ... %d" (setq count (1+ count)))))
(hs-safety-is-job-n))
(beginning-of-line)
(message "Hiding all blocks ... done")
(run-hooks 'hs-hide-hook)))
(defun hs-show-all ()
"Show everything then run `hs-show-hook'. See `run-hooks'."
(interactive)
(hs-life-goes-on
(message "Showing all blocks ...")
(hs-flag-region (point-min) (point-max) nil)
(message "Showing all blocks ... done")
(run-hooks 'hs-show-hook)))
(defun hs-hide-block (&optional end)
"Select a block and hide it. With prefix arg, reposition at END.
Upon completion, point is repositioned and the normal hook
`hs-hide-hook' is run. See documentation for `run-hooks'."
(interactive "P")
(hs-life-goes-on
(let ((c-reg (hs-inside-comment-p)))
(cond
((and c-reg (or (null (nth 0 c-reg))
(<= (count-lines (car c-reg) (nth 1 c-reg)) 1)))
(message "(not enough comment lines to hide)"))
((or c-reg
(looking-at hs-block-start-regexp)
(hs-find-block-beginning))
(hs-hide-block-at-point end c-reg)
(hs-safety-is-job-n)
(run-hooks 'hs-hide-hook))))))
(defun hs-show-block (&optional end)
"Select a block and show it.
With prefix arg, reposition at END. Upon completion, point is
repositioned and the normal hook `hs-show-hook' is run.
See documentation for functions `hs-hide-block' and `run-hooks'."
(interactive "P")
(hs-life-goes-on
(or
(catch 'eol-begins-hidden-region-p
(let ((here (point))
(ovs (save-excursion (end-of-line) (overlays-at (point)))))
(while ovs
(let ((ov (car ovs)))
(when (overlay-get ov 'hs)
(goto-char
(cond (end (overlay-end ov))
((eq 'comment (overlay-get ov 'hs)) here)
(t (+ (overlay-start ov) (overlay-get ov 'hs-ofs)))))
(delete-overlay ov)
(throw 'eol-begins-hidden-region-p t)))
(setq ovs (cdr ovs)))
nil))
(let ((c-reg (hs-inside-comment-p))
p q)
(cond (c-reg
(when (car c-reg)
(setq p (car c-reg)
q (cadr c-reg))))
((and (hs-find-block-beginning)
(looking-at hs-block-start-regexp)) (setq p (point)
q (progn (hs-forward-sexp (hs-match-data t) 1) (point)))))
(when (and p q)
(hs-flag-region p q nil)
(goto-char (if end q (1+ p)))))
(hs-safety-is-job-n)
(run-hooks 'hs-show-hook))))
(defun hs-hide-level (arg)
"Hide all blocks ARG levels below this block.
The hook `hs-hide-hook' is run; see `run-hooks'."
(interactive "p")
(hs-life-goes-on
(save-excursion
(message "Hiding blocks ...")
(hs-hide-level-recursive arg (point-min) (point-max))
(message "Hiding blocks ... done"))
(hs-safety-is-job-n)
(run-hooks 'hs-hide-hook)))
(defun hs-toggle-hiding ()
"Toggle hiding/showing of a block.
See `hs-hide-block' and `hs-show-block'."
(interactive)
(hs-life-goes-on
(if (hs-already-hidden-p)
(hs-show-block)
(hs-hide-block))))
(defun hs-mouse-toggle-hiding (e)
"Toggle hiding/showing of a block.
This command should be bound to a mouse key.
Argument E is a mouse event used by `mouse-set-point'.
See `hs-hide-block' and `hs-show-block'."
(interactive "@e")
(hs-life-goes-on
(mouse-set-point e)
(hs-toggle-hiding)))
(defun hs-hide-initial-comment-block ()
"Hide the first block of comments in a file.
This can be useful if you have huge RCS logs in those comments."
(interactive)
(hs-life-goes-on
(let ((c-reg (save-excursion
(goto-char (point-min))
(skip-chars-forward " \t\n\f")
(hs-inside-comment-p))))
(when c-reg
(let ((beg (car c-reg)) (end (cadr c-reg)))
(when (> (count-lines beg end) 1)
(hs-hide-comment-region beg end)))))))
(defun hs-minor-mode (&optional arg)
"Toggle hideshow minor mode.
With ARG, turn hideshow minor mode on if ARG is positive, off otherwise.
When hideshow minor mode is on, the menu bar is augmented with hideshow
commands and the hideshow commands are enabled.
The value '(hs . t) is added to `buffer-invisibility-spec'.
The main commands are: `hs-hide-all', `hs-show-all', `hs-hide-block',
`hs-show-block', `hs-hide-level' and `hs-toggle-hiding'. There is also
`hs-hide-initial-comment-block' and `hs-mouse-toggle-hiding'.
Turning hideshow minor mode off reverts the menu bar and the
variables to default values and disables the hideshow commands.
Lastly, the normal hook `hs-minor-mode-hook' is run using `run-hooks'.
Key bindings:
\\{hs-minor-mode-map}"
(interactive "P")
(setq hs-headline nil
hs-minor-mode (if (null arg)
(not hs-minor-mode)
(> (prefix-numeric-value arg) 0)))
(if hs-minor-mode
(progn
(hs-grok-mode-type)
(easy-menu-add hs-minor-mode-menu)
(set (make-local-variable 'line-move-ignore-invisible) t)
(add-to-invisibility-spec '(hs . t)))
(easy-menu-remove hs-minor-mode-menu)
(remove-from-invisibility-spec '(hs . t)))
(run-hooks 'hs-minor-mode-hook))
(if hs-minor-mode-map
nil
(setq hs-minor-mode-map (make-sparse-keymap))
(easy-menu-define hs-minor-mode-menu
hs-minor-mode-map
"Menu used when hideshow minor mode is active."
(cons "Hide/Show"
(mapcar
(lambda (ent)
(define-key hs-minor-mode-map (aref ent 2) (aref ent 1))
(if (aref ent 0) ent "-----"))
'(["Hide Block" hs-hide-block "\C-c@\C-h"]
["Show Block" hs-show-block "\C-c@\C-s"]
["Hide All" hs-hide-all "\C-c@\C-\M-h"]
["Show All" hs-show-all "\C-c@\C-\M-s"]
["Hide Level" hs-hide-level "\C-c@\C-l"]
["Toggle Hiding" hs-toggle-hiding "\C-c@\C-c"]
[nil hs-mouse-toggle-hiding [(shift mouse-2)]]
)))))
(or (assq 'hs-minor-mode minor-mode-map-alist)
(setq minor-mode-map-alist
(cons (cons 'hs-minor-mode hs-minor-mode-map)
minor-mode-map-alist)))
(or (assq 'hs-minor-mode minor-mode-alist)
(setq minor-mode-alist (append minor-mode-alist
(list '(hs-minor-mode " hs")))))
(let ((vars '(hs-minor-mode
hs-c-start-regexp
hs-block-start-regexp
hs-block-start-mdata-select
hs-block-end-regexp
hs-forward-sexp-func
hs-adjust-block-beginning)))
(while vars
(let ((var (car vars)))
(make-variable-buffer-local var)
(put var 'permanent-local t))
(setq vars (cdr vars))))
(provide 'hideshow)