1 ;;; hideshow.el --- minor mode cmds to selectively display code/comment blocks
3 ;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 ;; 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 ;; Author: Thien-Thi Nguyen <ttn@gnu.org>
7 ;; Dan Nicolaescu <dann@ics.uci.edu>
8 ;; Keywords: C C++ java lisp tools editing comments blocks hiding outlines
9 ;; Maintainer-Version: 5.65.2.2
10 ;; Time-of-Day-Author-Most-Likely-to-be-Recalcitrant: early morning
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software; you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation; either version 3, or (at your option)
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs; see the file COPYING. If not, write to the
26 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
27 ;; Boston, MA 02110-1301, USA.
31 ;; * Commands provided
33 ;; This file provides Hideshow Minor Mode. When active, nine commands
34 ;; are available, implementing block hiding and showing. They (and their
37 ;; hs-hide-block C-c @ C-h
38 ;; hs-show-block C-c @ C-s
39 ;; hs-hide-all C-c @ C-M-h
40 ;; hs-show-all C-c @ C-M-s
41 ;; hs-hide-level C-c @ C-l
42 ;; hs-toggle-hiding C-c @ C-c
43 ;; hs-mouse-toggle-hiding [(shift mouse-2)]
44 ;; hs-hide-initial-comment-block
46 ;; Blocks are defined per mode. In c-mode, c++-mode and java-mode, they
47 ;; are simply text between curly braces, while in Lisp-ish modes parens
48 ;; are used. Multi-line comment blocks can also be hidden. Read-only
49 ;; buffers are not a problem, since hideshow doesn't modify the text.
51 ;; The command `M-x hs-minor-mode' toggles the minor mode or sets it
52 ;; (similar to other minor modes).
56 ;; First make sure hideshow.el is in a directory in your `load-path'.
57 ;; You can optionally byte-compile it using `M-x byte-compile-file'.
58 ;; Then, add the following to your ~/.emacs:
60 ;; (load-library "hideshow")
61 ;; (add-hook 'X-mode-hook ; other modes similarly
62 ;; (lambda () (hs-minor-mode 1)))
64 ;; where X = {emacs-lisp,c,c++,perl,...}. You can also manually toggle
65 ;; hideshow minor mode by typing `M-x hs-minor-mode'. After hideshow is
66 ;; activated or deactivated, `hs-minor-mode-hook' is run w/ `run-hooks'.
68 ;; Additionally, Joseph Eydelnant writes:
69 ;; I enjoy your package hideshow.el Ver. 5.24 2001/02/13
70 ;; a lot and I've been looking for the following functionality:
71 ;; toggle hide/show all with a single key.
72 ;; Here are a few lines of code that lets me do just that.
74 ;; (defvar my-hs-hide nil "Current state of hideshow for toggling all.")
76 ;; (defun my-toggle-hideshow-all () "Toggle hideshow all."
78 ;; (setq my-hs-hide (not my-hs-hide))
83 ;; [Your hideshow hacks here!]
87 ;; You can use `M-x customize-variable' on the following variables:
89 ;; - hs-hide-comments-when-hiding-all -- self-explanatory!
90 ;; - hs-hide-all-non-comment-function -- if non-nil, when doing a
91 ;; `hs-hide-all', this function
92 ;; is called w/ no arguments
93 ;; - hs-isearch-open -- what kind of hidden blocks to
94 ;; open when doing isearch
96 ;; Some languages (e.g., Java) are deeply nested, so the normal behavior
97 ;; of `hs-hide-all' (hiding all but top-level blocks) results in very
98 ;; little information shown, which is not very useful. You can use the
99 ;; variable `hs-hide-all-non-comment-function' to implement your idea of
100 ;; what is more useful. For example, the following code shows the next
101 ;; nested level in addition to the top-level:
103 ;; (defun ttn-hs-hide-level-1 ()
106 ;; (setq hs-hide-all-non-comment-function 'ttn-hs-hide-level-1)
108 ;; Hideshow works w/ incremental search (isearch) by setting the variable
109 ;; `hs-headline', which is the line of text at the beginning of a hidden
110 ;; block that contains a match for the search. You can have this show up
111 ;; in the mode line by modifying the variable `mode-line-format'. For
112 ;; example, the following code prepends this info to the mode line:
114 ;; (unless (memq 'hs-headline mode-line-format)
115 ;; (setq mode-line-format
116 ;; (append '("-" hs-headline) mode-line-format)))
118 ;; See documentation for `mode-line-format' for more info.
120 ;; Hooks are run after some commands:
122 ;; hs-hide-hook in hs-hide-block, hs-hide-all, hs-hide-level
123 ;; hs-show-hook hs-show-block, hs-show-all
125 ;; One of `hs-hide-hook' or `hs-show-hook' is run for the toggling
126 ;; commands when the result of the toggle is to hide or show blocks,
127 ;; respectively. All hooks are run w/ `run-hooks'. See docs for each
128 ;; variable or hook for more info.
130 ;; Normally, hideshow tries to determine appropriate values for block
131 ;; and comment definitions by examining the buffer's major mode. If
132 ;; there are problems, hideshow will not activate and in that case you
133 ;; may wish to override hideshow's heuristics by adding an entry to
134 ;; variable `hs-special-modes-alist'. Packages that use hideshow should
135 ;; do something like:
137 ;; (add-to-list 'hs-special-modes-alist '(my-mode "{{" "}}" ...))
139 ;; If you have an entry that works particularly well, consider
140 ;; submitting it for inclusion in hideshow.el. See docstring for
141 ;; `hs-special-modes-alist' for more info on the entry format.
143 ;; See also variable `hs-set-up-overlay' for per-block customization of
144 ;; appearance or other effects associated with overlays. For example:
146 ;; (setq hs-set-up-overlay
147 ;; (defun my-display-code-line-counts (ov)
148 ;; (when (eq 'code (overlay-get ov 'hs))
149 ;; (overlay-put ov 'display
151 ;; (format " ... <%d>"
152 ;; (count-lines (overlay-start ov)
153 ;; (overlay-end ov)))
154 ;; 'face 'font-lock-type-face)))))
158 ;; (1) Hideshow does not work w/ emacs 18 because emacs 18 lacks the
159 ;; function `forward-comment' (among other things). If someone
160 ;; writes this, please send me a copy.
162 ;; (2) Sometimes `hs-headline' can become out of sync. To reset, type
163 ;; `M-x hs-minor-mode' twice (that is, deactivate then re-activate
166 ;; (3) Hideshow 5.x is developed and tested on GNU Emacs 20.7.
167 ;; XEmacs compatibility may have bitrotted since 4.29.
169 ;; (4) Some buffers can't be `byte-compile-file'd properly. This is because
170 ;; `byte-compile-file' inserts the file to be compiled in a temporary
171 ;; buffer and switches `normal-mode' on. In the case where you have
172 ;; `hs-hide-initial-comment-block' in `hs-minor-mode-hook', the hiding of
173 ;; the initial comment sometimes hides parts of the first statement (seems
174 ;; to be only in `normal-mode'), so there are unbalanced "(" and ")".
176 ;; The workaround is to clear `hs-minor-mode-hook' when byte-compiling:
178 ;; (defadvice byte-compile-file (around
179 ;; byte-compile-file-hideshow-off
181 ;; (let ((hs-minor-mode-hook nil))
184 ;; (5) Hideshow interacts badly with Ediff and `vc-diff'. At the moment, the
185 ;; suggested workaround is to turn off hideshow entirely, for example:
187 ;; (add-hook 'ediff-prepare-buffer-hook 'turn-off-hideshow)
188 ;; (add-hook 'vc-before-checkin-hook 'turn-off-hideshow)
190 ;; In the case of `vc-diff', here is a less invasive workaround:
192 ;; (add-hook 'vc-before-checkin-hook
194 ;; (goto-char (point-min))
197 ;; Unfortunately, these workarounds do not restore hideshow state.
198 ;; If someone figures out a better way, please let me know.
202 ;; Correspondance welcome; please indicate version number. Send bug
203 ;; reports and inquiries to <ttn@gnu.org>.
207 ;; Thanks go to the following people for valuable ideas, code and
210 ;; Dean Andrews, Alf-Ivar Holm, Holger Bauer, Christoph Conrad, Dave Love,
211 ;; Dirk Herrmann, Gael Marziou, Jan Djarv, Guillaume Leray, Moody Ahmad,
212 ;; Preston F. Crow, Lars Lindberg, Reto Zimmermann, Keith Sheffield,
213 ;; Chew Meng Kuan, Tony Lam, Pete Ware, François Pinard, Stefan Monnier,
214 ;; Joseph Eydelnant, Michael Ernst, Peter Heslin
216 ;; Special thanks go to Dan Nicolaescu, who reimplemented hideshow using
217 ;; overlays (rather than selective display), added isearch magic, folded
218 ;; in custom.el compatibility, generalized comment handling, incorporated
219 ;; mouse support, and maintained the code in general. Version 4.0 is
220 ;; largely due to his efforts.
224 ;; Hideshow was inspired when I learned about selective display. It was
225 ;; reimplemented to use overlays for 4.0 (see above). WRT older history,
226 ;; entries in the masterfile corresponding to versions 1.x and 2.x have
227 ;; been lost. XEmacs support is reliable as of 4.29. State save and
228 ;; restore was added in 3.5 (not widely distributed), and reliable as of
229 ;; 4.30. Otherwise, the code seems stable. Passes checkdoc as of 4.32.
230 ;; Version 5.x uses new algorithms for block selection and traversal,
231 ;; unbundles state save and restore, and includes more isearch support.
235 ;;---------------------------------------------------------------------------
236 ;; user-configurable variables
238 (defgroup hideshow nil
239 "Minor mode for hiding and showing program and comment blocks."
243 (defcustom hs-hide-comments-when-hiding-all t
244 "*Hide the comments too when you do an `hs-hide-all'."
248 (defcustom hs-minor-mode-hook nil
249 "*Hook called when hideshow minor mode is activated or deactivated."
254 (defcustom hs-isearch-open
'code
255 "*What kind of hidden blocks to open when doing `isearch'.
256 One of the following symbols:
258 code -- open only code blocks
259 comment -- open only comment blocks
260 t -- open both code and comment blocks
261 nil -- open neither code nor comment blocks
263 This has effect only if `search-invisible' is set to `open'."
264 :type
'(choice (const :tag
"open only code blocks" code
)
265 (const :tag
"open only comment blocks" comment
)
266 (const :tag
"open both code and comment blocks" t
)
267 (const :tag
"don't open any of them" nil
))
271 (defvar hs-special-modes-alist
272 '((c-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning
)
273 (c++-mode
"{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning
)
274 (bibtex-mode ("@\\S(*\\(\\s(\\)" 1))
275 (java-mode "{" "}" "/[*/]" nil hs-c-like-adjust-block-beginning
))
276 "*Alist for initializing the hideshow variables for different modes.
277 Each element has the form
278 (MODE START END COMMENT-START FORWARD-SEXP-FUNC ADJUST-BEG-FUNC).
280 If non-nil, hideshow will use these values as regexps to define blocks
281 and comments, respectively for major mode MODE.
283 START, END and COMMENT-START are regular expressions. A block is
284 defined as text surrounded by START and END.
286 As a special case, START may be a list of the form (COMPLEX-START
287 MDATA-SELECTOR), where COMPLEX-START is a regexp w/ multiple parts and
288 MDATA-SELECTOR an integer that specifies which sub-match is the proper
289 place to adjust point, before calling `hs-forward-sexp-func'. Point
290 is adjusted to the beginning of the specified match. For example,
291 see the `hs-special-modes-alist' entry for `bibtex-mode'.
293 For some major modes, `forward-sexp' does not work properly. In those
294 cases, FORWARD-SEXP-FUNC specifies another function to use instead.
296 See the documentation for `hs-adjust-block-beginning' to see what is the
297 use of ADJUST-BEG-FUNC.
299 If any of the elements is left nil or omitted, hideshow tries to guess
300 appropriate values. The regexps should not contain leading or trailing
301 whitespace. Case does not matter.")
303 (defvar hs-hide-all-non-comment-function nil
304 "*Function called if non-nil when doing `hs-hide-all' for non-comments.")
306 (defvar hs-allow-nesting nil
307 "*If non-nil, hiding remembers internal blocks.
308 This means that when the outer block is shown again, any
309 previously hidden internal blocks remain hidden.")
311 (defvar hs-hide-hook nil
312 "*Hook called (with `run-hooks') at the end of commands to hide text.
313 These commands include the toggling commands (when the result is to hide
314 a block), `hs-hide-all', `hs-hide-block' and `hs-hide-level'.")
316 (defvar hs-show-hook nil
317 "*Hook called (with `run-hooks') at the end of commands to show text.
318 These commands include the toggling commands (when the result is to show
319 a block), `hs-show-all' and `hs-show-block'..")
321 (defvar hs-set-up-overlay nil
322 "*Function called with one arg, OV, a newly initialized overlay.
323 Hideshow puts a unique overlay on each range of text to be hidden
324 in the buffer. Here is a simple example of how to use this variable:
326 (defun display-code-line-counts (ov)
327 (when (eq 'code (overlay-get ov 'hs))
328 (overlay-put ov 'display
330 (count-lines (overlay-start ov)
331 (overlay-end ov))))))
333 (setq hs-set-up-overlay 'display-code-line-counts)
335 This example shows how to get information from the overlay as well
336 as how to set its `display' property. See `hs-make-overlay' and
337 info node `(elisp)Overlays'.")
339 ;;---------------------------------------------------------------------------
340 ;; internal variables
342 (defvar hs-minor-mode nil
343 "Non-nil if using hideshow mode as a minor mode of some other mode.
344 Use the command `hs-minor-mode' to toggle or set this variable.")
346 (defvar hs-minor-mode-map
347 (let ((map (make-sparse-keymap)))
348 ;; These bindings roughly imitate those used by Outline mode.
349 (define-key map
"\C-c@\C-h" 'hs-hide-block
)
350 (define-key map
"\C-c@\C-s" 'hs-show-block
)
351 (define-key map
"\C-c@\C-\M-h" 'hs-hide-all
)
352 (define-key map
"\C-c@\C-\M-s" 'hs-show-all
)
353 (define-key map
"\C-c@\C-l" 'hs-hide-level
)
354 (define-key map
"\C-c@\C-c" 'hs-toggle-hiding
)
355 (define-key map
[(shift mouse-2
)] 'hs-mouse-toggle-hiding
)
357 "Keymap for hideshow minor mode.")
359 (easy-menu-define hs-minor-mode-menu hs-minor-mode-map
360 "Menu used when hideshow minor mode is active."
362 ["Hide Block" hs-hide-block
363 :help
"Hide the code or comment block at point"]
364 ["Show Block" hs-show-block
365 :help
"Show the code or comment block at point"]
366 ["Hide All" hs-hide-all
367 :help
"Hide all the blocks in the buffer"]
368 ["Show All" hs-show-all
369 :help
"Show all the blocks in the buffer"]
370 ["Hide Level" hs-hide-level
371 :help
"Hide all block at levels below the current block"]
372 ["Toggle Hiding" hs-toggle-hiding
373 :help
"Toggle the hiding state of the current block"]
375 ["Hide comments when hiding all"
376 (setq hs-hide-comments-when-hiding-all
377 (not hs-hide-comments-when-hiding-all
))
378 :help
"If t also hide comment blocks when doing `hs-hide-all'"
379 :style toggle
:selected hs-hide-comments-when-hiding-all
]
381 ["Code blocks" (setq hs-isearch-open
'code
)
382 :help
"Show hidden code blocks when isearch matches inside them"
383 :active t
:style radio
:selected
(eq hs-isearch-open
'code
)]
384 ["Comment blocks" (setq hs-isearch-open
'comment
)
385 :help
"Show hidden comment blocks when isearch matches inside them"
386 :active t
:style radio
:selected
(eq hs-isearch-open
'comment
)]
387 ["Code and Comment blocks" (setq hs-isearch-open t
)
388 :help
"Show both hidden code and comment blocks when isearch matches inside them"
389 :active t
:style radio
:selected
(eq hs-isearch-open t
)]
390 ["None" (setq hs-isearch-open nil
)
391 :help
"Do not hidden code or comment blocks when isearch matches inside them"
392 :active t
:style radio
:selected
(eq hs-isearch-open nil
)])))
394 (defvar hs-c-start-regexp nil
395 "Regexp for beginning of comments.
396 Differs from mode-specific comment regexps in that
397 surrounding whitespace is stripped.")
398 (make-variable-buffer-local 'hs-c-start-regexp
)
400 (defvar hs-block-start-regexp nil
401 "Regexp for beginning of block.")
402 (make-variable-buffer-local 'hs-block-start-regexp
)
404 (defvar hs-block-start-mdata-select nil
405 "Element in `hs-block-start-regexp' match data to consider as block start.
406 The internal function `hs-forward-sexp' moves point to the beginning of this
407 element (using `match-beginning') before calling `hs-forward-sexp-func'.")
408 (make-variable-buffer-local 'hs-block-start-mdata-select
)
410 (defvar hs-block-end-regexp nil
411 "Regexp for end of block.")
413 (defvar hs-forward-sexp-func
'forward-sexp
414 "Function used to do a `forward-sexp'.
415 Should change for Algol-ish modes. For single-character block
416 delimiters -- ie, the syntax table regexp for the character is
417 either `(' or `)' -- `hs-forward-sexp-func' would just be
418 `forward-sexp'. For other modes such as simula, a more specialized
419 function is necessary.")
420 (make-variable-buffer-local 'hs-forward-sexp-func
)
422 (defvar hs-adjust-block-beginning nil
423 "Function used to tweak the block beginning.
424 The block is hidden from the position returned by this function,
425 as opposed to hiding it from the position returned when searching
426 for `hs-block-start-regexp'.
428 For example, in c-like modes, if we wish to also hide the curly braces
429 \(if you think they occupy too much space on the screen), this function
430 should return the starting point (at the end of line) of the hidden
433 It is called with a single argument ARG which is the position in
434 buffer after the block beginning.
436 It should return the position from where we should start hiding.
438 It should not move the point.
440 See `hs-c-like-adjust-block-beginning' for an example of using this.")
441 (make-variable-buffer-local 'hs-adjust-block-beginning
)
443 (defvar hs-headline nil
444 "Text of the line where a hidden block begins, set during isearch.
445 You can display this in the mode line by adding the symbol `hs-headline'
446 to the variable `mode-line-format'. For example,
448 (unless (memq 'hs-headline mode-line-format)
449 (setq mode-line-format
450 (append '(\"-\" hs-headline) mode-line-format)))
452 Note that `mode-line-format' is buffer-local.")
454 ;;---------------------------------------------------------------------------
457 (defun hs-discard-overlays (from to
)
458 "Delete hideshow overlays in region defined by FROM and TO.
459 Skip \"internal\" overlays if `hs-allow-nesting' is non-nil."
461 (setq from
(prog1 to
(setq to from
))))
464 (while (> to
(setq from
(next-overlay-change from
)))
465 (when (setq ov
(hs-overlay-at from
))
466 (setq from
(overlay-end ov
))
467 (delete-overlay ov
))))
468 (dolist (ov (overlays-in from to
))
469 (when (overlay-get ov
'hs
)
470 (delete-overlay ov
)))))
472 (defun hs-make-overlay (b e kind
&optional b-offset e-offset
)
473 "Return a new overlay in region defined by B and E with type KIND.
474 KIND is either `code' or `comment'. Optional fourth arg B-OFFSET
475 when added to B specifies the actual buffer position where the block
476 begins. Likewise for optional fifth arg E-OFFSET. If unspecified
477 they are taken to be 0 (zero). The following properties are set
478 in the overlay: 'invisible 'hs 'hs-b-offset 'hs-e-offset. Also,
479 depending on variable `hs-isearch-open', the following properties may
480 be present: 'isearch-open-invisible 'isearch-open-invisible-temporary.
481 If variable `hs-set-up-overlay' is non-nil it should specify a function
482 to call with the newly initialized overlay."
483 (unless b-offset
(setq b-offset
0))
484 (unless e-offset
(setq e-offset
0))
485 (let ((ov (make-overlay b e
))
486 (io (if (eq 'block hs-isearch-open
)
487 ;; backward compatibility -- `block'<=>`code'
490 (overlay-put ov
'invisible
'hs
)
491 (overlay-put ov
'hs kind
)
492 (overlay-put ov
'hs-b-offset b-offset
)
493 (overlay-put ov
'hs-e-offset e-offset
)
494 (when (or (eq io t
) (eq io kind
))
495 (overlay-put ov
'isearch-open-invisible
'hs-isearch-show
)
496 (overlay-put ov
'isearch-open-invisible-temporary
497 'hs-isearch-show-temporary
))
498 (when hs-set-up-overlay
(funcall hs-set-up-overlay ov
))
501 (defun hs-isearch-show (ov)
502 "Delete overlay OV, and set `hs-headline' to nil.
504 This function is meant to be used as the `isearch-open-invisible'
505 property of an overlay."
506 (setq hs-headline nil
)
509 (defun hs-isearch-show-temporary (ov hide-p
)
510 "Hide or show overlay OV, and set `hs-headline', all depending on HIDE-P.
511 If HIDE-P is non-nil, `hs-headline' is set to nil and overlay OV is hidden.
512 Otherwise, `hs-headline' is set to the line of text at the head of OV, and
515 This function is meant to be used as the `isearch-open-invisible-temporary'
516 property of an overlay."
521 (let ((start (overlay-start ov
)))
523 (save-excursion (goto-char start
)
525 (skip-chars-forward " \t")
528 (force-mode-line-update)
529 ;; handle `display' property specially
532 (when (setq value
(overlay-get ov
'hs-isearch-display
))
533 (overlay-put ov
'display value
)
534 (overlay-put ov
'hs-isearch-display nil
))
535 (when (setq value
(overlay-get ov
'display
))
536 (overlay-put ov
'hs-isearch-display value
)
537 (overlay-put ov
'display nil
))))
538 (overlay-put ov
'invisible
(and hide-p
'hs
)))
540 (defun hs-forward-sexp (match-data arg
)
541 "Adjust point based on MATCH-DATA and call `hs-forward-sexp-func' w/ ARG.
542 Original match data is restored upon return."
544 (set-match-data match-data
)
545 (goto-char (match-beginning hs-block-start-mdata-select
))
546 (funcall hs-forward-sexp-func arg
)))
548 (defun hs-hide-comment-region (beg end
&optional repos-end
)
549 "Hide a region from BEG to END, marking it as a comment.
550 Optional arg REPOS-END means reposition at end."
551 (let ((beg-eol (progn (goto-char beg
) (line-end-position)))
552 (end-eol (progn (goto-char end
) (line-end-position))))
553 (hs-discard-overlays beg-eol end-eol
)
554 (hs-make-overlay beg-eol end-eol
'comment beg end
))
555 (goto-char (if repos-end end beg
)))
557 (defun hs-hide-block-at-point (&optional end comment-reg
)
558 "Hide block if on block beginning.
559 Optional arg END means reposition at end.
560 Optional arg COMMENT-REG is a list of the form (BEGIN END) and
561 specifies the limits of the comment, or nil if the block is not
564 The block beginning is adjusted by `hs-adjust-block-beginning'
565 and then further adjusted to be at the end of the line."
567 (hs-hide-comment-region (car comment-reg
) (cadr comment-reg
) end
)
568 (when (looking-at hs-block-start-regexp
)
569 (let* ((mdata (match-data t
))
570 (pure-p (match-end 0))
572 ;; `p' is the point at the end of the block beginning,
573 ;; which may need to be adjusted
575 (goto-char (funcall (or hs-adjust-block-beginning
578 ;; whatever the adjustment, we move to eol
579 (line-end-position)))
581 ;; `q' is the point at the end of the block
582 (progn (hs-forward-sexp mdata
1)
586 (when (and (< p
(point)) (> (count-lines p q
) 1))
587 (cond ((and hs-allow-nesting
(setq ov
(hs-overlay-at p
)))
589 ((not hs-allow-nesting
)
590 (hs-discard-overlays p q
)))
591 (hs-make-overlay p q
'code
(- pure-p p
)))
592 (goto-char (if end q
(min p pure-p
)))))))
594 (defun hs-inside-comment-p ()
595 "Return non-nil if point is inside a comment, otherwise nil.
596 Actually, return a list containing the buffer position of the start
597 and the end of the comment. A comment block can be hidden only if on
598 its starting line there is only whitespace preceding the actual comment
599 beginning. If we are inside of a comment but this condition is not met,
600 we return a list having a nil as its car and the end of comment position
603 ;; the idea is to look backwards for a comment start regexp, do a
604 ;; forward comment, and see if we are inside, then extend extend
605 ;; forward and backward as long as we have comments
607 (when (or (looking-at hs-c-start-regexp
)
608 (re-search-backward hs-c-start-regexp
(point-min) t
))
609 ;; first get to the beginning of this comment...
610 (while (and (not (bobp))
611 (= (point) (progn (forward-comment -
1) (point))))
613 ;; ...then extend backwards
614 (forward-comment (- (buffer-size)))
615 (skip-chars-forward " \t\n\f")
619 (unless (looking-at (concat "[ \t]*" hs-c-start-regexp
))
620 ;; we are in this situation: (example)
625 ;; the point was here before doing (beginning-of-line)
626 ;; here we should advance till the next comment which
627 ;; eventually has only white spaces preceding it on the same
631 (skip-chars-forward " \t\n\f")
633 (while (and (< (point) q
)
635 (not (looking-at hs-c-start-regexp
)))
636 ;; avoid an infinite cycle
639 (skip-chars-forward " \t\n\f"))
640 (when (or (not (looking-at hs-c-start-regexp
))
642 ;; we cannot hide this comment block
644 ;; goto the end of the comment
645 (forward-comment (buffer-size))
646 (skip-chars-backward " \t\n\f")
649 (list (and hidable p
) (point))))))))
651 (defun hs-grok-mode-type ()
652 "Set up hideshow variables for new buffers.
653 If `hs-special-modes-alist' has information associated with the
654 current buffer's major mode, use that.
655 Otherwise, guess start, end and `comment-start' regexps; `forward-sexp'
656 function; and adjust-block-beginning function."
657 (if (and (boundp 'comment-start
)
658 (boundp 'comment-end
)
659 comment-start comment-end
)
660 (let* ((lookup (assoc major-mode hs-special-modes-alist
))
661 (start-elem (or (nth 1 lookup
) "\\s(")))
662 (if (listp start-elem
)
663 ;; handle (START-REGEXP MDATA-SELECT)
664 (setq hs-block-start-regexp
(car start-elem
)
665 hs-block-start-mdata-select
(cadr start-elem
))
666 ;; backwards compatibility: handle simple START-REGEXP
667 (setq hs-block-start-regexp start-elem
668 hs-block-start-mdata-select
0))
669 (setq hs-block-end-regexp
(or (nth 2 lookup
) "\\s)")
670 hs-c-start-regexp
(or (nth 3 lookup
)
671 (let ((c-start-regexp
672 (regexp-quote comment-start
)))
673 (if (string-match " +$" c-start-regexp
)
674 (substring c-start-regexp
675 0 (1- (match-end 0)))
677 hs-forward-sexp-func
(or (nth 4 lookup
) 'forward-sexp
)
678 hs-adjust-block-beginning
(nth 5 lookup
)))
679 (setq hs-minor-mode nil
)
680 (error "%s Mode doesn't support Hideshow Minor Mode"
681 (format-mode-line mode-name
))))
683 (defun hs-find-block-beginning ()
684 "Reposition point at block-start.
685 Return point, or nil if original point was not in a block."
688 ;; look if current line is block start
689 (if (looking-at hs-block-start-regexp
)
691 ;; look backward for the start of a block that contains the cursor
692 (while (and (re-search-backward hs-block-start-regexp nil t
)
694 (< here
(save-excursion
695 (hs-forward-sexp (match-data t
) 1)
702 (defun hs-hide-level-recursive (arg minp maxp
)
703 "Recursively hide blocks ARG levels below point in region (MINP MAXP)."
704 (when (hs-find-block-beginning)
705 (setq minp
(1+ (point)))
706 (funcall hs-forward-sexp-func
1)
707 (setq maxp
(1- (point))))
708 (unless hs-allow-nesting
709 (hs-discard-overlays minp maxp
))
712 (forward-comment (buffer-size))
713 (and (< (point) maxp
)
714 (re-search-forward hs-block-start-regexp maxp t
)))
716 (hs-hide-level-recursive (1- arg
) minp maxp
)
717 (goto-char (match-beginning hs-block-start-mdata-select
))
718 (hs-hide-block-at-point t
)))
721 (defmacro hs-life-goes-on
(&rest body
)
722 "Evaluate BODY forms if variable `hs-minor-mode' is non-nil.
723 In the dynamic context of this macro, `inhibit-point-motion-hooks'
724 and `case-fold-search' are both t."
726 (let ((inhibit-point-motion-hooks t
)
727 (case-fold-search t
))
730 (put 'hs-life-goes-on
'edebug-form-spec
'(&rest form
))
732 (defun hs-overlay-at (position)
733 "Return hideshow overlay at POSITION, or nil if none to be found."
734 (let ((overlays (overlays-at position
))
736 (while (and (not found
) (setq ov
(car overlays
)))
737 (setq found
(and (overlay-get ov
'hs
) ov
)
738 overlays
(cdr overlays
)))
741 (defun hs-already-hidden-p ()
742 "Return non-nil if point is in an already-hidden block, otherwise nil."
744 (let ((c-reg (hs-inside-comment-p)))
745 (if (and c-reg
(nth 0 c-reg
))
746 ;; point is inside a comment, and that comment is hidable
747 (goto-char (nth 0 c-reg
))
749 (when (and (not c-reg
)
750 (hs-find-block-beginning)
751 (looking-at hs-block-start-regexp
))
752 ;; point is inside a block
753 (goto-char (match-end 0)))))
755 (hs-overlay-at (point))))
757 (defun hs-c-like-adjust-block-beginning (initial)
758 "Adjust INITIAL, the buffer position after `hs-block-start-regexp'.
759 Actually, point is never moved; a new position is returned that is
760 the end of the C-function header. This adjustment function is meant
761 to be assigned to `hs-adjust-block-beginning' for C-like modes."
763 (goto-char (1- initial
))
764 (forward-comment (- (buffer-size)))
767 ;;---------------------------------------------------------------------------
770 (defun hs-hide-all ()
771 "Hide all top level blocks, displaying only first and last lines.
772 Move point to the beginning of the line, and run the normal hook
773 `hs-hide-hook'. See documentation for `run-hooks'.
774 If `hs-hide-comments-when-hiding-all' is non-nil, also hide the comments."
778 (unless hs-allow-nesting
779 (hs-discard-overlays (point-min) (point-max)))
780 (goto-char (point-min))
781 (let ((spew (make-progress-reporter "Hiding all blocks..."
782 (point-min) (point-max)))
784 hs-block-start-regexp
786 (if hs-hide-comments-when-hiding-all
792 (unless hs-hide-comments-when-hiding-all
793 (forward-comment (point-max)))
794 (re-search-forward re
(point-max) t
))
795 (if (match-beginning 1)
796 ;; we have found a block beginning
798 (goto-char (match-beginning 1))
799 (if hs-hide-all-non-comment-function
800 (funcall hs-hide-all-non-comment-function
)
801 (hs-hide-block-at-point t
)))
802 ;; found a comment, probably
803 (let ((c-reg (hs-inside-comment-p)))
804 (when (and c-reg
(car c-reg
))
805 (if (> (count-lines (car c-reg
) (nth 1 c-reg
)) 1)
806 (hs-hide-block-at-point t c-reg
)
807 (goto-char (nth 1 c-reg
))))))
808 (progress-reporter-update spew
(point)))
809 (progress-reporter-done spew
)))
811 (run-hooks 'hs-hide-hook
)))
813 (defun hs-show-all ()
814 "Show everything then run `hs-show-hook'. See `run-hooks'."
817 (message "Showing all blocks ...")
818 (let ((hs-allow-nesting nil
))
819 (hs-discard-overlays (point-min) (point-max)))
820 (message "Showing all blocks ... done")
821 (run-hooks 'hs-show-hook
)))
823 (defun hs-hide-block (&optional end
)
824 "Select a block and hide it. With prefix arg, reposition at END.
825 Upon completion, point is repositioned and the normal hook
826 `hs-hide-hook' is run. See documentation for `run-hooks'."
829 (let ((c-reg (hs-inside-comment-p)))
831 ((and c-reg
(or (null (nth 0 c-reg
))
832 (<= (count-lines (car c-reg
) (nth 1 c-reg
)) 1)))
833 (message "(not enough comment lines to hide)"))
835 (looking-at hs-block-start-regexp
)
836 (hs-find-block-beginning))
837 (hs-hide-block-at-point end c-reg
)
838 (run-hooks 'hs-hide-hook
))))))
840 (defun hs-show-block (&optional end
)
841 "Select a block and show it.
842 With prefix arg, reposition at END. Upon completion, point is
843 repositioned and the normal hook `hs-show-hook' is run.
844 See documentation for functions `hs-hide-block' and `run-hooks'."
848 ;; first see if we have something at the end of the line
849 (let ((ov (hs-overlay-at (line-end-position)))
853 (cond (end (overlay-end ov
))
854 ((eq 'comment
(overlay-get ov
'hs
)) here
)
855 (t (+ (overlay-start ov
) (overlay-get ov
'hs-b-offset
)))))
858 ;; not immediately obvious, look for a suitable block
859 (let ((c-reg (hs-inside-comment-p))
865 ((and (hs-find-block-beginning)
866 ;; ugh, fresh match-data
867 (looking-at hs-block-start-regexp
))
869 q
(progn (hs-forward-sexp (match-data t
) 1) (point)))))
871 (hs-discard-overlays p q
)
872 (goto-char (if end q
(1+ p
)))))
873 (run-hooks 'hs-show-hook
))))
875 (defun hs-hide-level (arg)
876 "Hide all blocks ARG levels below this block.
877 The hook `hs-hide-hook' is run; see `run-hooks'."
881 (message "Hiding blocks ...")
882 (hs-hide-level-recursive arg
(point-min) (point-max))
883 (message "Hiding blocks ... done"))
884 (run-hooks 'hs-hide-hook
)))
886 (defun hs-toggle-hiding ()
887 "Toggle hiding/showing of a block.
888 See `hs-hide-block' and `hs-show-block'."
891 (if (hs-already-hidden-p)
895 (defun hs-mouse-toggle-hiding (e)
896 "Toggle hiding/showing of a block.
897 This command should be bound to a mouse key.
898 Argument E is a mouse event used by `mouse-set-point'.
899 See `hs-hide-block' and `hs-show-block'."
905 (defun hs-hide-initial-comment-block ()
906 "Hide the first block of comments in a file.
907 This can be useful if you have huge RCS logs in those comments."
910 (let ((c-reg (save-excursion
911 (goto-char (point-min))
912 (skip-chars-forward " \t\n\f")
913 (hs-inside-comment-p))))
915 (let ((beg (car c-reg
)) (end (cadr c-reg
)))
916 ;; see if we have enough comment lines to hide
917 (when (> (count-lines beg end
) 1)
918 (hs-hide-comment-region beg end
)))))))
921 (define-minor-mode hs-minor-mode
922 "Minor mode to selectively hide/show code and comment blocks.
923 When hideshow minor mode is on, the menu bar is augmented with hideshow
924 commands and the hideshow commands are enabled.
925 The value '(hs . t) is added to `buffer-invisibility-spec'.
927 The main commands are: `hs-hide-all', `hs-show-all', `hs-hide-block',
928 `hs-show-block', `hs-hide-level' and `hs-toggle-hiding'. There is also
929 `hs-hide-initial-comment-block' and `hs-mouse-toggle-hiding'.
931 Turning hideshow minor mode off reverts the menu bar and the
932 variables to default values and disables the hideshow commands.
934 Lastly, the normal hook `hs-minor-mode-hook' is run using `run-hooks'.
937 \\{hs-minor-mode-map}"
940 :keymap hs-minor-mode-map
941 (setq hs-headline nil
)
945 ;; Turn off this mode if we change major modes.
946 (add-hook 'change-major-mode-hook
949 (easy-menu-add hs-minor-mode-menu
)
950 (set (make-local-variable 'line-move-ignore-invisible
) t
)
951 (add-to-invisibility-spec '(hs . t
)))
952 (remove-from-invisibility-spec '(hs . t
))
953 ;; hs-show-all does nothing unless h-m-m is non-nil.
954 (let ((hs-minor-mode t
))
958 (defun turn-off-hideshow ()
959 "Unconditionally turn off `hs-minor-mode'."
962 ;;---------------------------------------------------------------------------
967 ;; arch-tag: 378b6852-e82a-466a-aee8-d9c73859a65e
968 ;;; hideshow.el ends here