all messages for Emacs-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
* patch to hilight-chg not in emacs 22.1
@ 2008-03-16 17:52 Richard Sharman
  2008-03-17 14:11 ` Stefan Monnier
  2008-03-18  9:55 ` martin rudalics
  0 siblings, 2 replies; 10+ messages in thread
From: Richard Sharman @ 2008-03-16 17:52 UTC (permalink / raw)
  To: Stefan Monnier, martin rudalics, Emacs Devel
  Cc: Juanma Barranquero, Richard Stallman

[-- Attachment #1: Type: text/plain, Size: 1275 bytes --]

Hello.

On 23 Oct 2006, Richard Stallman wrote

> Is there an important reason to overload M-x highlight-changes-mode
> for toggling between active and passive mode?  Would it be
> inconvenient to make that a separate command, so that M-x
> highlight-changes-mode could follow the conventions for minor modes?

After a while I made some changes to do that,  and RMS accepted them   
on 14 Dec.

I only just realized that they didn't make it to the official 22.1  
release.

One reason might be that I had coupled with it a change to easy- 
mmode.el because I was loathe to have disabling global highlight  
changes mode disable highlight changes in existing buffers. When  
testing the old patch I found there was problems with it when it when  
it was byte-compiled.

So,  I have simplified the change to hilit-chg.el and have removed  
the part that required the change to easy-mmode.  (I think what I was  
previously doing was overkill anyway.)

I will attach here this new patch (against 22.1).

(I have an archive of the mail messages on the thread if this is of  
interest, but it deals a lot with the change that I have removed.)

Note:  I have not addressed the problem mentioned by Stefan and  
Martin,  since it seems as if they have already handled it.

Richard


[-- Attachment #2: hilit-chg.el.cdif --]
[-- Type: application/octet-stream, Size: 45362 bytes --]

*** hilit-chg.el.orig	Thu Mar 13 22:55:20 2008
--- hilit-chg.el	Thu Mar 13 22:20:36 2008
***************
*** 26,85 ****
  ;;; Commentary:
  
  ;; A minor mode: "Highlight Changes mode".
- ;;
  
! ;; Highlight Changes mode has 2 submodes: active and passive.
! ;; When active, changes to the buffer are displayed in a different face.
! ;; When passive, any existing displayed changes are saved and new ones
! ;; recorded but are not displayed differently.
! ;; Why active and passive?  Having the changes visible can be handy when you
! ;; want the information but very distracting otherwise.  So, you can keep
! ;; Highlight Changes mode in passive state while you make your changes, toggle
! ;; it on to active mode to see them, then toggle it back off to avoid
! ;; distraction.
! ;;
! ;; When active, changes are displayed in the `highlight-changes' face.
! ;; When text is deleted, the following character is displayed in the
! ;; `highlight-changes-delete' face.
! ;;
  ;;
  ;; You can "age" different sets of changes by using
  ;; `highlight-changes-rotate-faces'.  This rotates through a series
  ;; of different faces, so you can distinguish "new" changes from "older"
  ;; changes.  You can customize these "rotated" faces in two ways.  You can
  ;; either explicitly define each face by customizing
  ;; `highlight-changes-face-list'.  If, however, the faces differ from
! ;; the `highlight-changes' face only in the foreground color, you can simply set
! ;; `highlight-changes-colors'.  If `highlight-changes-face-list' is nil when
  ;; the faces are required they will be constructed from
! ;; `highlight-changes-colors'.
! ;;
! ;;
! ;; When a Highlight Changes mode is on (either active or passive) you can go
! ;; to the next or previous change with `highlight-changes-next-change' and
! ;; `highlight-changes-previous-change'.
! ;;
! ;;
! ;; You can also use the command highlight-compare-with-file to show changes
! ;; in this file compared with another file (typically the previous version
! ;; of the file).  The command highlight-compare-buffers can be used to
! ;; compare two buffers.
! ;;
! ;;
! ;; There are currently three hooks run by `highlight-changes-mode':
  ;; `highlight-changes-enable-hook'  - is run when Highlight Changes mode
! ;;				    is initially enabled for a buffer.
  ;; `highlight-changes-disable-hook' - is run when Highlight Changes mode
! ;;				    is turned off.
! ;; `highlight-changes-toggle-hook'  - is run each time `highlight-changes-mode'
! ;;				    is called.  Typically this is when
! ;;				    toggling between active and passive
! ;;				    modes.  The variable
! ;;				    `highlight-changes-mode' contains the new
! ;;				    state (`active' or `passive'.)
! ;;
! ;;
! ;;
  ;; Example usage:
  ;; (defun my-highlight-changes-enable-hook ()
  ;;   (add-hook 'write-file-functions 'highlight-changes-rotate-faces nil t)
--- 26,73 ----
  ;;; Commentary:
  
  ;; A minor mode: "Highlight Changes mode".
  
! ;; When Highlight Changes mode is enabled changes to the buffer are
! ;; recorded with a text property.  Normally these ranges of text are
! ;; displayed in a distinctive face.  However, sometimes it is
! ;; desirable to temporarily not see these changes.  Rather than
! ;; disabling Highlight Changes mode (thus removing the text property)
! ;; use the command highlight-changes-toggle-visibility.
! 
! ;; Two faces are supported: one for changed or inserted text and
! ;; another for the first character after text has been deleted.
! 
! ;; When Highlight Changes mode is on (even if changes are not visible)
! ;; you can go to the next or previous change with
! ;; `highlight-changes-next-change' or `highlight-changes-previous-change'.
! 
! ;; Command highlight-compare-with-file shows changes in this file
! ;; compared with another file (by default the previous version of the
! ;; file).
  ;;
+ ;; The command highlight-compare-buffers compares two buffers by
+ ;; highlighting their differences.
+ 
  ;; You can "age" different sets of changes by using
  ;; `highlight-changes-rotate-faces'.  This rotates through a series
  ;; of different faces, so you can distinguish "new" changes from "older"
  ;; changes.  You can customize these "rotated" faces in two ways.  You can
  ;; either explicitly define each face by customizing
  ;; `highlight-changes-face-list'.  If, however, the faces differ from
! ;; `highlight-changes-face' only in the foreground color, you can simply set
! ;; `highlight-changes-colours'.  If `highlight-changes-face-list' is nil when
  ;; the faces are required they will be constructed from
! ;; `highlight-changes-colours'.
! 
! ;; You can automatically rotate faces when the buffer is saved;
! ;; see function `highlight-changes-rotate-faces' for how to do this.
! 
! ;; There are two hooks used by `highlight-changes-mode':
  ;; `highlight-changes-enable-hook'  - is run when Highlight Changes mode
! ;;				    is enabled for a buffer.
  ;; `highlight-changes-disable-hook' - is run when Highlight Changes mode
! ;;				    is disabled for a buffer.
! 
  ;; Example usage:
  ;; (defun my-highlight-changes-enable-hook ()
  ;;   (add-hook 'write-file-functions 'highlight-changes-rotate-faces nil t)
***************
*** 94,142 ****
  ;;		'my-highlight-changes-disable-hook)
  
  
! ;;           Explicit vs. Implicit
! ;;
  
  ;; Normally, Highlight Changes mode is turned on explicitly in a buffer.
! ;;
  ;; If you prefer to have it automatically invoked you can do it as
  ;; follows.
! ;;
  ;; 1. Most modes have a major-hook, typically called MODE-hook.  You
  ;; can use `add-hook' to call `highlight-changes-mode'.
! ;;
  ;;   Example:
  ;;	(add-hook 'c-mode-hook 'highlight-changes-mode)
! ;;
! ;;  If you want to make it start up in passive mode (regardless of the
! ;;  setting of highlight-changes-initial-state):
! ;;      (add-hook 'emacs-lisp-mode-hook
! ;; 	    (lambda ()
! ;; 	      (highlight-changes-mode 'passive)))
! ;;
  ;; However, this cannot be done for Fundamental mode for there is no
  ;; such hook.
! ;;
! ;; 2. You can use the function `global-highlight-changes'
! ;;
  ;; This function, which is fashioned after the way `global-font-lock' works,
  ;; toggles on or off global Highlight Changes mode.  When activated, it turns
  ;; on Highlight Changes mode in all "suitable" existing buffers and will turn
  ;; it on in new "suitable" buffers to be created.
! ;;
  ;; A buffer's "suitability" is determined by variable
! ;; `highlight-changes-global-modes', as follows.  If the variable is
  ;; * nil  -- then no buffers are suitable;
  ;; * a function -- this function is called and the result is used.  As
  ;;   an example, if the value is `buffer-file-name' then all buffers
  ;;   who are visiting files are suitable, but others (like dired
  ;;   buffers) are not;
! ;; * a list -- then the buffer is suitable iff its mode is in the
! ;;   list, except if the first element is `not', in which case the test
  ;;   is reversed (i.e. it is a list of unsuitable modes).
  ;; * Otherwise, the buffer is suitable if its name does not begin with
  ;;   ` ' or `*' and if `buffer-file-name' returns true.
! ;;
  
  
  
--- 82,127 ----
  ;;		'my-highlight-changes-disable-hook)
  
  
! 
! ;;           Automatically enabling Highlight Changes mode
! 
  
  ;; Normally, Highlight Changes mode is turned on explicitly in a buffer.
! 
  ;; If you prefer to have it automatically invoked you can do it as
  ;; follows.
! 
  ;; 1. Most modes have a major-hook, typically called MODE-hook.  You
  ;; can use `add-hook' to call `highlight-changes-mode'.
! 
  ;;   Example:
  ;;	(add-hook 'c-mode-hook 'highlight-changes-mode)
! 
  ;; However, this cannot be done for Fundamental mode for there is no
  ;; such hook.
! 
! ;; 2. You can use the function `global-highlight-changes-mode'
! 
  ;; This function, which is fashioned after the way `global-font-lock' works,
  ;; toggles on or off global Highlight Changes mode.  When activated, it turns
  ;; on Highlight Changes mode in all "suitable" existing buffers and will turn
  ;; it on in new "suitable" buffers to be created.
! 
  ;; A buffer's "suitability" is determined by variable
! ;; `highlight-changes-global-modes' as follows.  If this variable is
  ;; * nil  -- then no buffers are suitable;
  ;; * a function -- this function is called and the result is used.  As
  ;;   an example, if the value is `buffer-file-name' then all buffers
  ;;   who are visiting files are suitable, but others (like dired
  ;;   buffers) are not;
! ;; * a list -- then the buffer is suitable if and only if its mode is in the
! ;;   list, unless the first element is `not' in which case the test
  ;;   is reversed (i.e. it is a list of unsuitable modes).
  ;; * Otherwise, the buffer is suitable if its name does not begin with
  ;;   ` ' or `*' and if `buffer-file-name' returns true.
! 
! ;; To enable it for future sessions put this in your ~/.emacs file:
! ;;		(global-highlight-changes-mode t)
  
  
  
***************
*** 144,160 ****
  ;; (global-set-key '[C-right] 'highlight-changes-next-change)
  ;; (global-set-key '[C-left]  'highlight-changes-previous-change)
  ;;
! ;;     Other interactive functions (which could be bound if desired):
  ;; highlight-changes-mode
  ;; highlight-changes-remove-highlight
- ;; highlight-changes-rotate-faces
  ;; highlight-compare-with-file
  ;; highlight-compare-buffers
! 
! ;;
! ;; You can automatically rotate faces when the buffer is saved;
! ;; see function `highlight-changes-rotate-faces' for how to do this.
! ;;
  
  
  ;;; Bugs:
--- 129,141 ----
  ;; (global-set-key '[C-right] 'highlight-changes-next-change)
  ;; (global-set-key '[C-left]  'highlight-changes-previous-change)
  ;;
! ;;     Other interactive functions (that could be bound if desired):
  ;; highlight-changes-mode
+ ;; highlight-changes-toggle-visibility
  ;; highlight-changes-remove-highlight
  ;; highlight-compare-with-file
  ;; highlight-compare-buffers
! ;; highlight-changes-rotate-faces
  
  
  ;;; Bugs:
***************
*** 168,178 ****
  
  ;; - having different faces for deletion and non-deletion: is it
  ;;   really worth the hassle?
- ;; - should have better hooks:  when should they be run?
  ;; - highlight-compare-with-file should allow RCS files - e.g. nice to be
  ;;   able to say show changes compared with version 2.1.
- ;; - Maybe we should have compare-with-buffer as well.  (When I tried
- ;;   a while back I ran into a problem with ediff-buffers-internal.)
  
  
  ;;; History:
--- 149,156 ----
***************
*** 190,198 ****
  ;; - Changed to use overlays
  ;; August 98
  ;; - renamed to Highlight Changes mode.
! ;; Dec 2003
! ;; - Use require for ediff stuff
  ;; - Added highlight-compare-buffers
  
  ;;; Code:
  
--- 168,181 ----
  ;; - Changed to use overlays
  ;; August 98
  ;; - renamed to Highlight Changes mode.
! ;; Nov 2006
! ;; - Made highlight-changes-mode like other modes (toggle on/off)
! ;; - Added new command highlight-changes-toggle-visibility to replace the
! ;;   previous active/passive aspect of highlight-changes-mode.
! ;; - Removed highlight-changes-toggle-hook
  ;; - Added highlight-compare-buffers
+ ;; - Put back eval-and-compile inadvertently dropped
+ 
  
  ;;; Code:
  
***************
*** 254,298 ****
    :group 'highlight-changes)
  
  (define-obsolete-variable-alias 'highlight-changes-colours
!                                 'highlight-changes-colors "22.1")
  
  
! ;; If you invoke highlight-changes-mode with no argument, should it start in
! ;; active or passive mode?
! ;;
! (defcustom highlight-changes-initial-state 'active
!   "*What state (active or passive) Highlight Changes mode should start in.
! This is used when `highlight-changes-mode' is called with no argument.
! This variable must be set to one of the symbols `active' or `passive'."
!   :type '(choice (const :tag "Active" active)
! 		 (const :tag "Passive" passive))
!   :group 'highlight-changes)
  
- (defcustom highlight-changes-global-initial-state 'passive
-   "*What state global Highlight Changes mode should start in.
- This is used if `global-highlight-changes' is called with no argument.
- This variable must be set to either `active' or `passive'."
-   :type '(choice (const :tag "Active" active)
- 		 (const :tag "Passive" passive))
-   :group 'highlight-changes)
  
! ;; The strings displayed in the mode-line for the minor mode:
! (defcustom highlight-changes-active-string " +Chg"
!   "*The string used when Highlight Changes mode is in the active state.
  This should be set to nil if no indication is desired, or to
  a string with a leading space."
    :type '(choice string
  		 (const :tag "None"  nil))
    :group 'highlight-changes)
  
! (defcustom highlight-changes-passive-string " -Chg"
!   "*The string used when Highlight Changes mode is in the passive state.
  This should be set to nil if no indication is desired, or to
  a string with a leading space."
    :type '(choice string
  		 (const :tag "None"  nil))
    :group 'highlight-changes)
  
  (defcustom highlight-changes-global-modes t
    "*Determine whether a buffer is suitable for global Highlight Changes mode.
  
--- 237,277 ----
    :group 'highlight-changes)
  
  (define-obsolete-variable-alias 'highlight-changes-colours
! 				'highlight-changes-colors "22.1")
  
+ (make-obsolete-variable 'highlight-changes-global-changes-existing-buffers
+ 			"global-highlight-changes-mode
+ affects all buffers now." "22.1")
  
! ;; highlight-changes-initial-state has been removed
! ;; highlight-changes-global-initial-state has been removed
  
  
! ;; These are the strings displayed in the mode-line for the minor mode:
! 
! (defcustom highlight-changes-visible-string " +Chg"
!   "*The string used when in Highlight Changes mode and changes are visible.
  This should be set to nil if no indication is desired, or to
  a string with a leading space."
    :type '(choice string
  		 (const :tag "None"  nil))
    :group 'highlight-changes)
  
! (define-obsolete-variable-alias 'highlight-changes-active-string
! 			'highlight-changes-visible-string "22.1")
! 
! (defcustom highlight-changes-invisible-string " -Chg"
!   "*The string used when in Highlight Changes mode and changes are hidden.
  This should be set to nil if no indication is desired, or to
  a string with a leading space."
    :type '(choice string
  		 (const :tag "None"  nil))
    :group 'highlight-changes)
  
+ (define-obsolete-variable-alias 'highlight-changes-passive-string
+ 			'highlight-changes-invisible-string "22.1")
+ 
+ 
  (defcustom highlight-changes-global-modes t
    "*Determine whether a buffer is suitable for global Highlight Changes mode.
  
***************
*** 306,316 ****
  A value of t means the buffer is suitable if it is visiting a file and
  its name does not begin with ` ' or `*'.
  
! A value of nil means no buffers are suitable for `global-highlight-changes'
  \(effectively disabling the mode).
  
  Example:
!         (c-mode c++-mode)
  means that Highlight Changes mode is turned on for buffers in C and C++
  modes only."
    :type '(choice
--- 285,295 ----
  A value of t means the buffer is suitable if it is visiting a file and
  its name does not begin with ` ' or `*'.
  
! A value of nil means no buffers are suitable for `global-highlight-changes-mode'
  \(effectively disabling the mode).
  
  Example:
! 	(c-mode c++-mode)
  means that Highlight Changes mode is turned on for buffers in C and C++
  modes only."
    :type '(choice
***************
*** 325,341 ****
  	  )
    :group 'highlight-changes)
  
- (defvar global-highlight-changes nil)
- 
- (defcustom highlight-changes-global-changes-existing-buffers nil
-   "*If non-nil, toggling global Highlight Changes mode affects existing buffers.
- Normally, `global-highlight-changes' affects only new buffers (to be
- created).  However, if `highlight-changes-global-changes-existing-buffers'
- is non-nil, then turning on `global-highlight-changes' will turn on
- Highlight Changes mode in suitable buffers, and turning the mode off will
- remove it from existing buffers."
-   :type 'boolean
-   :group 'highlight-changes)
  
  (defun hilit-chg-cust-fix-changes-face-list (w wc &optional event)
    ;; When customization function `highlight-changes-face-list' inserts a new
--- 304,309 ----
***************
*** 398,403 ****
--- 366,383 ----
  	  )
    :group 'highlight-changes)
  
+ (defvar highlight-changes-visible-p t
+   "*This controls the appearance of changes when Highlight Changes mode is on.
+ If non-nil, the changes are displayed using distinctive faces.
+ 
+ This variable is buffer-local when set.
+ 
+ Do not set this variable directly.  Instead,  use
+ \\[highlight-changes-toggle-visibility] to change this variable in a
+ buffer,  or use the Lisp function `setq-default' to change the default
+ value that is used for new buffers visited when Global Highlight Changes
+ mode is active.")
+ 
  ;; ========================================================================
  
  ;; These shouldn't be changed!
***************
*** 405,429 ****
  (defvar highlight-changes-mode nil)
  (defvar hilit-chg-list nil)
  (defvar hilit-chg-string " ??")
! (or (assq 'highlight-changes-mode minor-mode-alist)
!     (setq minor-mode-alist
! 	  (cons '(highlight-changes-mode hilit-chg-string) minor-mode-alist)
! 	  ))
  (make-variable-buffer-local 'highlight-changes-mode)
  (make-variable-buffer-local 'hilit-chg-string)
  
  
- (require 'ediff-init)
- (require 'ediff-util)
- 
  
  ;;; Functions...
  
! (defun hilit-chg-map-changes (func &optional start-position end-position)
!   "Call function FUNC for each region used by Highlight Changes mode."
!   ;; if start-position is nil, (point-min) is used
!   ;; if end-position is nil, (point-max) is used
!   ;; FUNC is called with 3 params: property start stop
    (let ((start (or start-position (point-min)))
  	(limit (or end-position (point-max)))
  	prop end)
--- 385,405 ----
  (defvar highlight-changes-mode nil)
  (defvar hilit-chg-list nil)
  (defvar hilit-chg-string " ??")
! 
! 
  (make-variable-buffer-local 'highlight-changes-mode)
+ (make-variable-buffer-local 'highlight-changes-visible-p)
  (make-variable-buffer-local 'hilit-chg-string)
  
  
  
  ;;; Functions...
  
! (defun hilit-chg-map-changes  (func &optional start-position end-position)
!   "Call function FUNC for each region used by Highlight Changes mode.
! If START-POSITION is nil, (point-min) is used.
! If END-POSITION is nil, (point-max) is used.
! FUNC is called with 3 params: PROPERTY START STOP."
    (let ((start (or start-position (point-min)))
  	(limit (or end-position (point-max)))
  	prop end)
***************
*** 438,445 ****
  (defun hilit-chg-display-changes (&optional beg end)
    "Display face information for Highlight Changes mode.
  
! An overlay containing a change face is added from the information
! in the text property of type `hilit-chg'.
  
  This is the opposite of `hilit-chg-hide-changes'."
    (hilit-chg-map-changes 'hilit-chg-make-ov beg end))
--- 414,421 ----
  (defun hilit-chg-display-changes (&optional beg end)
    "Display face information for Highlight Changes mode.
  
! An overlay from BEG to END containing a change face is added from the
! information in the text property of type `hilit-chg'.
  
  This is the opposite of `hilit-chg-hide-changes'."
    (hilit-chg-map-changes 'hilit-chg-make-ov beg end))
***************
*** 448,455 ****
  (defun hilit-chg-make-ov (prop start end)
    (or prop
        (error "hilit-chg-make-ov: prop is nil"))
!   ;; for the region make change overlays corresponding to
!   ;; the text property 'hilit-chg
    (let ((ov (make-overlay start end))
  	face)
      (if (eq prop 'hilit-chg-delete)
--- 424,431 ----
  (defun hilit-chg-make-ov (prop start end)
    (or prop
        (error "hilit-chg-make-ov: prop is nil"))
!   ;; For the region create overlays with a distincive face
!   ;; and the text property 'hilit-chg.
    (let ((ov (make-overlay start end))
  	face)
      (if (eq prop 'hilit-chg-delete)
***************
*** 457,463 ****
        (setq face (nth 1 (member prop hilit-chg-list))))
      (if face
  	(progn
! 	  ;; We must mark the face, that is the purpose of the overlay
  	  (overlay-put ov 'face face)
  	  ;; I don't think we need to set evaporate since we should
  	  ;; be controlling them!
--- 433,439 ----
        (setq face (nth 1 (member prop hilit-chg-list))))
      (if face
  	(progn
! 	  ;; We must mark the face, that is the purpose of the overlay.
  	  (overlay-put ov 'face face)
  	  ;; I don't think we need to set evaporate since we should
  	  ;; be controlling them!
***************
*** 476,489 ****
  
  This is the opposite of `hilit-chg-display-changes'."
    (let ((start (or beg (point-min)))
! 	(limit (or end (point-max)))
! 	p ov)
!     (setq p (overlays-in start limit))
!     (while p
        ;; don't delete the overlay if it isn't ours!
!       (if (overlay-get (car p) 'hilit-chg)
! 	  (delete-overlay (car p)))
!       (setq p (cdr p)))))
  
  (defun hilit-chg-fixup (beg end)
    "Fix change overlays in region between BEG and END.
--- 452,463 ----
  
  This is the opposite of `hilit-chg-display-changes'."
    (let ((start (or beg (point-min)))
! 	(limit (or end (point-max))))
!     (dolist (p (overlays-in start limit))
        ;; don't delete the overlay if it isn't ours!
!       (if (overlay-get p 'hilit-chg)
! 	  (delete-overlay p)))))
! 
  
  (defun hilit-chg-fixup (beg end)
    "Fix change overlays in region between BEG and END.
***************
*** 492,500 ****
  the text properties of type `hilit-chg'."
    ;; Remove or alter overlays in region beg..end
    (let (ov-start ov-end	 props q)
-     ;; temp for debugging:
-     ;; (or (eq highlight-changes-mode 'active)
-     ;;	 (error "hilit-chg-fixup called but Highlight Changes mode not active"))
      (dolist (ov (overlays-in beg end))
        ;; Don't alter overlays that are not ours.
        (when (overlay-get ov 'hilit-chg)
--- 466,471 ----
***************
*** 541,547 ****
  	  (type 'hilit-chg)
  	  old)
        (if undo-in-progress
! 	  (if (eq highlight-changes-mode 'active)
  	      (hilit-chg-fixup beg end))
  	(if (and (= beg end) (> leng-before 0))
  	    ;; deletion
--- 512,519 ----
  	  (type 'hilit-chg)
  	  old)
        (if undo-in-progress
! 	  (if (and highlight-changes-mode
! 		   highlight-changes-visible-p)
  	      (hilit-chg-fixup beg end))
  	(if (and (= beg end) (> leng-before 0))
  	    ;; deletion
***************
*** 569,686 ****
  	      (progn
  		(remove-text-properties end (+ end 1) '(hilit-chg nil))
  		(put-text-property end (+ end 1) 'hilit-chg 'hilit-chg)
! 		(if (eq highlight-changes-mode 'active)
  		    (hilit-chg-fixup beg (+ end 1))))))
  	(unless no-property-change
  		(put-text-property beg end 'hilit-chg type))
! 	(if (or (eq highlight-changes-mode 'active) no-property-change)
  	    (hilit-chg-make-ov type beg end))))))
  
! (defun hilit-chg-set (value)
    "Turn on Highlight Changes mode for this buffer."
-   (setq highlight-changes-mode value)
    (remove-hook 'after-change-functions 'hilit-chg-set-face-on-change t)
    (hilit-chg-make-list)
!   (if (eq highlight-changes-mode 'active)
        (progn
! 	(setq hilit-chg-string highlight-changes-active-string)
  	(or buffer-read-only
  	    (hilit-chg-display-changes)))
!     ;; mode is passive
!     (setq hilit-chg-string highlight-changes-passive-string)
      (or buffer-read-only
  	(hilit-chg-hide-changes)))
    (force-mode-line-update)
!   (add-hook 'after-change-functions 'hilit-chg-set-face-on-change nil t))
  
  (defun hilit-chg-clear ()
    "Remove Highlight Changes mode for this buffer.
  This removes all saved change information."
    (if buffer-read-only
        ;; We print the buffer name because this function could be called
!       ;; on many buffers from `global-highlight-changes'.
        (message "Cannot remove highlighting from read-only mode buffer %s"
  	       (buffer-name))
-     (remove-hook 'after-change-functions 'hilit-chg-set-face-on-change t)
      (let ((after-change-functions nil))
        (hilit-chg-hide-changes)
        (hilit-chg-map-changes
         '(lambda (prop start stop)
  	  (remove-text-properties start stop '(hilit-chg nil))))
!       )
!     (setq highlight-changes-mode nil)
!     (force-mode-line-update)
!     ;; If we type:  C-u -1 M-x highlight-changes-mode
!     ;; we want to turn it off, but hilit-chg-post-command-hook
!     ;; runs and that turns it back on!
!     (remove-hook 'post-command-hook 'hilit-chg-post-command-hook)))
  
  ;;;###autoload
! (defun highlight-changes-mode (&optional arg)
!   "Toggle (or initially set) Highlight Changes mode.
  
! Without an argument:
!   If Highlight Changes mode is not enabled, then enable it (in either active
!   or passive state as determined by the variable
!   `highlight-changes-initial-state'); otherwise, toggle between active
!   and passive state.
! 
! With an argument ARG:
!   If ARG is positive, set state to active;
!   If ARG is zero, set state to passive;
!   If ARG is negative, disable Highlight Changes mode completely.
! 
! Active state  - means changes are shown in a distinctive face.
! Passive state - means changes are kept and new ones recorded but are
! 		not displayed in a different face.
  
! Functions:
  \\[highlight-changes-next-change] - move point to beginning of next change
  \\[highlight-changes-previous-change] - move to beginning of previous change
- \\[highlight-compare-with-file] - mark text as changed by comparing this
- 	buffer with the contents of a file
  \\[highlight-changes-remove-highlight] - remove the change face from the region
! \\[highlight-changes-rotate-faces] - rotate different \"ages\" of changes \
! through
! 	various faces
  
  Hook variables:
! `highlight-changes-enable-hook'  - when enabling Highlight Changes mode
! `highlight-changes-toggle-hook'  - when entering active or passive state
! `highlight-changes-disable-hook' - when turning off Highlight Changes mode"
!   (interactive "P")
    (if (or (display-color-p)
  	  (and (fboundp 'x-display-grayscale-p) (x-display-grayscale-p)))
!       (let ((was-on highlight-changes-mode)
! 	    (new-highlight-changes-mode
! 	     (cond
! 	      ((null arg)
! 	       ;; no arg => toggle (or set to active initially)
! 	       (if highlight-changes-mode
! 		   (if (eq highlight-changes-mode 'active) 'passive 'active)
! 		 highlight-changes-initial-state))
! 	      ;; an argument is given
! 	      ((eq arg 'active)
! 	       'active)
! 	      ((eq arg 'passive)
! 	       'passive)
! 	      ((> (prefix-numeric-value arg) 0)
! 	       'active)
! 	      ((< (prefix-numeric-value arg) 0)
! 	       nil)
! 	      (t
! 	       'passive))))
! 	(if new-highlight-changes-mode
! 	    ;; mode is turned on -- but may be passive
! 	    (progn
! 	      (hilit-chg-set new-highlight-changes-mode)
! 	      (or was-on
! 		  ;; run highlight-changes-enable-hook once
! 		  (run-hooks 'highlight-changes-enable-hook))
! 	      (run-hooks 'highlight-changes-toggle-hook))
! 	  ;; mode is turned off
! 	  (run-hooks 'highlight-changes-disable-hook)
! 	  (hilit-chg-clear)))
      (message "Highlight Changes mode requires color or grayscale display")))
  
  ;;;###autoload
--- 541,628 ----
  	      (progn
  		(remove-text-properties end (+ end 1) '(hilit-chg nil))
  		(put-text-property end (+ end 1) 'hilit-chg 'hilit-chg)
! 		(if highlight-changes-visible-p
  		    (hilit-chg-fixup beg (+ end 1))))))
  	(unless no-property-change
  		(put-text-property beg end 'hilit-chg type))
! 	(if (or highlight-changes-visible-p no-property-change)
  	    (hilit-chg-make-ov type beg end))))))
  
! (defun hilit-chg-set ()
    "Turn on Highlight Changes mode for this buffer."
    (remove-hook 'after-change-functions 'hilit-chg-set-face-on-change t)
    (hilit-chg-make-list)
!   (setq highlight-changes-mode t)
!   (if highlight-changes-visible-p
!       ;; changes are visible
        (progn
! 	(setq hilit-chg-string highlight-changes-visible-string)
  	(or buffer-read-only
  	    (hilit-chg-display-changes)))
!     ;; changes are invisible
!     (setq hilit-chg-string highlight-changes-invisible-string)
      (or buffer-read-only
  	(hilit-chg-hide-changes)))
    (force-mode-line-update)
!   ;; (make-local-hook 'after-change-functions)
!   (add-hook 'after-change-functions 'hilit-chg-set-face-on-change nil t)
!   (run-hooks 'highlight-changes-enable-hook))
  
  (defun hilit-chg-clear ()
    "Remove Highlight Changes mode for this buffer.
  This removes all saved change information."
    (if buffer-read-only
        ;; We print the buffer name because this function could be called
!       ;; on many buffers from `global-highlight-changes-mode'.
        (message "Cannot remove highlighting from read-only mode buffer %s"
  	       (buffer-name))
      (let ((after-change-functions nil))
        (hilit-chg-hide-changes)
        (hilit-chg-map-changes
         '(lambda (prop start stop)
  	  (remove-text-properties start stop '(hilit-chg nil))))
!       ))
!   (remove-hook 'after-change-functions 'hilit-chg-set-face-on-change t)
!   (setq highlight-changes-mode nil)
!   (force-mode-line-update)
!   (run-hooks 'highlight-changes-disable-hook))
  
  ;;;###autoload
! (define-minor-mode highlight-changes-mode
!   "Toggle Highlight Changes mode.
! 
! With ARG, turn Highlight Changes mode on if and only if arg is positive.
  
! In Highlight Changes mode changes are recorded with a text property.
! Normally they are displayed in a distinctive face, but command
! \\[highlight-changes-toggle-visibility] can be used to toggles this
! on and off.
  
! Other functions for buffers in this mode include:
  \\[highlight-changes-next-change] - move point to beginning of next change
  \\[highlight-changes-previous-change] - move to beginning of previous change
  \\[highlight-changes-remove-highlight] - remove the change face from the region
! \\[highlight-changes-rotate-faces] - rotate different \"ages\" of changes
! through	various faces.
! \\[highlight-compare-with-file] - mark text as changed by comparing this
! buffer with the contents of a file
! \\[highlight-compare-buffers] highlights differences between two buffers.
  
  Hook variables:
! `highlight-changes-enable-hook': called when enabling Highlight Changes mode.
! `highlight-changes-disable-hook': called when disabling Highlight Changes mode."
!   nil			;; init-value
!   hilit-chg-string	;; lighter
!   nil			;; keymap
    (if (or (display-color-p)
  	  (and (fboundp 'x-display-grayscale-p) (x-display-grayscale-p)))
!       (if highlight-changes-mode
! 	  ;; it is being turned on
! 	  ;; the hook has been moved into hilit-chg-set
! 	  ;; (run-hooks 'highlight-changes-enable-hook))
! 	  (hilit-chg-set)
! 	;; mode is turned off
! 	(hilit-chg-clear))
      (message "Highlight Changes mode requires color or grayscale display")))
  
  ;;;###autoload
***************
*** 725,730 ****
--- 667,698 ----
  	  (message "no previous change")))
      (message "This buffer is not in Highlight Changes mode.")))
  
+ 
+ ;;;###autoload
+ (defun highlight-changes-toggle-visibility (&optional arg)
+   "Toggle whether changes are visible in Highlight Changes modes.
+ While the changes are still kept (and new ones recorded) as long as
+ Highlight Changes modes is on, their distinctive display can be
+ toggled on and off using this command.  With ARG,  enable the
+ distinctive display if and only if the arg is positive.
+ 
+ Set variable `highlight-changes-visible-p' if you want to change the default
+ behaviour.
+ 
+ This command turns on highlight-changes mode."
+   (interactive "P")
+   (let ((old-value highlight-changes-visible-p))
+     (setq highlight-changes-visible-p
+ 	  (if (null arg)
+ 	      (not highlight-changes-visible-p)
+ 	    (> (prefix-numeric-value arg) 0)))
+     (unless (eq old-value highlight-changes-visible-p)
+       (message "changes will now be %s"
+ 	       (if highlight-changes-visible-p "visible" "invisible"))
+       (hilit-chg-set))
+     ))
+ 
+ 
  ;; ========================================================================
  
  (defun hilit-chg-make-list (&optional force)
***************
*** 775,781 ****
  
  ;;;###autoload
  (defun highlight-changes-rotate-faces ()
!   "Rotate the faces used by Highlight Changes mode.
  
  Current changes are displayed in the face described by the first element
  of `highlight-changes-face-list', one level older changes are shown in
--- 743,749 ----
  
  ;;;###autoload
  (defun highlight-changes-rotate-faces ()
!   "Rotate the faces if in Highlight Changes mode and the changes are visible.
  
  Current changes are displayed in the face described by the first element
  of `highlight-changes-face-list', one level older changes are shown in
***************
*** 788,796 ****
  
    \(add-hook 'write-file-functions 'highlight-changes-rotate-faces nil t)"
    (interactive)
!   ;; If not in active mode do nothing but don't complain because this
!   ;; may be bound to a hook.
!   (if (eq highlight-changes-mode 'active)
        (let ((after-change-functions nil))
  	;; ensure hilit-chg-list is made and up to date
  	(hilit-chg-make-list)
--- 756,763 ----
  
    \(add-hook 'write-file-functions 'highlight-changes-rotate-faces nil t)"
    (interactive)
!   (if (and highlight-changes-mode
! 	   highlight-changes-visible-p)
        (let ((after-change-functions nil))
  	;; ensure hilit-chg-list is made and up to date
  	(hilit-chg-make-list)
***************
*** 798,808 ****
  	(hilit-chg-hide-changes)
  	;; for each change text property, increment it
  	(hilit-chg-map-changes 'hilit-chg-bump-change)
! 	;; and display them all if active
! 	(if (eq highlight-changes-mode 'active)
! 	    (hilit-chg-display-changes))))
!   ;; This always returns nil so it is safe to use in write-file-functions
!   nil)
  
  ;; ========================================================================
  ;; Comparing buffers/files
--- 765,775 ----
  	(hilit-chg-hide-changes)
  	;; for each change text property, increment it
  	(hilit-chg-map-changes 'hilit-chg-bump-change)
! 	;; and display them.
! 	(hilit-chg-display-changes)
! 	))
!    ;; This always returns nil so it is safe to use in write-file-functions
!    nil)
  
  ;; ========================================================================
  ;; Comparing buffers/files
***************
*** 813,818 ****
--- 780,787 ----
    "Get differences between two buffers and set highlight changes.
  Both buffers are done unless optional parameter MARKUP-A-ONLY
  is non-nil."
+   (eval-and-compile
+     (require 'ediff-util))
    (save-window-excursion
      (let* (change-info
  	   change-a change-b
***************
*** 841,849 ****
        (or file-b
  	  (setq temp-b (setq file-b (ediff-make-temp-file buf-b nil))))
        (set-buffer buf-a)
!       (highlight-changes-mode 'active)
        (or markup-a-only (with-current-buffer buf-b
! 			  (highlight-changes-mode 'active)))
        (setq change-info (hilit-chg-get-diff-info buf-a file-a buf-b file-b))
  
  
--- 810,818 ----
        (or file-b
  	  (setq temp-b (setq file-b (ediff-make-temp-file buf-b nil))))
        (set-buffer buf-a)
!       (highlight-changes-mode 1)
        (or markup-a-only (with-current-buffer buf-b
! 			  (highlight-changes-mode 1)))
        (setq change-info (hilit-chg-get-diff-info buf-a file-a buf-b file-b))
  
  
***************
*** 917,936 ****
  If the buffer is read-only, differences will be highlighted but no property
  changes are made, so \\[highlight-changes-next-change] and
  \\[highlight-changes-previous-change] will not work."
!   (interactive (list
! 	      (read-file-name
! 	       "File to compare with? " ;; prompt
! 	       ""			;; directory
! 	       nil			;; default
! 	       'yes			;; must exist
! 	       (let ((f (buffer-file-name (current-buffer))))
! 		 (if f
! 		     (progn
! 		       (setq f (make-backup-file-name f))
! 		       (or (file-exists-p f)
! 			   (setq f nil)))
! 		   )
! 		 f))))
    (let* ((buf-a (current-buffer))
  	 (file-a (buffer-file-name))
  	 (existing-buf (get-file-buffer file-b))
--- 886,908 ----
  If the buffer is read-only, differences will be highlighted but no property
  changes are made, so \\[highlight-changes-next-change] and
  \\[highlight-changes-previous-change] will not work."
!   (interactive
!    (let ((file buffer-file-name)
! 	 (file-name nil)
! 	 (file-dir nil))
!      (and file
! 	  (setq file-name (file-name-nondirectory file)
! 		file-dir (file-name-directory file)))
!      (setq file-name (make-backup-file-name file-name))
!      (unless (file-exists-p file-name)
! 	     (setq file-name nil))
!      (list (read-file-name
! 	    "Find alternate file: "	;; prompt
! 	    file-dir			;; directory
! 	    nil				;; default
! 	    nil				;; existing
! 	    file-name)			;; initial
! 	   )))
    (let* ((buf-a (current-buffer))
  	 (file-a (buffer-file-name))
  	 (existing-buf (get-file-buffer file-b))
***************
*** 998,1122 ****
      ;; No point in returning a value, since this is a hook function.
      ))
  
! ;; ======================= automatic stuff ==============
! 
! ;; Global Highlight Changes mode is modeled after Global Font-lock mode.
! ;; Three hooks are used to gain control.  When Global Changes Mode is
! ;; enabled, `find-file-hook' and `change-major-mode-hook' are set.
! ;; `find-file-hook' is called when visiting a file, the new mode is
! ;; known at this time.
! ;; `change-major-mode-hook' is called when a buffer is changing mode.
! ;; This could be because of finding a file in which case
! ;; `find-file-hook' has already been called and has done its work.
! ;; However, it also catches the case where a new mode is being set by
! ;; the user.  However, it is called from `kill-all-variables' and at
! ;; this time the mode is the old mode, which is not what we want.
! ;; So, our function temporarily sets `post-command-hook' which will
! ;; be called after the buffer has been completely set up (with the new
! ;; mode).  It then removes the `post-command-hook'.
! ;; One other wrinkle - every M-x command runs the `change-major-mode-hook'
! ;; so we ignore this by examining the buffer name.
! 
! 
! (defun hilit-chg-major-mode-hook ()
!   (add-hook 'post-command-hook 'hilit-chg-post-command-hook))
! 
! (defun hilit-chg-post-command-hook ()
!   ;; This is called after changing a major mode, but also after each
!   ;; M-x command, in which case the current buffer is a minibuffer.
!   ;; In that case, do not act on it here, but don't turn it off
!   ;; either, we will get called here again soon-after.
!   ;; Also, don't enable it for other special buffers.
!   (if (string-match "^[ *]"  (buffer-name))
!       nil ;; (message "ignoring this post-command-hook")
!     (remove-hook 'post-command-hook 'hilit-chg-post-command-hook)
!     ;; The following check isn't necessary, since
!     ;; hilit-chg-turn-on-maybe makes this check too.
!     (or highlight-changes-mode	;; don't turn it on if it already is
! 	(hilit-chg-turn-on-maybe highlight-changes-global-initial-state))))
! 
! (defun hilit-chg-check-global ()
!   ;; This is called from the find file hook.
!   (hilit-chg-turn-on-maybe highlight-changes-global-initial-state))
! 
  
  ;;;###autoload
! (defun global-highlight-changes (&optional arg)
!   "Turn on or off global Highlight Changes mode.
! 
! When called interactively:
! - if no prefix, toggle global Highlight Changes mode on or off
! - if called with a positive prefix (or just C-u) turn it on in active mode
! - if called with a zero prefix turn it on in passive mode
! - if called with a negative prefix turn it off
! 
! When called from a program:
! - if ARG is nil or omitted, turn it off
! - if ARG is `active', turn it on in active mode
! - if ARG is `passive', turn it on in passive mode
! - otherwise just turn it on
! 
! When global Highlight Changes mode is enabled, Highlight Changes mode is turned
! on for future \"suitable\" buffers (and for \"suitable\" existing buffers if
! variable `highlight-changes-global-changes-existing-buffers' is non-nil).
! \"Suitability\" is determined by variable `highlight-changes-global-modes'."
! 
!   (interactive
!    (list
!     (cond
!      ((null current-prefix-arg)
!       ;; no arg => toggle it on/off
!       (setq global-highlight-changes (not global-highlight-changes)))
!      ;; positive interactive arg - turn it on as active
!      ((> (prefix-numeric-value current-prefix-arg) 0)
!       (setq global-highlight-changes t)
!       'active)
!      ;; zero interactive arg - turn it on as passive
!      ((= (prefix-numeric-value current-prefix-arg) 0)
!       (setq global-highlight-changes t)
!       'passive)
!      ;; negative interactive arg - turn it off
!      (t
!       (setq global-highlight-changes nil)
!       nil))))
  
!   (if arg
!       (progn
! 	(if (eq arg 'active)
! 	    (setq highlight-changes-global-initial-state 'active)
! 	  (if (eq arg 'passive)
! 	      (setq highlight-changes-global-initial-state 'passive)))
! 	(setq global-highlight-changes t)
! 	(message "Turning ON Global Highlight Changes mode in %s state"
! 		 highlight-changes-global-initial-state)
! 	;; FIXME: Not sure what this was intended to do.  --Stef
! 	;; (add-hook 'hilit-chg-major-mode-hook 'hilit-chg-major-mode-hook)
! 	(add-hook 'find-file-hook 'hilit-chg-check-global)
! 	(if highlight-changes-global-changes-existing-buffers
! 	    (hilit-chg-update-all-buffers
! 	     highlight-changes-global-initial-state)))
! 
!     (message "Turning OFF global Highlight Changes mode")
!     ;; FIXME: Not sure what this was intended to do.  --Stef
!     ;; (remove-hook 'hilit-chg-major-mode-hook 'hilit-chg-major-mode-hook)
!     (remove-hook 'post-command-hook 'hilit-chg-post-command-hook)
!     (remove-hook 'find-file-hook 'hilit-chg-check-global)
!     (if highlight-changes-global-changes-existing-buffers
! 	(hilit-chg-update-all-buffers nil))))
! 
! 
! (defun hilit-chg-turn-on-maybe (value)
!   "Turn on Highlight Changes mode if it is appropriate for this buffer.
! 
! A buffer is appropriate for Highlight Changes mode if all these are true:
! - the buffer is not a special buffer (one whose name begins with
!   `*' or ` '),
! - the buffer's mode is suitable as per variable
!   `highlight-changes-global-modes',
! - Highlight Changes mode is not already on for this buffer.
  
! This function is called from `hilit-chg-update-all-buffers' or
! from `global-highlight-changes' when turning on global Highlight Changes mode."
    (or highlight-changes-mode			; do nothing if already on
        (if
  	  (cond
--- 970,987 ----
      ;; No point in returning a value, since this is a hook function.
      ))
  
! ;; ======================= global-highlight-changes-mode ==============
  
  ;;;###autoload
! (define-global-minor-mode global-highlight-changes-mode highlight-changes-mode
!   highlight-changes-mode-turn-on)
  
! (define-obsolete-function-alias 'global-highlight-changes
!   'global-highlight-changes-mode "22.1")
  
! (defun highlight-changes-mode-turn-on ()
!   "See if highlight-changes-mode should be turned on for this buffer.
! This is called when global-highlight-changes-mode is turned on."
    (or highlight-changes-mode			; do nothing if already on
        (if
  	  (cond
***************
*** 1132,1159 ****
  	     (and
  	      (not (string-match "^[ *]" (buffer-name)))
  	      (buffer-file-name))))
! 	  (progn
! 	    (hilit-chg-set value)
! 	    (run-hooks 'highlight-changes-enable-hook)))))
! 
! 
! (defun hilit-chg-turn-off-maybe ()
!   (if highlight-changes-mode
!       (progn
! 	(run-hooks 'highlight-changes-disable-hook)
! 	(hilit-chg-clear))))
! 
  
- (defun hilit-chg-update-all-buffers (value)
-   (mapc
-    (function (lambda (buffer)
- 	       (with-current-buffer buffer
- 		 (if value
- 		     (hilit-chg-turn-on-maybe value)
- 		   (hilit-chg-turn-off-maybe))
- 		 )))
-    (buffer-list))
-   nil)
  
  ;;;; Desktop support.
  
--- 997,1005 ----
  	     (and
  	      (not (string-match "^[ *]" (buffer-name)))
  	      (buffer-file-name))))
! 	  (highlight-changes-mode 1))
! 	))
  
  
  ;;;; Desktop support.
  
***************
*** 1163,1169 ****
     (or (cdr (assq 'highlight-changes-mode desktop-buffer-locals)) 1)))
  
  (add-to-list 'desktop-minor-mode-handlers
!              '(highlight-changes-mode . hilit-chg-desktop-restore))
  
  (add-to-list 'desktop-locals-to-save 'highlight-changes-mode)
  
--- 1009,1015 ----
     (or (cdr (assq 'highlight-changes-mode desktop-buffer-locals)) 1)))
  
  (add-to-list 'desktop-minor-mode-handlers
! 	     '(highlight-changes-mode . hilit-chg-desktop-restore))
  
  (add-to-list 'desktop-locals-to-save 'highlight-changes-mode)
  
***************
*** 1174,1183 ****
  ;;   (interactive)
  ;;   (message "--- hilit-chg-debug-show ---")
  ;;   (hilit-chg-map-changes '(lambda (prop start end)
! ;; 			      (message "%d-%d: %s" start end prop)
! ;; 			      )
! ;; 			   beg end
! ;; 			   ))
  ;;
  ;; ================== end of debug ===============
  
--- 1020,1029 ----
  ;;   (interactive)
  ;;   (message "--- hilit-chg-debug-show ---")
  ;;   (hilit-chg-map-changes '(lambda (prop start end)
! ;;			      (message "%d-%d: %s" start end prop)
! ;;			      )
! ;;			   beg end
! ;;			   ))
  ;;
  ;; ================== end of debug ===============
  

^ permalink raw reply	[flat|nested] 10+ messages in thread
end of thread, other threads:[~2008-05-02  8:53 UTC | newest]

Thread overview: 10+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2008-03-16 17:52 patch to hilight-chg not in emacs 22.1 Richard Sharman
2008-03-17 14:11 ` Stefan Monnier
2008-03-18  3:11   ` Richard Sharman
2008-03-18 16:51     ` Stefan Monnier
2008-03-19  2:43       ` Richard Sharman
2008-03-19 16:20         ` Stefan Monnier
2008-04-25 14:27           ` Juanma Barranquero
2008-05-02  3:21             ` Richard Sharman
2008-05-02  8:53               ` Juanma Barranquero
2008-03-18  9:55 ` martin rudalics

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/emacs.git
	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.