*** empty log message ***
[emacs.git] / lisp / hilit-chg.el
blob6c2c7e26ea0c715168a3f2042d42dfc679a73ae6
1 ;;; hilit-chg.el --- minor mode displaying buffer changes with special face
3 ;; Copyright (C) 1998, 2000 Free Software Foundation, Inc.
5 ;; Author: Richard Sharman <rsharman@pobox.com>
6 ;; Keywords: faces
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 2, or (at your option)
13 ;; any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 ;; Boston, MA 02111-1307, USA.
25 ;;; Commentary:
27 ;; A minor mode: "Highlight Changes mode".
30 ;; Highlight Changes mode has 2 submodes: active and passive.
31 ;; When active, changes to the buffer are displayed in a different face.
32 ;; When passive, any existing displayed changes are saved and new ones
33 ;; recorded but are not displayed differently.
34 ;; Why active and passive? Having the changes visible can be handy when you
35 ;; want the information but very distracting otherwise. So, you can keep
36 ;; Highlight Changes mode in passive state while you make your changes, toggle
37 ;; it on to active mode to see them, then toggle it back off to avoid
38 ;; distraction.
40 ;; When active, changes are displayed in `highlight-changes-face'. When
41 ;; text is deleted, the following character is displayed in
42 ;; `highlight-changes-delete-face' face.
45 ;; You can "age" different sets of changes by using
46 ;; `highlight-changes-rotate-faces'. This rotates through a series
47 ;; of different faces, so you can distinguish "new" changes from "older"
48 ;; changes. You can customize these "rotated" faces in two ways. You can
49 ;; either explicitly define each face by customizing
50 ;; `highlight-changes-face-list'. If, however, the faces differ from
51 ;; `highlight-changes-face' only in the foreground color, you can simply set
52 ;; `highlight-changes-colours'. If `highlight-changes-face-list' is nil when
53 ;; the faces are required they will be constructed from
54 ;; `highlight-changes-colours'.
57 ;; When a Highlight Changes mode is on (either active or passive) you can go
58 ;; to the next or previous change with `highlight-changes-next-change' and
59 ;; `highlight-changes-previous-change'.
62 ;; You can also use the command highlight-compare-with-file to show changes
63 ;; in this file compared with another file (typically the previous version
64 ;; of the file). The command highlight-compare-buffers can be used to
65 ;; compare two buffers.
68 ;; There are currently three hooks run by `highlight-changes-mode':
69 ;; `highlight-changes-enable-hook' - is run when Highlight Changes mode
70 ;; is initially enabled for a buffer.
71 ;; `highlight-changes-disable-hook' - is run when Highlight Changes mode
72 ;; is turned off.
73 ;; `highlight-changes-toggle-hook' - is run each time `highlight-changes-mode'
74 ;; is called. Typically this is when
75 ;; toggling between active and passive
76 ;; modes. The variable
77 ;; `highlight-changes-mode' contains the new
78 ;; state (`active' or `passive'.)
82 ;; Example usage:
83 ;; (defun my-highlight-changes-enable-hook ()
84 ;; (add-hook 'local-write-file-hooks 'highlight-changes-rotate-faces)
85 ;; )
87 ;; (defun my-highlight-changes-disable-hook ()
88 ;; (remove-hook 'local-write-file-hooks 'highlight-changes-rotate-faces)
89 ;; )
91 ;; (add-hook 'highlight-changes-enable-hook 'my-highlight-changes-enable-hook)
92 ;; (add-hook 'highlight-changes-disable-hook
93 ;; 'my-highlight-changes-disable-hook)
96 ;; Explicit vs. Implicit
99 ;; Normally, Highlight Changes mode is turned on explicitly in a buffer.
101 ;; If you prefer to have it automatically invoked you can do it as
102 ;; follows.
104 ;; 1. Most modes have a major-hook, typically called MODE-hook. You
105 ;; can use `add-hook' to call `highlight-changes-mode'.
107 ;; Example:
108 ;; (add-hook 'c-mode-hook 'highlight-changes-mode)
110 ;; If you want to make it start up in passive mode (regardless of the
111 ;; setting of highlight-changes-initial-state):
112 ;; (add-hook 'emacs-lisp-mode-hook
113 ;; (lambda ()
114 ;; (highlight-changes-mode 'passive)))
116 ;; However, this cannot be done for Fundamental mode for there is no
117 ;; such hook.
119 ;; 2. You can use the function `global-highlight-changes'
121 ;; This function, which is fashioned after the way `global-font-lock' works,
122 ;; toggles on or off global Highlight Changes mode. When activated, it turns
123 ;; on Highlight Changes mode in all "suitable" existing buffers and will turn
124 ;; it on in new "suitable" buffers to be created.
126 ;; A buffer's "suitability" is determined by variable
127 ;; `highlight-changes-global-modes', as follows. If the variable is
128 ;; * nil -- then no buffers are suitable;
129 ;; * a function -- this function is called and the result is used. As
130 ;; an example, if the value is `buffer-file-name' then all buffers
131 ;; who are visiting files are suitable, but others (like dired
132 ;; buffers) are not;
133 ;; * a list -- then the buffer is suitable iff its mode is in the
134 ;; list, except if the first element is `not', in which case the test
135 ;; is reversed (i.e. it is a list of unsuitable modes).
136 ;; * Otherwise, the buffer is suitable if its name does not begin with
137 ;; ` ' or `*' and if `buffer-file-name' returns true.
142 ;; Possible bindings:
143 ;; (global-set-key '[C-right] 'highlight-changes-next-change)
144 ;; (global-set-key '[C-left] 'highlight-changes-previous-change)
146 ;; Other interactive functions (which could be bound if desired):
147 ;; highlight-changes-mode
148 ;; highlight-changes-remove-highlight
149 ;; highlight-changes-rotate-faces
150 ;; highlight-compare-with-file
151 ;; highlight-compare-buffers
154 ;; You can automatically rotate faces when the buffer is saved;
155 ;; see function `highlight-changes-rotate-faces' for how to do this.
159 ;;; Bugs:
161 ;; - the next-change and previous-change functions are too literal;
162 ;; they should find the next "real" change, in other words treat
163 ;; consecutive changes as one.
166 ;;; To do (maybe), notes, ...
168 ;; - having different faces for deletion and non-deletion: is it
169 ;; really worth the hassle?
170 ;; - should have better hooks: when should they be run?
171 ;; - highlight-compare-with-file should allow RCS files - e.g. nice to be
172 ;; able to say show changes compared with version 2.1.
173 ;; - Maybe we should have compare-with-buffer as well. (When I tried
174 ;; a while back I ran into a problem with ediff-buffers-internal.)
177 ;;; History:
179 ;; R Sharman (rsharman@pobox.com) Feb 1998:
180 ;; - initial release as change-mode.
181 ;; Jari Aalto <jari.aalto@ntc.nokia.com> Mar 1998
182 ;; - fixes for byte compile errors
183 ;; - use eval-and-compile for autoload
184 ;; Marijn Ros <J.M.Ros@fys.ruu.nl> Mar 98
185 ;; - suggested turning it on by default
186 ;; Eric Ludlam <zappo@gnu.org> Suggested using overlays.
187 ;; July 98
188 ;; - global mode and various stuff added
189 ;; - Changed to use overlays
190 ;; August 98
191 ;; - renamed to Highlight Changes mode.
192 ;; Dec 2003
193 ;; - Use require for ediff stuff
194 ;; - Added highlight-compare-buffers
196 ;;; Code:
198 (require 'wid-edit)
200 ;; ====================== Customization =======================
201 (defgroup highlight-changes nil
202 "Highlight Changes mode."
203 :version "20.4"
204 :group 'faces)
207 ;; Face information: How the changes appear.
209 ;; Defaults for face: red foreground, no change to background,
210 ;; and underlined if a change is because of a deletion.
211 ;; Note: underlining is helpful in that it shows up changes in white space.
212 ;; However, having it set for non-delete changes can be annoying because all
213 ;; indentation on inserts gets underlined (which can look pretty ugly!).
215 (defface highlight-changes-face
216 '((((class color)) (:foreground "red" ))
217 (t (:inverse-video t)))
218 "Face used for highlighting changes."
219 :group 'highlight-changes)
221 ;; This looks pretty ugly, actually. Maybe the underline should be removed.
222 (defface highlight-changes-delete-face
223 '((((class color)) (:foreground "red" :underline t))
224 (t (:inverse-video t)))
225 "Face used for highlighting deletions."
226 :group 'highlight-changes)
230 ;; A (not very good) default list of colours to rotate through.
232 (defcustom highlight-changes-colours
233 (if (eq (frame-parameter nil 'background-mode) 'light)
234 ;; defaults for light background:
235 '( "magenta" "blue" "darkgreen" "chocolate" "sienna4" "NavyBlue")
236 ;; defaults for dark background:
237 '("yellow" "magenta" "blue" "maroon" "firebrick" "green4" "DarkOrchid"))
238 "*Colours used by `highlight-changes-rotate-faces'.
239 The newest rotated change will be displayed in the first element of this list,
240 the next older will be in the second element etc.
242 This list is used if `highlight-changes-face-list' is nil, otherwise that
243 variable overrides this list. If you only care about foreground
244 colours then use this, if you want fancier faces then set
245 `highlight-changes-face-list'."
246 :type '(repeat color)
247 :group 'highlight-changes)
250 ;; If you invoke highlight-changes-mode with no argument, should it start in
251 ;; active or passive mode?
253 (defcustom highlight-changes-initial-state 'active
254 "*What state (active or passive) `highlight-changes' should start in.
255 This is used when `highlight-changes' is called with no argument.
256 This variable must be set to one of the symbols `active' or `passive'."
257 :type '(choice (const :tag "Active" active)
258 (const :tag "Passive" passive))
259 :group 'highlight-changes)
261 (defcustom highlight-changes-global-initial-state 'passive
262 "*What state `global-highlight-changes' should start in.
263 This is used if `global-highlight-changes' is called with no argument.
264 This variable must be set to either `active' or `passive'"
265 :type '(choice (const :tag "Active" active)
266 (const :tag "Passive" passive))
267 :group 'highlight-changes)
269 ;; The strings displayed in the mode-line for the minor mode:
270 (defcustom highlight-changes-active-string " +Chg"
271 "*The string used when Highlight Changes mode is in the active state.
272 This should be set to nil if no indication is desired, or to
273 a string with a leading space."
274 :type '(choice string
275 (const :tag "None" nil))
276 :group 'highlight-changes)
278 (defcustom highlight-changes-passive-string " -Chg"
279 "*The string used when Highlight Changes mode is in the passive state.
280 This should be set to nil if no indication is desired, or to
281 a string with a leading space."
282 :type '(choice string
283 (const :tag "None" nil))
284 :group 'highlight-changes)
286 (defcustom highlight-changes-global-modes t
287 "*Determine whether a buffer is suitable for global Highlight Changes mode.
289 A function means call that function to decide: if it returns non-nil,
290 the buffer is suitable.
292 A list means the elements are major modes suitable for Highlight
293 Changes mode, or a list whose first element is `not' followed by major
294 modes which are not suitable.
296 t means the buffer is suitable if it is visiting a file and its name
297 does not begin with ` ' or `*'.
299 A value of nil means no buffers are suitable for `global-highlight-changes'
300 \(effectively disabling the mode).
302 Examples:
303 (c-mode c++-mode)
304 means that Highlight Changes mode is turned on for buffers in C and C++
305 modes only."
306 :type '(choice
307 (const :tag "all non-special buffers visiting files" t)
308 (set :menu-tag "specific modes" :tag "modes"
309 :value (not)
310 (const :tag "All except these" not)
311 (repeat :tag "Modes" :inline t (symbol :tag "mode")))
312 (function :menu-tag "determined by function"
313 :value buffer-file-name)
314 (const :tag "none" nil)
316 :group 'highlight-changes)
318 (defvar global-highlight-changes nil)
320 (defcustom highlight-changes-global-changes-existing-buffers nil
321 "*If non-nil, toggling global Highlight Changes mode affects existing buffers.
322 Normally, `global-highlight-changes' affects only new buffers (to be
323 created). However, if `highlight-changes-global-changes-existing-buffers'
324 is non-nil, then turning on `global-highlight-changes' will turn on
325 Highlight Changes mode in suitable buffers, and turning the mode off will
326 remove it from existing buffers."
327 :type 'boolean
328 :group 'highlight-changes)
330 (defun hilit-chg-cust-fix-changes-face-list (w wc &optional event)
331 ;; When customization function `highlight-changes-face-list' inserts a new
332 ;; face it uses the default face. We don't want the user to modify this
333 ;; face, so we rename the faces in the list on an insert. The rename is
334 ;; actually done by copying the faces so user-defined faces still remain
335 ;; in the same order.
336 ;; The notifying the parent is needed because without it changes to the
337 ;; faces are saved but not to the actual list itself.
338 (let ((old-list (widget-value w)))
339 (if (member 'default old-list)
340 (let
341 ((p (reverse old-list))
342 (n (length old-list))
343 new-name old-name
344 (new-list nil)
346 (while p
347 (setq old-name (car p))
348 (setq new-name (intern (format "highlight-changes-face-%d" n)))
349 (if (eq old-name new-name)
351 ;; A new face has been inserted: we don't want to modify the
352 ;; default face so copy it. Better, though, (I think) is to
353 ;; make a new face have the same attributes as
354 ;; highlight-changes-face .
355 (if (eq old-name 'default)
356 (copy-face 'highlight-changes-face new-name)
357 (copy-face old-name new-name)
359 (setq new-list (append (list new-name) new-list))
360 (setq n (1- n))
361 (setq p (cdr p)))
362 (if (equal new-list (widget-value w))
363 nil ;; (message "notify: no change!")
364 (widget-value-set w new-list)
365 (widget-setup)
368 ;; (message "notify: no default here!")
370 (let ((parent (widget-get w :parent)))
371 (when parent
372 (widget-apply parent :notify w event))))
375 (defcustom highlight-changes-face-list nil
376 "*A list of faces used when rotating changes.
377 Normally the variable is initialized to nil and the list is created from
378 `highlight-changes-colours' when needed. However, you can set this variable
379 to any list of faces. You will have to do this if you want faces which
380 don't just differ from `highlight-changes-face' by the foreground colour.
381 Otherwise, this list will be constructed when needed from
382 `highlight-changes-colours'."
383 :type '(choice
384 (repeat
385 :notify hilit-chg-cust-fix-changes-face-list
386 face )
387 (const :tag "Derive from highlight-changes-colours" nil)
389 :group 'highlight-changes)
391 ;; ========================================================================
393 ;; These shouldn't be changed!
395 ;; Autoload for the benefit of `make-mode-line-mouse-sensitive'.
396 ;;;###autoload
397 (defvar highlight-changes-mode nil)
398 (defvar hilit-chg-list nil)
399 (defvar hilit-chg-string " ??")
400 (or (assq 'highlight-changes-mode minor-mode-alist)
401 (setq minor-mode-alist
402 (cons '(highlight-changes-mode hilit-chg-string) minor-mode-alist)
404 (make-variable-buffer-local 'highlight-changes-mode)
405 (make-variable-buffer-local 'hilit-chg-string)
408 (require 'ediff-init)
409 (require 'ediff-util)
412 ;;; Functions...
414 (defun hilit-chg-map-changes (func &optional start-position end-position)
415 "Call function FUNC for each region used by Highlight Changes mode."
416 ;; if start-position is nil, (point-min) is used
417 ;; if end-position is nil, (point-max) is used
418 ;; FUNC is called with 3 params: property start stop
419 (let ((start (or start-position (point-min)))
420 (limit (or end-position (point-max)))
421 prop end)
422 (while (and start (< start limit))
423 (setq prop (get-text-property start 'hilit-chg))
424 (setq end (text-property-not-all start limit 'hilit-chg prop))
425 (if prop
426 (funcall func prop start (or end limit)))
427 (setq start end))))
430 (defun hilit-chg-display-changes (&optional beg end)
431 "Display face information for Highlight Changes mode.
433 An overlay containing a change face is added from the information
434 in the text property of type `hilit-chg'.
436 This is the opposite of `hilit-chg-hide-changes'."
437 (hilit-chg-map-changes 'hilit-chg-make-ov beg end))
440 (defun hilit-chg-make-ov (prop start end)
441 (or prop
442 (error "hilit-chg-make-ov: prop is nil"))
443 ;; for the region make change overlays corresponding to
444 ;; the text property 'hilit-chg
445 (let ((ov (make-overlay start end))
446 face)
447 (if (eq prop 'hilit-chg-delete)
448 (setq face 'highlight-changes-delete-face)
449 (setq face (nth 1 (member prop hilit-chg-list))))
450 (if face
451 (progn
452 ;; We must mark the face, that is the purpose of the overlay
453 (overlay-put ov 'face face)
454 ;; I don't think we need to set evaporate since we should
455 ;; be controlling them!
456 (overlay-put ov 'evaporate t)
457 ;; We set the change property so we can tell this is one
458 ;; of our overlays (so we don't delete someone else's).
459 (overlay-put ov 'hilit-chg t)
461 (error "hilit-chg-make-ov: no face for prop: %s" prop))))
463 (defun hilit-chg-hide-changes (&optional beg end)
464 "Remove face information for Highlight Changes mode.
466 The overlay containing the face is removed, but the text property
467 containing the change information is retained.
469 This is the opposite of `hilit-chg-display-changes'."
470 (let ((start (or beg (point-min)))
471 (limit (or end (point-max)))
472 p ov)
473 (setq p (overlays-in start limit))
474 (while p
475 ;; don't delete the overlay if it isn't ours!
476 (if (overlay-get (car p) 'hilit-chg)
477 (delete-overlay (car p)))
478 (setq p (cdr p)))))
480 (defun hilit-chg-fixup (beg end)
481 "Fix change overlays in region between BEG and END.
483 Ensure the overlays agree with the changes as determined from
484 the text properties of type `hilit-chg' ."
485 ;; Remove or alter overlays in region beg..end
486 (let (ov-start ov-end props q)
487 ;; temp for debugging:
488 ;; (or (eq highlight-changes-mode 'active)
489 ;; (error "hilit-chg-fixup called but Highlight Changes mode not active"))
490 (dolist (ov (overlays-in beg end))
491 ;; Don't alter overlays that are not ours.
492 (when (overlay-get ov 'hilit-chg)
493 (let ((ov-start (overlay-start ov))
494 (ov-end (overlay-end ov)))
495 (if (< ov-start beg)
496 (progn
497 (move-overlay ov ov-start beg)
498 (if (> ov-end end)
499 (progn
500 (setq props (overlay-properties ov))
501 (setq ov (make-overlay end ov-end))
502 (while props
503 (overlay-put ov (car props)(car (cdr props)))
504 (setq props (cdr (cdr props)))))))
505 (if (> ov-end end)
506 (move-overlay ov end ov-end)
507 (delete-overlay ov))))))
508 (hilit-chg-display-changes beg end)))
510 ;;;###autoload
511 (defun highlight-changes-remove-highlight (beg end)
512 "Remove the change face from the region between BEG and END.
513 This allows you to manually remove highlighting from uninteresting changes."
514 (interactive "r")
515 (let ((after-change-functions nil))
516 (remove-text-properties beg end '(hilit-chg nil))
517 (hilit-chg-fixup beg end)))
519 (defun hilit-chg-set-face-on-change (beg end leng-before
520 &optional no-property-change)
521 "Record changes and optionally display them in a distinctive face.
522 `hilit-chg-set' adds this function to the `after-change-functions' hook."
524 ;; This function is called by the `after-change-functions' hook, which
525 ;; is how we are notified when text is changed.
526 ;; It is also called from `highlight-compare-with-file'.
528 ;; We do NOT want to simply do this if this is an undo command, because
529 ;; otherwise an undone change shows up as changed. While the properties
530 ;; are automatically restored by undo, we must fix up the overlay.
531 (save-match-data
532 (let ((beg-decr 1) (end-incr 1)
533 (type 'hilit-chg)
534 old)
535 (if undo-in-progress
536 (if (eq highlight-changes-mode 'active)
537 (hilit-chg-fixup beg end))
538 (if (and (= beg end) (> leng-before 0))
539 ;; deletion
540 (progn
541 ;; The eolp and bolp tests are a kludge! But they prevent
542 ;; rather nasty looking displays when deleting text at the end
543 ;; of line, such as normal corrections as one is typing and
544 ;; immediately makes a correction, and when deleting first
545 ;; character of a line.
546 ;;; (if (= leng-before 1)
547 ;;; (if (eolp)
548 ;;; (setq beg-decr 0 end-incr 0)
549 ;;; (if (bolp)
550 ;;; (setq beg-decr 0))))
551 ;;; (setq beg (max (- beg beg-decr) (point-min)))
552 (setq end (min (+ end end-incr) (point-max)))
553 (setq type 'hilit-chg-delete))
554 ;; Not a deletion.
555 ;; Most of the time the following is not necessary, but
556 ;; if the current text was marked as a deletion then
557 ;; the old overlay is still in effect, so if we add some
558 ;; text then remove the deletion marking, but set it to
559 ;; changed otherwise its highlighting disappears.
560 (if (eq (get-text-property end 'hilit-chg) 'hilit-chg-delete)
561 (progn
562 (remove-text-properties end (+ end 1) '(hilit-chg nil))
563 (put-text-property end (+ end 1) 'hilit-chg 'hilit-chg)
564 (if (eq highlight-changes-mode 'active)
565 (hilit-chg-fixup beg (+ end 1))))))
566 (unless no-property-change
567 (put-text-property beg end 'hilit-chg type))
568 (if (or (eq highlight-changes-mode 'active) no-property-change)
569 (hilit-chg-make-ov type beg end))))))
571 (defun hilit-chg-set (value)
572 "Turn on Highlight Changes mode for this buffer."
573 (setq highlight-changes-mode value)
574 (remove-hook 'after-change-functions 'hilit-chg-set-face-on-change t)
575 (hilit-chg-make-list)
576 (if (eq highlight-changes-mode 'active)
577 (progn
578 (setq hilit-chg-string highlight-changes-active-string)
579 (or buffer-read-only
580 (hilit-chg-display-changes)))
581 ;; mode is passive
582 (setq hilit-chg-string highlight-changes-passive-string)
583 (or buffer-read-only
584 (hilit-chg-hide-changes)))
585 (force-mode-line-update)
586 (add-hook 'after-change-functions 'hilit-chg-set-face-on-change nil t))
588 (defun hilit-chg-clear ()
589 "Remove Highlight Changes mode for this buffer.
590 This removes all saved change information."
591 (if buffer-read-only
592 ;; We print the buffer name because this function could be called
593 ;; on many buffers from `global-highlight-changes'.
594 (message "Cannot remove highlighting from read-only mode buffer %s"
595 (buffer-name))
596 (remove-hook 'after-change-functions 'hilit-chg-set-face-on-change t)
597 (let ((after-change-functions nil))
598 (hilit-chg-hide-changes)
599 (hilit-chg-map-changes
600 '(lambda (prop start stop)
601 (remove-text-properties start stop '(hilit-chg nil))))
603 (setq highlight-changes-mode nil)
604 (force-mode-line-update)
605 ;; If we type: C-u -1 M-x highlight-changes-mode
606 ;; we want to turn it off, but hilit-chg-post-command-hook
607 ;; runs and that turns it back on!
608 (remove-hook 'post-command-hook 'hilit-chg-post-command-hook)))
610 ;;;###autoload
611 (defun highlight-changes-mode (&optional arg)
612 "Toggle (or initially set) Highlight Changes mode.
614 Without an argument:
615 If Highlight Changes mode is not enabled, then enable it (in either active
616 or passive state as determined by the variable
617 `highlight-changes-initial-state'); otherwise, toggle between active
618 and passive state.
620 With an argument ARG:
621 If ARG is positive, set state to active;
622 If ARG is zero, set state to passive;
623 If ARG is negative, disable Highlight Changes mode completely.
625 Active state - means changes are shown in a distinctive face.
626 Passive state - means changes are kept and new ones recorded but are
627 not displayed in a different face.
629 Functions:
630 \\[highlight-changes-next-change] - move point to beginning of next change
631 \\[highlight-changes-previous-change] - move to beginning of previous change
632 \\[highlight-compare-with-file] - mark text as changed by comparing this
633 buffer with the contents of a file
634 \\[highlight-changes-remove-highlight] - remove the change face from the region
635 \\[highlight-changes-rotate-faces] - rotate different \"ages\" of changes \
636 through
637 various faces.
639 Hook variables:
640 `highlight-changes-enable-hook' - when enabling Highlight Changes mode.
641 `highlight-changes-toggle-hook' - when entering active or passive state
642 `highlight-changes-disable-hook' - when turning off Highlight Changes mode."
643 (interactive "P")
644 (if (or (display-color-p)
645 (and (fboundp 'x-display-grayscale-p) (x-display-grayscale-p)))
646 (let ((was-on highlight-changes-mode)
647 (new-highlight-changes-mode
648 (cond
649 ((null arg)
650 ;; no arg => toggle (or set to active initially)
651 (if highlight-changes-mode
652 (if (eq highlight-changes-mode 'active) 'passive 'active)
653 highlight-changes-initial-state))
654 ;; an argument is given
655 ((eq arg 'active)
656 'active)
657 ((eq arg 'passive)
658 'passive)
659 ((> (prefix-numeric-value arg) 0)
660 'active)
661 ((< (prefix-numeric-value arg) 0)
662 nil)
664 'passive))))
665 (if new-highlight-changes-mode
666 ;; mode is turned on -- but may be passive
667 (progn
668 (hilit-chg-set new-highlight-changes-mode)
669 (or was-on
670 ;; run highlight-changes-enable-hook once
671 (run-hooks 'highlight-changes-enable-hook))
672 (run-hooks 'highlight-changes-toggle-hook))
673 ;; mode is turned off
674 (run-hooks 'highlight-changes-disable-hook)
675 (hilit-chg-clear)))
676 (message "Highlight Changes mode requires color or grayscale display")))
678 ;;;###autoload
679 (defun highlight-changes-next-change ()
680 "Move to the beginning of the next change, if in Highlight Changes mode."
681 (interactive)
682 (if highlight-changes-mode
683 (let ((start (point))
684 prop)
685 (setq prop (get-text-property (point) 'hilit-chg))
686 (if prop
687 ;; we are in a change
688 (setq start (next-single-property-change (point) 'hilit-chg)))
689 (if start
690 (setq start (next-single-property-change start 'hilit-chg)))
691 (if start
692 (goto-char start)
693 (message "no next change")))
694 (message "This buffer is not in Highlight Changes mode.")))
697 ;;;###autoload
698 (defun highlight-changes-previous-change ()
699 "Move to the beginning of the previous change, if in Highlight Changes mode."
700 (interactive)
701 (if highlight-changes-mode
702 (let ( (start (point)) (prop nil) )
703 (or (bobp)
704 (setq prop (get-text-property (1- (point)) 'hilit-chg)))
705 (if prop
706 ;; we are in a change
707 (setq start (previous-single-property-change (point) 'hilit-chg)))
708 (if start
709 (setq start (previous-single-property-change start 'hilit-chg)))
710 ;; special handling for the case where (point-min) is a change
711 (if start
712 (setq start (or (previous-single-property-change start 'hilit-chg)
713 (if (get-text-property (point-min) 'hilit-chg)
714 (point-min)))))
715 (if start
716 (goto-char start)
717 (message "no previous change")))
718 (message "This buffer is not in Highlight Changes mode.")))
720 ;; ========================================================================
722 (defun hilit-chg-make-list (&optional force)
723 "Construct `hilit-chg-list' and `highlight-changes-face-list'."
724 ;; Constructs highlight-changes-face-list if necessary,
725 ;; and hilit-chg-list always:
726 ;; Maybe this should always be called when rotating a face
727 ;; so we pick up any changes?
728 (if (or (null highlight-changes-face-list) ; Don't do it if it
729 force) ; already exists unless FORCE non-nil.
730 (let ((p highlight-changes-colours)
731 (n 1) name)
732 (setq highlight-changes-face-list nil)
733 (while p
734 (setq name (intern (format "highlight-changes-face-%d" n)))
735 (copy-face 'highlight-changes-face name)
736 (set-face-foreground name (car p))
737 (setq highlight-changes-face-list
738 (append highlight-changes-face-list (list name)))
739 (setq p (cdr p))
740 (setq n (1+ n)))))
741 (setq hilit-chg-list (list 'hilit-chg 'highlight-changes-face))
742 (let ((p highlight-changes-face-list)
743 (n 1)
744 last-category last-face)
745 (while p
746 (setq last-category (intern (format "change-%d" n)))
747 ;; (setq last-face (intern (format "highlight-changes-face-%d" n)))
748 (setq last-face (car p))
749 (setq hilit-chg-list
750 (append hilit-chg-list
751 (list last-category last-face)))
752 (setq p (cdr p))
753 (setq n (1+ n)))
754 (setq hilit-chg-list
755 (append hilit-chg-list
756 (list last-category last-face)))))
758 (defun hilit-chg-bump-change (prop start end)
759 "Increment (age) the Highlight Changes mode text property."
760 (let ( new-prop )
761 (if (eq prop 'hilit-chg-delete)
762 (setq new-prop (nth 2 hilit-chg-list))
763 (setq new-prop (nth 2 (member prop hilit-chg-list))))
764 (if prop
765 (put-text-property start end 'hilit-chg new-prop)
766 (message "%d-%d unknown property %s not changed" start end prop))))
768 ;;;###autoload
769 (defun highlight-changes-rotate-faces ()
770 "Rotate the faces used by Highlight Changes mode.
772 Current changes are displayed in the face described by the first element
773 of `highlight-changes-face-list', one level older changes are shown in
774 face described by the second element, and so on. Very old changes remain
775 shown in the last face in the list.
777 You can automatically rotate colours when the buffer is saved
778 by adding the following to `local-write-file-hooks', by evaling it in the
779 buffer to be saved):
781 \(add-hook 'local-write-file-hooks 'highlight-changes-rotate-faces)"
782 (interactive)
783 ;; If not in active mode do nothing but don't complain because this
784 ;; may be bound to a hook.
785 (if (eq highlight-changes-mode 'active)
786 (let ((after-change-functions nil))
787 ;; ensure hilit-chg-list is made and up to date
788 (hilit-chg-make-list)
789 ;; remove our existing overlays
790 (hilit-chg-hide-changes)
791 ;; for each change text property, increment it
792 (hilit-chg-map-changes 'hilit-chg-bump-change)
793 ;; and display them all if active
794 (if (eq highlight-changes-mode 'active)
795 (hilit-chg-display-changes))))
796 ;; This always returns nil so it is safe to use in
797 ;; local-write-file-hook
798 nil)
800 ;; ========================================================================
801 ;; Comparing buffers/files
802 ;; These use ediff to find the differences.
804 (defun highlight-markup-buffers
805 (buf-a file-a buf-b file-b &optional markup-a-only)
806 "Get differences between two buffers and set highlight changes.
807 Both buffers are done unless optional parameter MARKUP-A-ONLY
808 is non-nil."
809 (save-window-excursion
810 (let* (change-info
811 change-a change-b
812 a-start a-end len-a
813 b-start b-end len-b
814 (bufa-modified (buffer-modified-p buf-a))
815 (bufb-modified (buffer-modified-p buf-b))
816 (buf-a-read-only (with-current-buffer buf-a buffer-read-only))
817 (buf-b-read-only (with-current-buffer buf-b buffer-read-only))
818 temp-a temp-b)
819 (if (and file-a bufa-modified)
820 (if (y-or-n-p (format "Save buffer %s? " buf-a))
821 (with-current-buffer buf-a
822 (save-buffer)
823 (setq bufa-modified (buffer-modified-p buf-a)))
824 (setq file-a nil)))
825 (or file-a
826 (setq temp-a (setq file-a (ediff-make-temp-file buf-a nil))))
828 (if (and file-b bufb-modified)
829 (if (y-or-n-p (format "Save buffer %s? " buf-b))
830 (with-current-buffer buf-b
831 (save-buffer)
832 (setq bufb-modified (buffer-modified-p buf-b)))
833 (setq file-b nil)))
834 (or file-b
835 (setq temp-b (setq file-b (ediff-make-temp-file buf-b nil))))
836 (set-buffer buf-a)
837 (highlight-changes-mode 'active)
838 (or markup-a-only (with-current-buffer buf-b
839 (highlight-changes-mode 'active)))
840 (setq change-info (hilit-chg-get-diff-info buf-a file-a buf-b file-b))
843 (setq change-a (car change-info))
844 (setq change-b (car (cdr change-info)))
846 (hilit-chg-make-list)
847 (while change-a
848 (setq a-start (nth 0 (car change-a)))
849 (setq a-end (nth 1 (car change-a)))
850 (setq b-start (nth 0 (car change-b)))
851 (setq b-end (nth 1 (car change-b)))
852 (setq len-a (- a-end a-start))
853 (setq len-b (- b-end b-start))
854 (set-buffer buf-a)
855 (hilit-chg-set-face-on-change a-start a-end len-b buf-a-read-only)
856 (or markup-a-only
857 (with-current-buffer buf-b
858 (hilit-chg-set-face-on-change b-start b-end len-a
859 buf-b-read-only)
861 (setq change-a (cdr change-a))
862 (setq change-b (cdr change-b)))
863 (or bufa-modified
864 (with-current-buffer buf-a (set-buffer-modified-p nil)))
865 (or bufb-modified
866 (with-current-buffer buf-b (set-buffer-modified-p nil)))
867 (if temp-a
868 (delete-file temp-a))
869 (if temp-b
870 (delete-file temp-b)))
873 ;;;###autoload
874 (defun highlight-compare-buffers (buf-a buf-b)
875 "Compare two buffers and highlight the differences.
877 The default is the current buffer and the one in the next window.
879 If either buffer is modified and is visiting a file, you are prompted
880 to save the file.
882 Unless the buffer is unmodified and visiting a file, the buffer is
883 written to a temporary file for comparison.
885 If a buffer is read-only, differences will be highlighted but no property
886 changes are made, so \\[highlight-changes-next-change] and
887 \\[highlight-changes-previous-change] will not work."
888 (interactive
889 (list
890 (get-buffer (read-buffer "buffer-a " (current-buffer) t))
891 (get-buffer
892 (read-buffer "buffer-b "
893 (window-buffer (next-window (selected-window))) t))))
894 (let ((file-a (buffer-file-name buf-a))
895 (file-b (buffer-file-name buf-b)))
896 (highlight-markup-buffers buf-a file-a buf-b file-b)
899 ;;;###autoload
900 (defun highlight-compare-with-file (file-b)
901 "Compare this buffer with a file, and highlight differences.
903 If the buffer has a backup filename, it is used as the default when
904 this function is called interactively.
906 If the current buffer is visiting the file being compared against, it
907 also will have its differences highlighted. Otherwise, the file is
908 read in temporarily but the buffer is deleted.
910 If the buffer is read-only, differences will be highlighted but no property
911 changes are made, so \\[highlight-changes-next-change] and
912 \\[highlight-changes-previous-change] will not work."
913 (interactive (list
914 (read-file-name
915 "File to compare with? " ;; prompt
916 "" ;; directory
917 nil ;; default
918 'yes ;; must exist
919 (let ((f (buffer-file-name (current-buffer))))
920 (if f
921 (progn
922 (setq f (make-backup-file-name f))
923 (or (file-exists-p f)
924 (setq f nil)))
926 f))))
927 (let* ((buf-a (current-buffer))
928 (file-a (buffer-file-name))
929 (existing-buf (get-file-buffer file-b))
930 (buf-b (or existing-buf
931 (find-file-noselect file-b)))
932 (buf-b-read-only (with-current-buffer buf-b buffer-read-only)))
933 (highlight-markup-buffers buf-a file-a buf-b file-b (not existing-buf))
934 (unless existing-buf
935 (kill-buffer buf-b))
939 (defun hilit-chg-get-diff-info (buf-a file-a buf-b file-b)
940 (let ((e nil) x y) ;; e is set by function hilit-chg-get-diff-list-hk
941 (ediff-setup buf-a file-a buf-b file-b
942 nil nil ; buf-c file-C
943 'hilit-chg-get-diff-list-hk
944 (list (cons 'ediff-job-name 'something))
946 (ediff-with-current-buffer e (ediff-really-quit nil))
947 (list x y)))
950 (defun hilit-chg-get-diff-list-hk ()
951 ;; x and y are dynamically bound by hilit-chg-get-diff-info
952 ;; which calls this function as a hook
953 (defvar x) ;; placate the byte-compiler
954 (defvar y)
955 (setq e (current-buffer))
956 (let ((n 0) extent p va vb a b)
957 (setq x nil y nil) ;; x and y are bound by hilit-chg-get-diff-info
958 (while (< n ediff-number-of-differences)
959 (ediff-make-fine-diffs n)
960 (setq va (ediff-get-fine-diff-vector n 'A))
961 ;; va is a vector if there are fine differences
962 (if va
963 (setq a (append va nil))
964 ;; if not, get the unrefined difference
965 (setq va (ediff-get-difference n 'A))
966 (setq a (list (elt va 0))))
967 ;; a list a list
968 (setq p a)
969 (while p
970 (setq extent (list (overlay-start (car p))
971 (overlay-end (car p))))
972 (setq p (cdr p))
973 (setq x (append x (list extent) )));; while p
975 (setq vb (ediff-get-fine-diff-vector n 'B))
976 ;; vb is a vector
977 (if vb
978 (setq b (append vb nil))
979 ;; if not, get the unrefined difference
980 (setq vb (ediff-get-difference n 'B))
981 (setq b (list (elt vb 0))))
982 ;; b list a list
983 (setq p b)
984 (while p
985 (setq extent (list (overlay-start (car p))
986 (overlay-end (car p))))
987 (setq p (cdr p))
988 (setq y (append y (list extent) )))
989 (setq n (1+ n)));; while
990 ;; ediff-quit doesn't work here.
991 ;; No point in returning a value, since this is a hook function.
994 ;; ======================= automatic stuff ==============
996 ;; Global Highlight Changes mode is modeled after Global Font-lock mode.
997 ;; Three hooks are used to gain control. When Global Changes Mode is
998 ;; enabled, `find-file-hooks' and `change-major-mode-hook' are set.
999 ;; `find-file-hooks' is called when visiting a file, the new mode is
1000 ;; known at this time.
1001 ;; `change-major-mode-hook' is called when a buffer is changing mode.
1002 ;; This could be because of finding a file in which case
1003 ;; `find-file-hooks' has already been called and has done its work.
1004 ;; However, it also catches the case where a new mode is being set by
1005 ;; the user. However, it is called from `kill-all-variables' and at
1006 ;; this time the mode is the old mode, which is not what we want.
1007 ;; So, our function temporarily sets `post-command-hook' which will
1008 ;; be called after the buffer has been completely set up (with the new
1009 ;; mode). It then removes the `post-command-hook'.
1010 ;; One other wrinkle - every M-x command runs the `change-major-mode-hook'
1011 ;; so we ignore this by examining the buffer name.
1014 (defun hilit-chg-major-mode-hook ()
1015 (add-hook 'post-command-hook 'hilit-chg-post-command-hook))
1017 (defun hilit-chg-post-command-hook ()
1018 ;; This is called after changing a major mode, but also after each
1019 ;; M-x command, in which case the current buffer is a minibuffer.
1020 ;; In that case, do not act on it here, but don't turn it off
1021 ;; either, we will get called here again soon-after.
1022 ;; Also, don't enable it for other special buffers.
1023 (if (string-match "^[ *]" (buffer-name))
1024 nil ;; (message "ignoring this post-command-hook")
1025 (remove-hook 'post-command-hook 'hilit-chg-post-command-hook)
1026 ;; The following check isn't necessary, since
1027 ;; hilit-chg-turn-on-maybe makes this check too.
1028 (or highlight-changes-mode ;; don't turn it on if it already is
1029 (hilit-chg-turn-on-maybe highlight-changes-global-initial-state))))
1031 (defun hilit-chg-check-global ()
1032 ;; This is called from the find file hook.
1033 (hilit-chg-turn-on-maybe highlight-changes-global-initial-state))
1036 ;;;###autoload
1037 (defun global-highlight-changes (&optional arg)
1038 "Turn on or off global Highlight Changes mode.
1040 When called interactively:
1041 - if no prefix, toggle global Highlight Changes mode on or off
1042 - if called with a positive prefix (or just C-u) turn it on in active mode
1043 - if called with a zero prefix turn it on in passive mode
1044 - if called with a negative prefix turn it off
1046 When called from a program:
1047 - if ARG is nil or omitted, turn it off
1048 - if ARG is `active', turn it on in active mode
1049 - if ARG is `passive', turn it on in passive mode
1050 - otherwise just turn it on
1052 When global Highlight Changes mode is enabled, Highlight Changes mode is turned
1053 on for future \"suitable\" buffers (and for \"suitable\" existing buffers if
1054 variable `highlight-changes-global-changes-existing-buffers' is non-nil).
1055 \"Suitability\" is determined by variable `highlight-changes-global-modes'."
1057 (interactive
1058 (list
1059 (cond
1060 ((null current-prefix-arg)
1061 ;; no arg => toggle it on/off
1062 (setq global-highlight-changes (not global-highlight-changes)))
1063 ;; positive interactive arg - turn it on as active
1064 ((> (prefix-numeric-value current-prefix-arg) 0)
1065 (setq global-highlight-changes t)
1066 'active)
1067 ;; zero interactive arg - turn it on as passive
1068 ((= (prefix-numeric-value current-prefix-arg) 0)
1069 (setq global-highlight-changes t)
1070 'passive)
1071 ;; negative interactive arg - turn it off
1073 (setq global-highlight-changes nil)
1074 nil))))
1076 (if arg
1077 (progn
1078 (if (eq arg 'active)
1079 (setq highlight-changes-global-initial-state 'active)
1080 (if (eq arg 'passive)
1081 (setq highlight-changes-global-initial-state 'passive)))
1082 (setq global-highlight-changes t)
1083 (message "Turning ON Global Highlight Changes mode in %s state"
1084 highlight-changes-global-initial-state)
1085 (add-hook 'hilit-chg-major-mode-hook 'hilit-chg-major-mode-hook)
1086 (add-hook 'find-file-hooks 'hilit-chg-check-global)
1087 (if highlight-changes-global-changes-existing-buffers
1088 (hilit-chg-update-all-buffers
1089 highlight-changes-global-initial-state)))
1091 (message "Turning OFF global Highlight Changes mode")
1092 (remove-hook 'hilit-chg-major-mode-hook 'hilit-chg-major-mode-hook)
1093 (remove-hook 'find-file-hooks 'hilit-chg-check-global)
1094 (remove-hook 'post-command-hook
1095 'hilit-chg-post-command-hook)
1096 (remove-hook 'find-file-hooks 'hilit-chg-check-global)
1097 (if highlight-changes-global-changes-existing-buffers
1098 (hilit-chg-update-all-buffers nil))))
1101 (defun hilit-chg-turn-on-maybe (value)
1102 "Turn on Highlight Changes mode if it is appropriate for this buffer.
1104 A buffer is appropriate for Highlight Changes mode if all these are true:
1105 - the buffer is not a special buffer (one whose name begins with
1106 `*' or ` ')
1107 - the buffer's mode is suitable as per variable
1108 `highlight-changes-global-modes'
1109 - Highlight Changes mode is not already on for this buffer.
1111 This function is called from `hilit-chg-update-all-buffers' or
1112 from `global-highlight-changes' when turning on global Highlight Changes mode."
1113 (or highlight-changes-mode ; do nothing if already on
1115 (cond
1116 ((null highlight-changes-global-modes)
1117 nil)
1118 ((functionp highlight-changes-global-modes)
1119 (funcall highlight-changes-global-modes))
1120 ((listp highlight-changes-global-modes)
1121 (if (eq (car-safe highlight-changes-global-modes) 'not)
1122 (not (memq major-mode (cdr highlight-changes-global-modes)))
1123 (memq major-mode highlight-changes-global-modes)))
1125 (and
1126 (not (string-match "^[ *]" (buffer-name)))
1127 (buffer-file-name))))
1128 (progn
1129 (hilit-chg-set value)
1130 (run-hooks 'highlight-changes-enable-hook)))))
1133 (defun hilit-chg-turn-off-maybe ()
1134 (if highlight-changes-mode
1135 (progn
1136 (run-hooks 'highlight-changes-disable-hook)
1137 (hilit-chg-clear))))
1140 (defun hilit-chg-update-all-buffers (value)
1141 (mapcar
1142 (function (lambda (buffer)
1143 (with-current-buffer buffer
1144 (if value
1145 (hilit-chg-turn-on-maybe value)
1146 (hilit-chg-turn-off-maybe))
1148 (buffer-list)))
1150 ;; ===================== debug ==================
1151 ;; For debug & test use:
1153 ;; (defun hilit-chg-debug-show (&optional beg end)
1154 ;; (interactive)
1155 ;; (message "--- hilit-chg-debug-show ---")
1156 ;; (hilit-chg-map-changes '(lambda (prop start end)
1157 ;; (message "%d-%d: %s" start end prop)
1158 ;; )
1159 ;; beg end
1160 ;; ))
1162 ;; ================== end of debug ===============
1164 (provide 'hilit-chg)
1166 ;;; arch-tag: de00301d-5bad-44da-aa82-e0e010b0c463
1167 ;;; hilit-chg.el ends here