From 2a918c495538ef8c395b33601e1b23517fdfb3bb Mon Sep 17 00:00:00 2001 From: Vasilij Schneidermann Date: Tue, 19 Sep 2017 07:45:58 +0200 Subject: Update bundled libraries to latest stable version --- lib/goto-chg.el | 271 +++++++++++++++++++++++++++++++------------------------ lib/undo-tree.el | 141 +++++++++++++++++++++++++---- 2 files changed, 276 insertions(+), 136 deletions(-) diff --git a/lib/goto-chg.el b/lib/goto-chg.el index 3881706..7877404 100644 --- a/lib/goto-chg.el +++ b/lib/goto-chg.el @@ -1,7 +1,7 @@ ;;; goto-chg.el --- goto last change ;;-------------------------------------------------------------------- ;; -;; Copyright (C) 2002-2008, David Andersson +;; Copyright (C) 2002-2008,2013 David Andersson ;; ;; This program is free software; you can redistribute it and/or ;; modify it under the terms of the GNU General Public License as @@ -21,8 +21,10 @@ ;;------------------------------------------------------------------- ;; ;; Author: David Andersson +;; Maintainer: Vasilij Schneidermann ;; Created: 16 May 2002 -;; Version: 1.4 +;; Version: 1.7 +;; Keywords: convenience, matching ;; ;;; Commentary: ;; @@ -41,12 +43,19 @@ ;; (global-set-key [(control ?.)] 'goto-last-change) ;; (global-set-key [(control ?,)] 'goto-last-change-reverse) ;; -;; Works with emacs-19.29, 19.31, 20.3, 20.7, 21.1, 21.4 and 22.1. +;; Works with emacs-19.29, 19.31, 20.3, 20.7, 21.1, 21.4, 22.1 and 23.1 ;; Works with XEmacs-20.4 and 21.4 (but see todo about `last-command' below) ;; ;;-------------------------------------------------------------------- ;; History ;; +;; Ver 1.7 2017-09-17 Vasilij Schneidermann +;; Make it work with undo-tree-mode (see +;; ) +;; Ver 1.6 2013-12-12 David Andersson +;; Add keywords; Cleanup comments +;; Ver 1.5 2013-12-11 David Andersson +;; Autoload and document `goto-last-change-reverse' ;; Ver 1.4 2008-09-20 David Andersson ;; Improved property change description; Update comments. ;; Ver 1.3 2007-03-14 David Andersson @@ -64,15 +73,12 @@ ;;todo: Rename "goto-chg.el" -> "gotochange.el" or "goto-chgs" ? ;;todo: Rename function goto-last-change -> goto-last-edit ? ;;todo: Rename adjective "-last-" -> "-latest-" or "-most-recent-" ? -;;todo: There are some, maybe useful, funcs for region undo +;;todo: There are some, maybe useful, funcs for region undo ;; in simple.el in emacs 20. Take a look. ;;todo: Add functionality to visit changed point in text order, not only in ;; chronological order. (Naa, highlight-changes-mode does that). ;;todo: Inverse indication that a change has been saved or not ;;todo: Highlight the range of text involved in the last change? -;;todo: Function that goes in reverse direction. Either a function -;; 'goto-next-change' only callable after 'goto-last-change' -;; or enter a minor mode similar to isearch. ;;todo: See session-jump-to-last-change in session.el? ;;todo: Unhide invisible text (e.g. outline mode) like isearch do. ;;todo: XEmacs sets last-command to `t' after an error, so you cannot reverse @@ -98,21 +104,24 @@ Optional third argument is the replacement, which defaults to \"...\"." str ;; else (let* ((lipsis (or ellipsis "...")) - (i (/ (- maxlen (length lipsis)) 2))) + (i (/ (- maxlen (length lipsis)) 2))) (concat (substring str 0 i) - lipsis - (substring str (- i)))))) + lipsis + (substring str (- i)))))) (defun glc-adjust-pos2 (pos p1 p2 adj) ;; Helper function to glc-adjust-pos + ;; p1, p2: interval where an edit occured + ;; adj: amount of text added (positive) or removed (negativ) by the edit + ;; Return pos if well before p1, or pos+adj if well after p2, or nil if too close (cond ((<= pos (- p1 glc-current-span)) - pos) - ((> pos (+ p2 glc-current-span)) - (+ pos adj)) - ((zerop glc-current-span) - p1) - (t - nil))) + pos) + ((> pos (+ p2 glc-current-span)) + (+ pos adj)) + ((zerop glc-current-span) + p1) + (t + nil))) (defun glc-adjust-pos (pos e) "Given POS, a buffer position before the edit E, compute and return @@ -121,25 +130,16 @@ Exception: return nil if POS is closer than `glc-current-span' to the edit E. \nInsertion edits before POS returns a larger value. Deletion edits before POS returns a smaller value. \nThe edit E is an entry from the `buffer-undo-list'. See for details." - (cond ((atom e) ; nil==cmd boundary, or, num==changed pos - pos) - ((numberp (car e)) ; (beg . end)==insertion - (glc-adjust-pos2 pos (car e) (car e) (- (cdr e) (car e)))) -;; (cond ((< pos (- (car e) glc-current-span)) pos) -;; ((> pos (+ (car e) glc-current-span)) (+ pos (- (cdr e) (car e)))) -;; (t nil))) - ((stringp (car e)) ; (string . pos)==deletion - (glc-adjust-pos2 pos (abs (cdr e)) (+ (abs (cdr e)) (length (car e))) (- (length (car e))))) -;; (cond ((< pos (- (abs (cdr e)) glc-current-span)) pos) -;; ((> pos (+ (abs (cdr e)) (length (car e)) glc-current-span)) (- pos (length (car e)))) -;; (t nil))) - ((null (car e)) ; (nil prop val beg . end)==prop change - (glc-adjust-pos2 pos (nth 3 e) (nthcdr 4 e) 0)) -;; (cond ((< pos (- (nth 3 e) glc-current-span)) pos) -;; ((> pos (+ (nthcdr 4 e) glc-current-span)) pos) -;; (t nil))) - (t ; (marker . dist)==marker moved - pos))) + (cond ((atom e) ; nil==cmd boundary, or, num==changed pos + pos) + ((numberp (car e)) ; (beg . end)==insertion + (glc-adjust-pos2 pos (car e) (car e) (- (cdr e) (car e)))) + ((stringp (car e)) ; (string . pos)==deletion + (glc-adjust-pos2 pos (abs (cdr e)) (+ (abs (cdr e)) (length (car e))) (- (length (car e))))) + ((null (car e)) ; (nil prop val beg . end)==prop change + (glc-adjust-pos2 pos (nth 3 e) (nthcdr 4 e) 0)) + (t ; (marker . dist)==marker moved + pos))) ;; If recursive in stead of iterative (while), it tends to fill the call stack. ;; (Isn't it tail optimized?) @@ -152,52 +152,52 @@ or nil if the point was closer than `glc-current-span' to some edit in R. (if r ;; Get pos (let ((pos (glc-get-pos (car r)))) - (setq r (cdr r)) - ;; Walk back in reverse list - (while (and r pos) - (setq pos (glc-adjust-pos pos (car r)) - r (cdr r))) - pos) + (setq r (cdr r)) + ;; Walk back in reverse list + (while (and r pos) + (setq pos (glc-adjust-pos pos (car r)) + r (cdr r))) + pos) ;; else nil)) (defun glc-get-pos (e) "If E represents an edit, return a position value in E, the position where the edit took place. Return nil if E represents no real change. -\nE is a entry in the buffer-undo-list." - (cond ((numberp e) e) ; num==changed position - ((atom e) nil) ; nil==command boundary - ((numberp (car e)) (cdr e)) ; (beg . end)==insertion - ((stringp (car e)) (abs (cdr e))) ; (string . pos)==deletion - ((null (car e)) (nthcdr 4 e)) ; (nil ...)==text property change - ((atom (car e)) nil) ; (t ...)==file modification time - (t nil))) ; (marker ...)==marker moved +\nE is an entry in the buffer-undo-list." + (cond ((numberp e) e) ; num==changed position + ((atom e) nil) ; nil==command boundary + ((numberp (car e)) (cdr e)) ; (beg . end)==insertion + ((stringp (car e)) (abs (cdr e))) ; (string . pos)==deletion + ((null (car e)) (nthcdr 4 e)) ; (nil ...)==text property change + ((atom (car e)) nil) ; (t ...)==file modification time + (t nil))) ; (marker ...)==marker moved (defun glc-get-descript (e &optional n) "If E represents an edit, return a short string describing E. Return nil if E represents no real change. -\nE is a entry in the buffer-undo-list." +\nE is an entry in the buffer-undo-list." (let ((nn (or (format "T-%d: " n) ""))) - (cond ((numberp e) "New position") ; num==changed position - ((atom e) nil) ; nil==command boundary - ((numberp (car e)) ; (beg . end)==insertion - (if (and n (< n 2)) - (format "%sInserted %d chars \"%s\"" nn (- (cdr e) (car e)) - (glc-center-ellipsis (buffer-substring (car e) (cdr e)) 60)) - ;; else - ;; An older insert. The inserted text cannot easily be computed. - ;; Just show the char count. - (format "%sInserted %d chars" nn (- (cdr e) (car e))))) - ((stringp (car e)) ; (string . pos)==deletion - (format "%sDeleted \"%s\"" nn (glc-center-ellipsis (car e) 60))) - ((null (car e)) ; (nil ...)==text property change - (format "%sProperty change" nn)) - ((atom (car e)) nil) ; (t ...)==file modification time - (t nil)))) ; (marker ...)==marker moved + (cond ((numberp e) "New position") ; num==changed position + ((atom e) nil) ; nil==command boundary + ((numberp (car e)) ; (beg . end)==insertion + (if (and n (< n 2)) + (format "%sInserted %d chars \"%s\"" nn (- (cdr e) (car e)) + (glc-center-ellipsis (buffer-substring (car e) (cdr e)) 60)) + ;; else + ;; An older insert. The inserted text cannot easily be computed. + ;; Just show the char count. + (format "%sInserted %d chars" nn (- (cdr e) (car e))))) + ((stringp (car e)) ; (string . pos)==deletion + (format "%sDeleted \"%s\"" nn (glc-center-ellipsis (car e) 60))) + ((null (car e)) ; (nil ...)==text property change + (format "%sProperty change" nn)) + ((atom (car e)) nil) ; (t ...)==file modification time + (t nil)))) ; (marker ...)==marker moved (defun glc-is-positionable (e) "Return non-nil if E is an insertion, deletion or text property change. -\nE is a entry in the buffer-undo-list." +\nE is an entry in the buffer-undo-list." (and (not (numberp e)) (glc-get-pos e))) (defun glc-is-filetime (e) @@ -209,8 +209,8 @@ that is, it was previously saved or unchanged. Nil otherwise." (defun goto-last-change (arg) "Go to the point where the last edit was made in the current buffer. Repeat the command to go to the second last edit, etc. -A preceding \\[universal-argument] - (minus) will reverse direction for the next command in -the sequence, to go back to a more recent edit. +\nTo go back to more recent edit, the reverse of this command, use \\[goto-last-change-reverse] +or precede this command with \\[universal-argument] - (minus). \nIt does not go to the same point twice even if there has been many edits there. I call the minimal distance between distinguishable edits \"span\". Set variable `glc-default-span' to control how close is \"the same point\". @@ -228,86 +228,117 @@ At times, when undo information becomes too large, the oldest information is discarded. See variable `undo-limit'." (interactive "P") (cond ((not (eq this-command last-command)) - ;; Start a glc sequence - ;; Don't go to current point if last command was an obvious edit - ;; (yank or self-insert, but not kill-region). Makes it easier to - ;; jump back and forth when copying seleced lines. - (setq glc-probe-depth (if (memq last-command '(yank self-insert-command)) 1 0) - glc-direction 1 - glc-current-span glc-default-span) - (if (< (prefix-numeric-value arg) 0) - (error "Negative arg: Cannot reverse as the first operation")))) + ;; Start a glc sequence + ;; Don't go to current point if last command was an obvious edit + ;; (yank or self-insert, but not kill-region). Makes it easier to + ;; jump back and forth when copying seleced lines. + (setq glc-probe-depth (if (memq last-command '(yank self-insert-command)) 1 0) + glc-direction 1 + glc-current-span glc-default-span) + (if (< (prefix-numeric-value arg) 0) + (error "Negative arg: Cannot reverse as the first operation")))) (cond ((null buffer-undo-list) - (error "Buffer has not been changed")) - ((eq buffer-undo-list t) - (error "No change info (undo is disabled)"))) - (cond ((numberp arg) ; Numeric arg sets span - (setq glc-current-span (abs arg))) - ((consp arg) ; C-u's multiply previous span by 4 - (setq glc-current-span (* (abs (car arg)) glc-default-span)) - (message "Current span is %d chars" glc-current-span))) ;todo: keep message with "waiting" and "is saved" + (error "Buffer has not been changed")) + ((eq buffer-undo-list t) + (error "No change info (undo is disabled)"))) + (cond ((numberp arg) ; Numeric arg sets span + (setq glc-current-span (abs arg))) + ((consp arg) ; C-u's multiply previous span by 4 + (setq glc-current-span (* (abs (car arg)) glc-default-span)) + (message "Current span is %d chars" glc-current-span))) ;todo: keep message with "waiting" and "is saved" (cond ((< (prefix-numeric-value arg) 0) - (setq glc-direction -1)) - (t - (setq glc-direction 1))) - (let (rev ; Reversed (and filtered) undo list - pos ; The pos we look for, nil until found - (n 0) ; Steps in undo list (length of 'rev') - (l buffer-undo-list) - (passed-save-entry (not (buffer-modified-p))) - (new-probe-depth glc-probe-depth)) + (setq glc-direction -1)) + (t + (setq glc-direction 1))) + (let (rev ; Reversed (and filtered) undo list + pos ; The pos we look for, nil until found + (n 0) ; Steps in undo list (length of 'rev') + (l buffer-undo-list) + (passed-save-entry (not (buffer-modified-p))) + (new-probe-depth glc-probe-depth) + (undo-tree-p (bound-and-true-p undo-tree-mode)) + glc-seen-canary) ;; Walk back and forth in the buffer-undo-list, each time one step deeper, ;; until we can walk back the whole list with a 'pos' that is not coming ;; too close to another edit. (while (null pos) (setq new-probe-depth (+ new-probe-depth glc-direction)) (if (< glc-direction 0) - (setq rev () - n 0 - l buffer-undo-list - passed-save-entry (not (buffer-modified-p)))) + (setq rev () + n 0 + l buffer-undo-list + passed-save-entry (not (buffer-modified-p)))) (if (< new-probe-depth 1) - (error "No later change info")) + (error "No later change info")) (if (> n 150) - (message "working...")) + (message "working...")) ;; Walk forward in buffer-undo-list, glc-probe-depth steps. ;; Build reverse list along the way - (while (< n new-probe-depth) - (cond ((null l) - ;(setq this-command t) ; Disrupt repeat sequence - (error "No further change info")) - ((glc-is-positionable (car l)) - (setq n (1+ n) - rev (cons (car l) rev))) - ((or passed-save-entry (glc-is-filetime (car l))) - (setq passed-save-entry t))) - (setq l (cdr l))) + (if (not undo-tree-p) + (while (< n new-probe-depth) + (cond ((null l) + ;(setq this-command t) ; Disrupt repeat sequence + (error "No further change info")) + ((glc-is-positionable (car l)) + (setq n (1+ n) + rev (cons (car l) rev))) + ((or passed-save-entry (glc-is-filetime (car l))) + (setq passed-save-entry t))) + (setq l (cdr l))) + (when (not glc-seen-canary) + (while (and (not (null l)) (not glc-seen-canary) (< n new-probe-depth)) + (cond ((eq 'undo-tree-canary (car l)) ; used by buffer-undo-tree + (message "Canary found...") + (setq l (undo-tree-current buffer-undo-tree) + glc-seen-canary t)) + ((glc-is-positionable (car l)) + (setq n (1+ n) + rev (cons (car l) rev))) + ((or passed-save-entry (glc-is-filetime (car l))) + (setq passed-save-entry t))) + (when (not glc-seen-canary) + (setq l (cdr l))))) + (when glc-seen-canary + (while (< n new-probe-depth) + (cond ((null l) + ;(setq this-command t) ; Disrupt repeat sequence + (error "No further change info")) + ((glc-is-positionable (car (undo-tree-node-undo l))) + (setq n (1+ n) + rev (cons (car (undo-tree-node-undo l)) rev))) + ((or passed-save-entry (glc-is-filetime (car (undo-tree-node-undo l)))) + (setq passed-save-entry t))) + (setq l (undo-tree-node-previous l)))) + (when (null l) + (error "No further change info"))) ;; Walk back in reverse list, from older to newer edits. ;; Adjusting pos along the way. (setq pos (glc-adjust-list rev))) ;; Found a place not previously visited, in 'pos'. ;; (An error have been issued if nothing (more) found.) (if (> n 150) - (message nil)) ; remove message "working..." + (message nil)) ; remove message "working..." (if (and (= glc-current-span 0) (glc-get-descript (car rev) n)) - (message "%s" (glc-get-descript (car rev) n)) + (message "%s" (glc-get-descript (car rev) n)) ;; else (if passed-save-entry - (message "(This change is saved)"))) + (message "(This change is saved)"))) (setq glc-probe-depth new-probe-depth) (goto-char pos))) -;; ;;;###autoload +;;;###autoload (defun goto-last-change-reverse (arg) + "Go back to more recent changes after \\[goto-last-change] have been used. +See `goto-last-change' for use of prefix argument." (interactive "P") ;; Negate arg, all kinds (cond ((eq arg nil) (setq arg '-)) - ((eq arg '-) (setq arg nil)) - ((listp arg) (setq arg (list (- (car arg))))) - (t (setq arg (- arg)))) + ((eq arg '-) (setq arg nil)) + ((listp arg) (setq arg (list (- (car arg))))) + (t (setq arg (- arg)))) ;; Make 'goto-last-change-reverse' look like 'goto-last-change' (cond ((eq last-command this-command) - (setq last-command 'goto-last-change))) + (setq last-command 'goto-last-change))) (setq this-command 'goto-last-change) ;; Call 'goto-last-change' to do the job (goto-last-change arg)) diff --git a/lib/undo-tree.el b/lib/undo-tree.el index 1ff99b2..3e45b84 100644 --- a/lib/undo-tree.el +++ b/lib/undo-tree.el @@ -1,9 +1,9 @@ ;;; undo-tree.el --- Treat undo history as a tree -*- lexical-binding: t; -*- -;; Copyright (C) 2009-2012 Free Software Foundation, Inc +;; Copyright (C) 2009-2013 Free Software Foundation, Inc ;; Author: Toby Cubitt -;; Version: 0.6.3 +;; Version: 0.6.5 ;; Keywords: convenience, files, undo, redo, history, tree ;; URL: http://www.dr-qubit.org/emacs.php ;; Repository: http://www.dr-qubit.org/git/undo-tree.git @@ -51,7 +51,9 @@ ;; Installation ;; ============ ;; -;; This package requires Emacs version 24 or newer. +;; This package has only been tested with Emacs versions 24 and CVS. It should +;; work in Emacs versions 22 and 23 too, but will not work without +;; modifications in earlier versions of Emacs. ;; ;; To install `undo-tree-mode', make sure this file is saved in a directory in ;; your `load-path', and add the line: @@ -206,9 +208,7 @@ ;; ;; Persistent undo history: ;; -;; Note: Requires a recent development version of Emacs checked out out from -;; the Emacs bzr repository. All stable versions of Emacs currently -;; break this feature. +;; Note: Requires Emacs version 24.3 or higher. ;; ;; `undo-tree-auto-save-history' (variable) ;; automatically save and restore undo-tree history along with buffer @@ -883,9 +883,11 @@ when a buffer is saved to file. It will automatically load undo history when a buffer is loaded from file, if an undo save file exists. -Undo-tree history is saved to a file called -\"..~undo-tree\" in the same directory as the -file itself. +By default, undo-tree history is saved to a file called +\"..~undo-tree~\" in the same directory as the +file itself. To save under a different directory, customize +`undo-tree-history-directory-alist' (see the documentation for +that variable for details). WARNING! `undo-tree-auto-save-history' will not work properly in Emacs versions prior to 24.3, so it cannot be enabled via @@ -1201,6 +1203,42 @@ in visualizer." (setq undo-tree-visualizer-selection-mode-map map))) +(defvar undo-tree-old-undo-menu-item nil) + +(defun undo-tree-update-menu-bar () + "Update `undo-tree-mode' Edit menu items." + (if undo-tree-mode + (progn + ;; save old undo menu item, and install undo/redo menu items + (setq undo-tree-old-undo-menu-item + (cdr (assq 'undo (lookup-key global-map [menu-bar edit])))) + (define-key (lookup-key global-map [menu-bar edit]) + [undo] '(menu-item "Undo" undo-tree-undo + :enable (and undo-tree-mode + (not buffer-read-only) + (not (eq t buffer-undo-list)) + (undo-tree-node-previous + (undo-tree-current buffer-undo-tree))) + :help "Undo last operation")) + (define-key-after (lookup-key global-map [menu-bar edit]) + [redo] '(menu-item "Redo" undo-tree-redo + :enable (and undo-tree-mode + (not buffer-read-only) + (not (eq t buffer-undo-list)) + (undo-tree-node-next + (undo-tree-current buffer-undo-tree))) + :help "Redo last operation") + 'undo)) + ;; uninstall undo/redo menu items + (define-key (lookup-key global-map [menu-bar edit]) + [undo] undo-tree-old-undo-menu-item) + (define-key (lookup-key global-map [menu-bar edit]) + [redo] nil))) + +(add-hook 'menu-bar-update-hook 'undo-tree-update-menu-bar) + + + ;;; ===================================================================== @@ -2592,7 +2630,7 @@ Within the undo-tree visualizer, the following keys are available: ;; if disabling `undo-tree-mode', rebuild `buffer-undo-list' from tree so ;; Emacs undo can work - (if (not undo-tree-mode) + (when (not undo-tree-mode) (undo-list-rebuild-from-tree) (setq buffer-undo-tree nil))) @@ -2984,16 +3022,16 @@ Argument is a character, naming the register." (defun undo-tree-make-history-save-file-name (file) "Create the undo history file name for FILE. -Normally this is the file's name with `.' prepended and -`~undo-tree~' appended. +Normally this is the file's name with \".\" prepended and +\".~undo-tree~\" appended. -A match for FILE is sought in `undo-tree-history-directory-alist'; -see the documentation of that variable. If the directory for the -backup doesn't exist, it is created." +A match for FILE is sought in `undo-tree-history-directory-alist' +\(see the documentation of that variable for details\). If the +directory for the backup doesn't exist, it is created." (let* ((backup-directory-alist undo-tree-history-directory-alist) (name (make-backup-file-name-1 file))) (concat (file-name-directory name) "." (file-name-nondirectory name) - "~undo-tree~"))) + ".~undo-tree~"))) (defun undo-tree-save-history (&optional filename overwrite) @@ -3182,6 +3220,8 @@ signaling an error if file is not found." (undo-tree-current undo-tree) (undo-tree-root undo-tree)))) (erase-buffer) + (setq undo-tree-visualizer-needs-extending-down nil + undo-tree-visualizer-needs-extending-up nil) (undo-tree-clear-visualizer-data undo-tree) (undo-tree-compute-widths node) ;; lazy drawing starts vertically centred and displaced horizontally to @@ -4302,6 +4342,75 @@ specifies `saved', and a negative prefix argument specifies (balance-windows) (shrink-window-if-larger-than-buffer win)))) +;;;; ChangeLog: + +;; 2013-12-28 Toby S. Cubitt +;; +;; * undo-tree: Update to version 0.6.5. +;; +;; 2012-12-05 Toby S. Cubitt +;; +;; Update undo-tree to version 0.6.3 +;; +;; * undo-tree.el: Implement lazy tree drawing to significantly speed up +;; visualization of large trees + various more minor improvements. +;; +;; 2012-09-25 Toby S. Cubitt +;; +;; Updated undo-tree package to version 0.5.5. +;; +;; Small bug-fix to avoid hooks triggering an error when trying to save +;; undo history in a buffer where undo is disabled. +;; +;; 2012-09-11 Toby S. Cubitt +;; +;; Updated undo-tree package to version 0.5.4 +;; +;; Bug-fixes and improvements to persistent history storage. +;; +;; 2012-07-18 Toby S. Cubitt +;; +;; Update undo-tree to version 0.5.3 +;; +;; * undo-tree.el: Cope gracefully with undo boundaries being deleted +;; (cf. bug#11774). Allow customization of directory to which undo +;; history is +;; saved. +;; +;; 2012-05-24 Toby S. Cubitt +;; +;; updated undo-tree package to version 0.5.2 +;; +;; * undo-tree.el: add diff view feature in undo-tree visualizer. +;; +;; 2012-05-02 Toby S. Cubitt +;; +;; undo-tree.el: Update package to version 0.4 +;; +;; 2012-04-20 Toby S. Cubitt +;; +;; undo-tree.el: Update package to version 0.3.4 +;; +;; * undo-tree.el (undo-list-pop-changeset): fix pernicious bug causing +;; undo history to be lost. +;; (buffer-undo-tree): set permanent-local property. +;; (undo-tree-enable-undo-in-region): add new customization option +;; allowing undo-in-region to be disabled. +;; +;; 2012-01-26 Toby S. Cubitt +;; +;; undo-tree.el: Fixed copyright attribution and Emacs status. +;; +;; 2012-01-26 Toby S. Cubitt +;; +;; undo-tree.el: Update package to version 0.3.3 +;; +;; 2011-09-17 Stefan Monnier +;; +;; Add undo-tree.el +;; + + (provide 'undo-tree) -- cgit v1.0