Update bundled libraries to latest stable version

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 <l.david.andersson(at)sverige.nu>
+;; Maintainer: Vasilij Schneidermann <v.schneidermann@github.com>
 ;; 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
+;;    <https://github.com/martinp26/goto-chg>)
+;; 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 <toby-undo-tree@dr-qubit.org>
-;; 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
-\".<buffer-file-name>.~undo-tree\" in the same directory as the
-file itself.
+By default, undo-tree history is saved to a file called
+\".<buffer-file-name>.~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  <tsc25@cantab.net>
+;; 
+;; 	* undo-tree: Update to version 0.6.5.
+;; 
+;; 2012-12-05  Toby S. Cubitt  <tsc25@cantab.net>
+;; 
+;; 	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  <tsc25@cantab.net>
+;; 
+;; 	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  <tsc25@cantab.net>
+;; 
+;; 	Updated undo-tree package to version 0.5.4
+;; 
+;; 	Bug-fixes and improvements to persistent history storage.
+;; 
+;; 2012-07-18  Toby S. Cubitt  <tsc25@cantab.net>
+;; 
+;; 	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  <tsc25@cantab.net>
+;; 
+;; 	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  <tsc25@cantab.net>
+;; 
+;; 	undo-tree.el: Update package to version 0.4
+;; 
+;; 2012-04-20  Toby S. Cubitt  <tsc25@cantab.net>
+;; 
+;; 	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  <tsc25@cantab.net>
+;; 
+;; 	undo-tree.el: Fixed copyright attribution and Emacs status.
+;; 
+;; 2012-01-26  Toby S. Cubitt  <tsc25@cantab.net>
+;; 
+;; 	undo-tree.el: Update package to version 0.3.3
+;; 
+;; 2011-09-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+;; 
+;; 	Add undo-tree.el
+;; 
+
+
 
 
 (provide 'undo-tree)