Move/add window-buffer-related functions to window.el.

* buffer.c: New Lisp objects Qbuffer_list_update_hook and
Qclone_number.  Remove external declaration of Qdelete_window.
(Fbuffer_list): Rewrite doc-string.  Minor restructuring of
code.
(Fget_buffer_create, Fmake_indirect_buffer, Frename_buffer): Run
Qbuffer_list_update_hook if allowed.
(Fother_buffer): Rewrite doc-string.  Major rewrite for new
buffer list implementation.
(other_buffer_safely): New function.
(Fkill_buffer): Replace call to replace_buffer_in_all_windows by
calls to replace_buffer_in_windows and
replace_buffer_in_windows_safely.  Run Qbuffer_list_update_hook
if allowed.
(record_buffer): Inhibit quitting and rewrite using quittable
functions.  Run Qbuffer_list_update_hook if allowed.
(Frecord_buffer, Funrecord_buffer): New functions.
(switch_to_buffer_1, Fswitch_to_buffer): Remove.  Move
switch-to-buffer to window.el.
(bury-buffer): Move to window.el.
(Vbuffer_list_update_hook): New variable.

* lisp.h (other_buffer_safely): Add prototype in buffer.c
section.

* window.h (resize_frame_windows): Move up in code.
(Fwindow_frame): Remove EXFUN.
(replace_buffer_in_all_windows): Remove prototype.
(replace_buffer_in_windows_safely): Add prototype.

* window.c: Declare Qdelete_window static again.  Move down
declaration of select_count.
(Fnext_window, Fprevious_window): Rewrite doc-strings.
(Fother_window): Move to window.el.
(window_loop): Remove DELETE_BUFFER_WINDOWS and UNSHOW_BUFFER
cases.  Add REPLACE_BUFFER_IN_WINDOWS_SAFELY case.
(Fdelete_windows_on, Freplace_buffer_in_windows): Move to
window.el.
(replace_buffer_in_windows): Implement by calling
Qreplace_buffer_in_windows.
(replace_buffer_in_all_windows): Remove with some functionality
moved into replace_buffer_in_windows_safely.
(replace_buffer_in_windows_safely): New function.
(select_window_norecord, select_frame_norecord): Move in front
of run_window_configuration_change_hook.  Remove now obsolete
declarations.
(Fset_window_buffer): Rewrite doc-string.  Call
Qrecord_window_buffer.
(keys_of_window): Move binding for other-window to window.el.

* loadup.el (top-level): Load window before files for the sake
of replace-buffer-in-windows.

* files.el (read-buffer-to-switch)
(switch-to-buffer-other-window)
(switch-to-buffer-other-frame, display-buffer-other-frame): Move
to window.el.

* simple.el (get-next-valid-buffer, last-buffer, next-buffer)
(previous-buffer): Move to window.el.

* bindings.el (unbury-buffer): Move to window.el.

* window.el (delete-other-windows-vertically): Move after
definition of delete-other-windows.
(other-window, delete-windows-on, replace-buffer-in-windows):
Move here from window.c.
(record-window-buffer, unrecord-window-buffer)
(set-window-buffer-start-and-point, switch-to-prev-buffer)
(switch-to-next-buffer): New functions.
(get-next-valid-buffer, last-buffer, next-buffer): Move here
from simple.el.  Call switch-to-next-buffer.
(previous-buffer): Move here from simple.el.  Call
switch-to-prev-buffer.
(bury-buffer): Move here from buffer.c.  Switch to previous
buffer when window cannot be deleted.
(unbury-buffer): Move here from bindings.el.
(ctl-x-map): Move binding for other-window from window.c to
here.
(read-buffer-to-switch, switch-to-buffer-other-window)
(switch-to-buffer-other-frame): Move here from files.el.
(normalize-buffer-to-switch-to): New functions.
(switch-to-buffer): Move here from buffer.c.  Use
read-buffer-to-switch and normalize-buffer-to-switch-to.

6 files changed, 777 insertions, 183 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 1ac216dfbe2..611531330cc 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,42 @@
 2011-06-10  Martin Rudalics  <rudalics@gmx.at>
 
+        * loadup.el (top-level): Load window before files for the sake
+        of replace-buffer-in-windows.
+
+        * files.el (read-buffer-to-switch)
+        (switch-to-buffer-other-window)
+        (switch-to-buffer-other-frame, display-buffer-other-frame): Move
+        to window.el.
+
+        * simple.el (get-next-valid-buffer, last-buffer, next-buffer)
+        (previous-buffer): Move to window.el.
+
+        * bindings.el (unbury-buffer): Move to window.el.
+
+        * window.el (delete-other-windows-vertically): Move after
+        definition of delete-other-windows.
+        (other-window, delete-windows-on, replace-buffer-in-windows):
+        Move here from window.c.
+        (record-window-buffer, unrecord-window-buffer)
+        (set-window-buffer-start-and-point, switch-to-prev-buffer)
+        (switch-to-next-buffer): New functions.
+        (get-next-valid-buffer, last-buffer, next-buffer): Move here
+        from simple.el.  Call switch-to-next-buffer.
+        (previous-buffer): Move here from simple.el.  Call
+        switch-to-prev-buffer.
+        (bury-buffer): Move here from buffer.c.  Switch to previous
+        buffer when window cannot be deleted.
+        (unbury-buffer): Move here from bindings.el.
+        (ctl-x-map): Move binding for other-window from window.c to
+        here.
+        (read-buffer-to-switch, switch-to-buffer-other-window)
+        (switch-to-buffer-other-frame): Move here from files.el.
+        (normalize-buffer-to-switch-to): New functions.
+        (switch-to-buffer): Move here from buffer.c.  Use
+        read-buffer-to-switch and normalize-buffer-to-switch-to.
+
+2011-06-10  Martin Rudalics  <rudalics@gmx.at>
+
         * window.el (window-min-height, window-min-width): Move here
         from window.c.  Add defcustoms and rewrite doc-strings.
         (resize-mini-window, resize-window): New functions.
diff --git a/lisp/bindings.el b/lisp/bindings.el
index ffc797966b8..a7b729a1ba3 100644
--- a/lisp/bindings.el
+++ b/lisp/bindings.el
@@ -454,11 +454,6 @@ Major modes that edit things other than ordinary files may change this
 (put 'mode-line-buffer-identification 'risky-local-variable t)
 (make-variable-buffer-local 'mode-line-buffer-identification)
 
-(defun unbury-buffer () "\
-Switch to the last buffer in the buffer list."
-  (interactive)
-  (switch-to-buffer (last-buffer)))
-
 (defun mode-line-unbury-buffer (event) "\
 Call `unbury-buffer' in this window."
   (interactive "e")
diff --git a/lisp/files.el b/lisp/files.el
index 317153dc9bf..aafc6f92906 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -1288,100 +1288,6 @@ return value, which may be passed as the REQUIRE-MATCH arg to
          'confirm)
         (t nil)))
 
-(defun read-buffer-to-switch (prompt)
-  "Read the name of a buffer to switch to and return as a string.
-It is intended for `switch-to-buffer' family of commands since they
-need to omit the name of current buffer from the list of completions
-and default values."
-  (let ((rbts-completion-table (internal-complete-buffer-except)))
-    (minibuffer-with-setup-hook
-        (lambda ()
-          (setq minibuffer-completion-table rbts-completion-table)
-          ;; Since rbts-completion-table is built dynamically, we
-          ;; can't just add it to the default value of
-          ;; icomplete-with-completion-tables, so we add it
-          ;; here manually.
-          (if (and (boundp 'icomplete-with-completion-tables)
-                   (listp icomplete-with-completion-tables))
-              (set (make-local-variable 'icomplete-with-completion-tables)
-                   (cons rbts-completion-table
-                         icomplete-with-completion-tables))))
-      (read-buffer prompt (other-buffer (current-buffer))
-                   (confirm-nonexistent-file-or-buffer)))))
-
-(defun switch-to-buffer-other-window (buffer-or-name &optional norecord)
-  "Select the buffer specified by BUFFER-OR-NAME in another window.
-BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
-nil.  Return the buffer switched to.
-
-If called interactively, prompt for the buffer name using the
-minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
-determines whether to request confirmation before creating a new
-buffer.
-
-If BUFFER-OR-NAME is a string and does not identify an existing
-buffer, create a new buffer with that name.  If BUFFER-OR-NAME is
-nil, switch to the buffer returned by `other-buffer'.
-
-Optional second argument NORECORD non-nil means do not put this
-buffer at the front of the list of recently selected ones.
-
-This uses the function `display-buffer' as a subroutine; see its
-documentation for additional customization information."
-  (interactive
-   (list (read-buffer-to-switch "Switch to buffer in other window: ")))
-  (let ((pop-up-windows t)
-        same-window-buffer-names same-window-regexps)
-    (pop-to-buffer buffer-or-name t norecord)))
-
-(defun switch-to-buffer-other-frame (buffer-or-name &optional norecord)
-  "Switch to buffer BUFFER-OR-NAME in another frame.
-BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
-nil.  Return the buffer switched to.
-
-If called interactively, prompt for the buffer name using the
-minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
-determines whether to request confirmation before creating a new
-buffer.
-
-If BUFFER-OR-NAME is a string and does not identify an existing
-buffer, create a new buffer with that name.  If BUFFER-OR-NAME is
-nil, switch to the buffer returned by `other-buffer'.
-
-Optional second arg NORECORD non-nil means do not put this
-buffer at the front of the list of recently selected ones.
-
-This uses the function `display-buffer' as a subroutine; see its
-documentation for additional customization information."
-  (interactive
-   (list (read-buffer-to-switch "Switch to buffer in other frame: ")))
-  (let ((pop-up-frames t)
-        same-window-buffer-names same-window-regexps)
-    (pop-to-buffer buffer-or-name t norecord)))
-
-(defun display-buffer-other-frame (buffer)
-  "Display buffer BUFFER in another frame.
-This uses the function `display-buffer' as a subroutine; see
-its documentation for additional customization information."
-  (interactive "BDisplay buffer in other frame: ")
-  (let ((pop-up-frames t)
-        same-window-buffer-names same-window-regexps
-        ;;(old-window (selected-window))
-        new-window)
-    (setq new-window (display-buffer buffer t))
-    ;; This may have been here in order to prevent the new frame from hiding
-    ;; the old frame.  But it does more harm than good.
-    ;; Maybe we should call `raise-window' on the old-frame instead?  --Stef
-    ;;(lower-frame (window-frame new-window))
-
-    ;; This may have been here in order to make sure the old-frame gets the
-    ;; focus.  But not only can it cause an annoying flicker, with some
-    ;; window-managers it just makes the window invisible, with no easy
-    ;; way to recover it.  --Stef
-    ;;(make-frame-invisible (window-frame old-window))
-    ;;(make-frame-visible (window-frame old-window))
-    ))
-
 (defmacro minibuffer-with-setup-hook (fun &rest body)
   "Temporarily add FUN to `minibuffer-setup-hook' while executing BODY.
 BODY should use the minibuffer at most once.
diff --git a/lisp/loadup.el b/lisp/loadup.el
index 7e80ff97cff..4c677523689 100644
--- a/lisp/loadup.el
+++ b/lisp/loadup.el
@@ -95,6 +95,7 @@
 (load "env")
 (load "format")
 (load "bindings")
+(load "window")  ; Needed here for `replace-buffer-in-windows'.
 (setq load-source-file-function 'load-with-code-conversion)
 (load "files")
 
@@ -156,7 +157,6 @@
 (load "language/cham")
 
 (load "indent")
-(load "window")
 (load "frame")
 (load "term/tty-colors")
 (load "font-core")
diff --git a/lisp/simple.el b/lisp/simple.el
index 76269c9ef9a..b36cf2ec3ec 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -52,60 +52,6 @@ wait this many seconds after Emacs becomes idle before doing an update."
 (defgroup paren-matching nil
   "Highlight (un)matching of parens and expressions."
   :group 'matching)
-
-(defun get-next-valid-buffer (list &optional buffer visible-ok frame)
-  "Search LIST for a valid buffer to display in FRAME.
-Return nil when all buffers in LIST are undesirable for display,
-otherwise return the first suitable buffer in LIST.
-
-Buffers not visible in windows are preferred to visible buffers,
-unless VISIBLE-OK is non-nil.
-If the optional argument FRAME is nil, it defaults to the selected frame.
-If BUFFER is non-nil, ignore occurrences of that buffer in LIST."
-  ;; This logic is more or less copied from other-buffer.
-  (setq frame (or frame (selected-frame)))
-  (let ((pred (frame-parameter frame 'buffer-predicate))
-        found buf)
-    (while (and (not found) list)
-      (setq buf (car list))
-      (if (and (not (eq buffer buf))
-               (buffer-live-p buf)
-               (or (null pred) (funcall pred buf))
-               (not (eq (aref (buffer-name buf) 0) ?\s))
-               (or visible-ok (null (get-buffer-window buf 'visible))))
-          (setq found buf)
-        (setq list (cdr list))))
-    (car list)))
-
-(defun last-buffer (&optional buffer visible-ok frame)
-  "Return the last buffer in FRAME's buffer list.
-If BUFFER is the last buffer, return the preceding buffer instead.
-Buffers not visible in windows are preferred to visible buffers,
-unless optional argument VISIBLE-OK is non-nil.
-Optional third argument FRAME nil or omitted means use the
-selected frame's buffer list.
-If no such buffer exists, return the buffer `*scratch*', creating
-it if necessary."
-  (setq frame (or frame (selected-frame)))
-  (or (get-next-valid-buffer (nreverse (buffer-list frame))
-                             buffer visible-ok frame)
-      (get-buffer "*scratch*")
-      (let ((scratch (get-buffer-create "*scratch*")))
-        (set-buffer-major-mode scratch)
-        scratch)))
-
-(defun next-buffer ()
-  "Switch to the next buffer in cyclic order."
-  (interactive)
-  (let ((buffer (current-buffer)))
-    (switch-to-buffer (other-buffer buffer t))
-    (bury-buffer buffer)))
-
-(defun previous-buffer ()
-  "Switch to the previous buffer in cyclic order."
-  (interactive)
-  (switch-to-buffer (last-buffer (current-buffer) t)))
-
 
 ;;; next-error support framework
 
diff --git a/lisp/window.el b/lisp/window.el
index a88e56be83c..2811baf706d 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -2078,6 +2078,74 @@ WINDOW can be any window and defaults to the selected window."
   "Return non-nil if WINDOW is the root window of its frame."
   (eq window (frame-root-window window)))
 
+(defun other-window (count &optional all-frames)
+  "Select another window in cyclic ordering of windows.
+COUNT specifies the number of windows to skip, starting with the
+selected window, before making the selection.  If COUNT is
+positive, skip COUNT windows forwards.  If COUNT is negative,
+skip -COUNT windows backwards.  COUNT zero means do not skip any
+window, so select the selected window.  In an interactive call,
+COUNT is the numeric prefix argument.  Return nil.
+
+If the `other-window' parameter of WINDOW is a function and
+`ignore-window-parameters' is nil, call that function with the
+arguments COUNT and ALL-FRAMES.
+
+This function does not select a window whose `no-other-window'
+window parameter is non-nil.
+
+This function uses `next-window' for finding the window to
+select.  The argument ALL-FRAMES has the same meaning as in
+`next-window', but the MINIBUF argument of `next-window' is
+always effectively nil."
+  (interactive "p")
+  (let* ((window (selected-window))
+         (function (and (not ignore-window-parameters)
+                        (window-parameter window 'other-window)))
+         old-window old-count)
+    (if (functionp function)
+        (funcall function count all-frames)
+      ;; `next-window' and `previous-window' may return a window we are
+      ;; not allowed to select.  Hence we need an exit strategy in case
+      ;; all windows are non-selectable.
+      (catch 'exit
+        (while (> count 0)
+          (setq window (next-window window nil all-frames))
+          (cond
+           ((eq window old-window)
+            (when (= count old-count)
+              ;; Keep out of infinite loops.  When COUNT has not changed
+              ;; since we last looked at `window' we're probably in one.
+              (throw 'exit nil)))
+           ((window-parameter window 'no-other-window)
+            (unless old-window
+              ;; The first non-selectable window `next-window' got us:
+              ;; Remember it and the current value of COUNT.
+              (setq old-window window)
+              (setq old-count count)))
+           (t
+            (setq count (1- count)))))
+        (while (< count 0)
+          (setq window (previous-window window nil all-frames))
+          (cond
+           ((eq window old-window)
+            (when (= count old-count)
+              ;; Keep out of infinite loops.  When COUNT has not changed
+              ;; since we last looked at `window' we're probably in one.
+              (throw 'exit nil)))
+           ((window-parameter window 'no-other-window)
+            (unless old-window
+              ;; The first non-selectable window `previous-window' got
+              ;; us: Remember it and the current value of COUNT.
+              (setq old-window window)
+              (setq old-count count)))
+           (t
+            (setq count (1+ count)))))
+
+        (select-window window)
+        ;; Always return nil.
+        nil))))
+
 ;; This should probably return non-nil when the selected window is part
 ;; of an atomic window whose root is the frame's root window.
 (defun one-window-p (&optional nomini all-frames)
@@ -2285,6 +2353,518 @@ window signal an error."
         (window-check frame))
       ;; Always return nil.
       nil)))
+
+(defun delete-other-windows-vertically (&optional window)
+  "Delete the windows in the same column with WINDOW, but not WINDOW itself.
+This may be a useful alternative binding for \\[delete-other-windows]
+ if you often split windows horizontally."
+  (interactive)
+  (let* ((window (or window (selected-window)))
+         (edges (window-edges window))
+         (w window) delenda)
+    (while (not (eq (setq w (next-window w 1)) window))
+      (let ((e (window-edges w)))
+        (when (and (= (car e) (car edges))
+                   (= (caddr e) (caddr edges)))
+          (push w delenda))))
+    (mapc 'delete-window delenda)))
+
+;;; Windows and buffers.
+
+;; `prev-buffers' and `next-buffers' are two reserved window slots used
+;; for (1) determining which buffer to show in the window when its
+;; buffer shall be buried or killed and (2) which buffer to show for
+;; `switch-to-prev-buffer' and `switch-to-next-buffer'.
+
+;; `prev-buffers' consists of <buffer, window-start, window-point>
+;; triples.  The entries on this list are ordered by the time their
+;; buffer has been removed from the window, the most recently removed
+;; buffer's entry being first.  The window-start and window-point
+;; components are `window-start' and `window-point' at the time the
+;; buffer was removed from the window which implies that the entry must
+;; be added when `set-window-buffer' removes the buffer from the window.
+
+;; `next-buffers' is the list of buffers that have been replaced
+;; recently by `switch-to-prev-buffer'.  These buffers are the least
+;; preferred candidates of `switch-to-prev-buffer' and the preferred
+;; candidates of `switch-to-next-buffer' to switch to.  This list is
+;; reset to nil by any action changing the window's buffer with the
+;; exception of `switch-to-prev-buffer' and `switch-to-next-buffer'.
+;; `switch-to-prev-buffer' pushes the buffer it just replaced on it,
+;; `switch-to-next-buffer' pops the last pushed buffer from it.
+
+;; Both `prev-buffers' and `next-buffers' may reference killed buffers
+;; if such a buffer was killed while the window was hidden within a
+;; window configuration.  Such killed buffers get removed whenever
+;; `switch-to-prev-buffer' or `switch-to-next-buffer' encounter them.
+
+;; The following function is called by `set-window-buffer' _before_ it
+;; replaces the buffer of the argument window with the new buffer.
+(defun record-window-buffer (&optional window)
+  "Record WINDOW's buffer.
+WINDOW must be a live window and defaults to the selected one."
+  (let* ((window (normalize-live-window window))
+         (buffer (window-buffer window))
+         (entry (assq buffer (window-prev-buffers window))))
+    ;; Reset WINDOW's next buffers.  If needed, they are resurrected by
+    ;; `switch-to-prev-buffer' and `switch-to-next-buffer'.
+    (set-window-next-buffers window nil)
+
+    (when entry
+      ;; Remove all entries for BUFFER from WINDOW's previous buffers.
+      (set-window-prev-buffers
+       window (assq-delete-all buffer (window-prev-buffers window))))
+
+    ;; Don't record insignificant buffers.
+    (unless (eq (aref (buffer-name buffer) 0) ?\s)
+      ;; Add an entry for buffer to WINDOW's previous buffers.
+      (with-current-buffer buffer
+        (let ((start (window-start window))
+              (point (window-point window)))
+          (setq entry
+                (cons buffer
+                      (if entry
+                          ;; We have an entry, update marker positions.
+                          (list (set-marker (nth 1 entry) start)
+                                (set-marker (nth 2 entry) point))
+                        ;; Make new markers.
+                        (list (copy-marker start)
+                              (copy-marker point)))))
+
+          (set-window-prev-buffers
+           window (cons entry (window-prev-buffers window))))))))
+
+(defun unrecord-window-buffer (&optional window buffer)
+  "Unrecord BUFFER in WINDOW.
+WINDOW must be a live window and defaults to the selected one.
+BUFFER must be a live buffer and defaults to the buffer of
+WINDOW."
+  (let* ((window (normalize-live-window window))
+         (buffer (or buffer (window-buffer window))))
+    (set-window-prev-buffers
+     window (assq-delete-all buffer (window-prev-buffers window)))
+    (set-window-next-buffers
+     window (delq buffer (window-next-buffers window)))))
+
+(defun set-window-buffer-start-and-point (window buffer &optional start point)
+  "Set WINDOW's buffer to BUFFER.
+Optional argument START non-nil means set WINDOW's start position
+to START.  Optional argument POINT non-nil means set WINDOW's
+point to POINT.  If WINDOW is selected this also sets BUFFER's
+`point' to POINT.  If WINDOW is selected and the buffer it showed
+before was current this also makes BUFFER the current buffer."
+  (let ((selected (eq window (selected-window)))
+        (current (eq (window-buffer window) (current-buffer))))
+    (set-window-buffer window buffer)
+    (when (and selected current)
+      (set-buffer buffer))
+    (when start
+      (set-window-start window start))
+    (when point
+      (if selected
+          (with-current-buffer buffer
+            (goto-char point))
+        (set-window-point window point)))))
+
+(defun switch-to-prev-buffer (&optional window bury-or-kill)
+  "In WINDOW switch to previous buffer.
+WINDOW must be a live window and defaults to the selected one.
+
+Optional argument BURY-OR-KILL non-nil means the buffer currently
+shown in WINDOW is about to be buried or killed and consequently
+shall not be switched to in future invocations of this command."
+  (interactive)
+  (let* ((window (normalize-live-window window))
+         (old-buffer (window-buffer window))
+         ;; Save this since it's destroyed by `set-window-buffer'.
+         (next-buffers (window-next-buffers window))
+         entry new-buffer killed-buffers deletable visible)
+    (cond
+     ;; When BURY-OR-KILL is non-nil, there's no previous buffer for
+     ;; this window, and we can delete the window (or the frame) do
+     ;; that.
+     ((and bury-or-kill
+           (or (not (window-prev-buffers window))
+               (and (eq (caar (window-prev-buffers window)) old-buffer)
+                    (not (cdr (car (window-prev-buffers window))))))
+           (setq deletable (window-deletable-p window)))
+      (if (eq deletable 'frame)
+          (delete-frame (window-frame window))
+        (delete-window window)))
+     ((window-dedicated-p window)
+      (error "Window %s is dedicated to buffer %s" window old-buffer)))
+
+    (unless deletable
+      (catch 'found
+        ;; Scan WINDOW's previous buffers first, skipping entries of next
+        ;; buffers.
+        (dolist (entry (window-prev-buffers window))
+          (when (and (setq new-buffer (car entry))
+                     (or (buffer-live-p new-buffer)
+                         (not (setq killed-buffers
+                                    (cons new-buffer killed-buffers))))
+                     (not (eq new-buffer old-buffer))
+                     (or bury-or-kill
+                         (not (memq new-buffer next-buffers))))
+            (set-window-buffer-start-and-point
+             window new-buffer (nth 1 entry) (nth 2 entry))
+            (throw 'found t)))
+        ;; Scan reverted buffer list of WINDOW's frame next, skipping
+        ;; entries of next buffers.  Note that when we bury or kill a
+        ;; buffer we don't reverse the global buffer list to avoid showing
+        ;; a buried buffer instead.  Otherwise, we must reverse the global
+        ;; buffer list in order to make sure that switching to the
+        ;; previous/next buffer traverse it in opposite directions.
+        (dolist (buffer (if bury-or-kill
+                            (buffer-list (window-frame window))
+                          (nreverse (buffer-list (window-frame window)))))
+          (when (and (buffer-live-p buffer)
+                     (not (eq buffer old-buffer))
+                     (not (eq (aref (buffer-name buffer) 0) ?\s))
+                     (or bury-or-kill (not (memq buffer next-buffers))))
+            (if (get-buffer-window buffer)
+                ;; Try to avoid showing a buffer visible in some other window.
+                (setq visible buffer)
+            (setq new-buffer buffer)
+            (set-window-buffer-start-and-point window new-buffer)
+            (throw 'found t))))
+        (unless bury-or-kill
+          ;; Scan reverted next buffers last (must not use nreverse
+          ;; here!).
+          (dolist (buffer (reverse next-buffers))
+            ;; Actually, buffer _must_ be live here since otherwise it
+            ;; would have been caught in the scan of previous buffers.
+            (when (and (or (buffer-live-p buffer)
+                           (not (setq killed-buffers
+                                      (cons buffer killed-buffers))))
+                       (not (eq buffer old-buffer))
+                       (setq entry (assq buffer (window-prev-buffers window))))
+              (setq new-buffer buffer)
+              (set-window-buffer-start-and-point
+               window new-buffer (nth 1 entry) (nth 2 entry))
+              (throw 'found t))))
+
+        ;; Show a buffer visible in another window.
+        (when visible
+          (setq new-buffer visible)
+          (set-window-buffer-start-and-point window new-buffer)))
+
+      (if bury-or-kill
+          ;; Remove `old-buffer' from WINDOW's previous and (restored list
+          ;; of) next buffers.
+          (progn
+            (set-window-prev-buffers
+             window (assq-delete-all old-buffer (window-prev-buffers window)))
+            (set-window-next-buffers window (delq old-buffer next-buffers)))
+        ;; Move `old-buffer' to head of WINDOW's restored list of next
+        ;; buffers.
+        (set-window-next-buffers
+         window (cons old-buffer (delq old-buffer next-buffers)))))
+
+    ;; Remove killed buffers from WINDOW's previous and next buffers.
+    (when killed-buffers
+      (dolist (buffer killed-buffers)
+        (set-window-prev-buffers
+         window (assq-delete-all buffer (window-prev-buffers window)))
+        (set-window-next-buffers
+         window (delq buffer (window-next-buffers window)))))
+
+    ;; Return new-buffer.
+    new-buffer))
+
+(defun switch-to-next-buffer (&optional window)
+  "In WINDOW switch to next buffer.
+WINDOW must be a live window and defaults to the selected one."
+  (interactive)
+  (let* ((window (normalize-live-window window))
+         (old-buffer (window-buffer window))
+         (next-buffers (window-next-buffers window))
+         new-buffer entry killed-buffers visible)
+    (when (window-dedicated-p window)
+      (error "Window %s is dedicated to buffer %s" window old-buffer))
+
+    (catch 'found
+      ;; Scan WINDOW's next buffers first.
+      (dolist (buffer next-buffers)
+        (when (and (or (buffer-live-p buffer)
+                       (not (setq killed-buffers
+                                  (cons buffer killed-buffers))))
+                   (not (eq buffer old-buffer))
+                   (setq entry (assq buffer (window-prev-buffers window))))
+          (setq new-buffer buffer)
+          (set-window-buffer-start-and-point
+           window new-buffer (nth 1 entry) (nth 2 entry))
+          (throw 'found t)))
+      ;; Scan the buffer list of WINDOW's frame next, skipping previous
+      ;; buffers entries.
+      (dolist (buffer (buffer-list (window-frame window)))
+        (when (and (buffer-live-p buffer) (not (eq buffer old-buffer))
+                   (not (eq (aref (buffer-name buffer) 0) ?\s))
+                   (not (assq buffer (window-prev-buffers window))))
+          (if (get-buffer-window buffer)
+              ;; Try to avoid showing a buffer visible in some other window.
+              (setq visible buffer)
+            (setq new-buffer buffer)
+            (set-window-buffer-start-and-point window new-buffer)
+            (throw 'found t))))
+      ;; Scan WINDOW's reverted previous buffers last (must not use
+      ;; nreverse here!)
+      (dolist (entry (reverse (window-prev-buffers window)))
+        (when (and (setq new-buffer (car entry))
+                   (or (buffer-live-p new-buffer)
+                       (not (setq killed-buffers
+                                  (cons new-buffer killed-buffers))))
+                   (not (eq new-buffer old-buffer)))
+          (set-window-buffer-start-and-point
+           window new-buffer (nth 1 entry) (nth 2 entry))
+          (throw 'found t)))
+
+      ;; Show a buffer visible in another window.
+      (when visible
+        (setq new-buffer visible)
+        (set-window-buffer-start-and-point window new-buffer)))
+
+    ;; Remove `new-buffer' from and restore WINDOW's next buffers.
+    (set-window-next-buffers window (delq new-buffer next-buffers))
+
+    ;; Remove killed buffers from WINDOW's previous and next buffers.
+    (when killed-buffers
+      (dolist (buffer killed-buffers)
+        (set-window-prev-buffers
+         window (assq-delete-all buffer (window-prev-buffers window)))
+        (set-window-next-buffers
+         window (delq buffer (window-next-buffers window)))))
+
+    ;; Return new-buffer.
+    new-buffer))
+
+(defun get-next-valid-buffer (list &optional buffer visible-ok frame)
+  "Search LIST for a valid buffer to display in FRAME.
+Return nil when all buffers in LIST are undesirable for display,
+otherwise return the first suitable buffer in LIST.
+
+Buffers not visible in windows are preferred to visible buffers,
+unless VISIBLE-OK is non-nil.
+If the optional argument FRAME is nil, it defaults to the selected frame.
+If BUFFER is non-nil, ignore occurrences of that buffer in LIST."
+  ;; This logic is more or less copied from other-buffer.
+  (setq frame (or frame (selected-frame)))
+  (let ((pred (frame-parameter frame 'buffer-predicate))
+        found buf)
+    (while (and (not found) list)
+      (setq buf (car list))
+      (if (and (not (eq buffer buf))
+               (buffer-live-p buf)
+               (or (null pred) (funcall pred buf))
+               (not (eq (aref (buffer-name buf) 0) ?\s))
+               (or visible-ok (null (get-buffer-window buf 'visible))))
+          (setq found buf)
+        (setq list (cdr list))))
+    (car list)))
+
+(defun last-buffer (&optional buffer visible-ok frame)
+  "Return the last buffer in FRAME's buffer list.
+If BUFFER is the last buffer, return the preceding buffer
+instead.  Buffers not visible in windows are preferred to visible
+buffers, unless optional argument VISIBLE-OK is non-nil.
+Optional third argument FRAME nil or omitted means use the
+selected frame's buffer list.  If no such buffer exists, return
+the buffer `*scratch*', creating it if necessary."
+  (setq frame (or frame (selected-frame)))
+  (or (get-next-valid-buffer (nreverse (buffer-list frame))
+                             buffer visible-ok frame)
+      (get-buffer "*scratch*")
+      (let ((scratch (get-buffer-create "*scratch*")))
+        (set-buffer-major-mode scratch)
+        scratch)))
+
+(defun bury-buffer (&optional buffer-or-name)
+  "Put BUFFER-OR-NAME at the end of the list of all buffers.
+There it is the least likely candidate for `other-buffer' to
+return; thus, the least likely buffer for \\[switch-to-buffer] to
+select by default.
+
+You can specify a buffer name as BUFFER-OR-NAME, or an actual
+buffer object.  If BUFFER-OR-NAME is nil or omitted, bury the
+current buffer.  Also, if BUFFER-OR-NAME is nil or omitted,
+remove the current buffer from the selected window if it is
+displayed there."
+  (interactive)
+  (let* ((buffer (normalize-live-buffer buffer-or-name)))
+    ;; If `buffer-or-name' is not on the selected frame we unrecord it
+    ;; although it's not "here" (call it a feature).
+    (unrecord-buffer buffer)
+    ;; Handle case where `buffer-or-name' is nil and the current buffer
+    ;; is shown in the selected window.
+    (cond
+     ((or buffer-or-name (not (eq buffer (window-buffer)))))
+     ((not (window-dedicated-p))
+      (switch-to-prev-buffer nil 'bury))
+     ((frame-root-window-p (selected-window))
+      (iconify-frame (window-frame (selected-window))))
+     ((window-deletable-p)
+      (delete-window)))
+    ;; Always return nil.
+    nil))
+
+(defun unbury-buffer ()
+  "Switch to the last buffer in the buffer list."
+  (interactive)
+  (switch-to-buffer (last-buffer)))
+
+(defun next-buffer ()
+  "In selected window switch to next buffer."
+  (interactive)
+  (switch-to-next-buffer))
+
+(defun previous-buffer ()
+  "In selected window switch to previous buffer."
+  (interactive)
+  (switch-to-prev-buffer))
+
+(defun delete-windows-on (&optional buffer-or-name frame)
+  "Delete all windows showing BUFFER-OR-NAME.
+BUFFER-OR-NAME may be a buffer or the name of an existing buffer
+and defaults to the current buffer.
+
+The following non-nil values of the optional argument FRAME
+have special meanings:
+
+- t means consider all windows on the selected frame only.
+
+- `visible' means consider all windows on all visible frames on
+  the current terminal.
+
+- 0 (the number zero) means consider all windows on all visible
+  and iconified frames on the current terminal.
+
+- A frame means consider all windows on that frame only.
+
+Any other value of FRAME means consider all windows on all
+frames.
+
+When a window showing BUFFER-OR-NAME is dedicated and the only
+window of its frame, that frame is deleted when there are other
+frames left."
+  (interactive "BDelete windows on (buffer):\nP")
+  (let ((buffer (normalize-live-buffer buffer-or-name))
+        ;; Handle the "inverted" meaning of the FRAME argument wrt other
+        ;; `window-list-1' based function.
+        (all-frames (cond ((not frame) t) ((eq frame t) nil) (t frame))))
+    (dolist (window (window-list-1 nil nil all-frames))
+      (if (eq (window-buffer window) buffer)
+          (let ((deletable (window-deletable-p window)))
+            (cond
+             ((eq deletable 'frame)
+              ;; Delete frame.
+              (delete-frame (window-frame window)))
+             (deletable
+              ;; Delete window only.
+              (delete-window window))
+             (t
+              ;; In window switch to previous buffer.
+              (set-window-dedicated-p window nil)
+              (switch-to-prev-buffer window 'bury))))
+        ;; If a window doesn't show BUFFER, unrecord BUFFER in it.
+        (unrecord-window-buffer window buffer)))))
+
+(defun replace-buffer-in-windows (&optional buffer-or-name)
+  "Replace BUFFER-OR-NAME with some other buffer in all windows showing it.
+BUFFER-OR-NAME may be a buffer or the name of an existing buffer
+and defaults to the current buffer.
+
+When a window showing BUFFER-OR-NAME is either dedicated, or the
+window has no previous buffer, that window is deleted.  If that
+window is the only window on its frame, the frame is deleted too
+when there are other frames left.  If there are no other frames
+left, some other buffer is displayed in that window.
+
+This function removes the buffer denoted by BUFFER-OR-NAME from
+all window-local buffer lists."
+  (let ((buffer (normalize-live-buffer buffer-or-name)))
+    (dolist (window (window-list-1 nil nil t))
+      (if (eq (window-buffer window) buffer)
+          (let ((deletable (window-deletable-p window)))
+            (cond
+             ((eq deletable 'frame)
+              ;; Delete frame.
+              (delete-frame (window-frame window)))
+             ((and (window-dedicated-p window) deletable)
+              ;; Delete window.
+              (delete-window window))
+             (t
+              ;; Switch to another buffer in window.
+              (set-window-dedicated-p window nil)
+              (switch-to-prev-buffer window 'kill))))
+        ;; Unrecord BUFFER in WINDOW.
+        (unrecord-window-buffer window buffer)))))
+
+(defun quit-restore-window (&optional window kill)
+  "Quit WINDOW in some way.
+WINDOW must be a live window and defaults to the selected window.
+Return nil.
+
+According to information stored in WINDOW's `quit-restore' window
+parameter either \(1) delete WINDOW and its frame, \(2) delete
+WINDOW, \(3) restore the buffer previously displayed in WINDOW,
+or \(4) make WINDOW display some other buffer than the present
+one.  If non-nil, reset `quit-restore' parameter to nil.
+
+Optional argument KILL non-nil means in addition kill WINDOW's
+buffer.  If KILL is nil, put WINDOW's buffer at the end of the
+buffer list.  Interactively, KILL is the prefix argument."
+  (interactive "i\nP")
+  (setq window (normalize-live-window window))
+  (let ((buffer (window-buffer window))
+        (quit-restore (window-parameter window 'quit-restore))
+        deletable resize)
+    (cond
+     ((and (or (and (memq (car-safe quit-restore) '(new-window new-frame))
+                    ;; Check that WINDOW's buffer is still the same.
+                    (eq (window-buffer window) (nth 1 quit-restore)))
+               (window-dedicated-p window))
+           (setq deletable (window-deletable-p window)))
+      ;; WINDOW can be deleted.
+      (unrecord-buffer buffer)
+      (if (eq deletable 'frame)
+          ;; WINDOW's frame can be deleted.
+          (delete-frame (window-frame window))
+        ;; Just delete WINDOW.
+        (delete-window window))
+      ;; If the previously selected window is still alive, select it.
+      (when (window-live-p (nth 2 quit-restore))
+        (select-window (nth 2 quit-restore))))
+     ((and (buffer-live-p (nth 0 quit-restore))
+           ;; The buffer currently shown in WINDOW must still be the
+           ;; buffer shown when its `quit-restore' parameter was created
+           ;; in the first place.
+           (eq (window-buffer window) (nth 3 quit-restore)))
+      (setq resize (with-current-buffer buffer temp-buffer-resize-mode))
+      ;; Unrecord buffer.
+      (unrecord-buffer buffer)
+      (unrecord-window-buffer window buffer)
+      ;; Display buffer stored in the quit-restore parameter.
+      (set-window-dedicated-p window nil)
+      (set-window-buffer window (nth 0 quit-restore))
+      (set-window-start window (nth 1 quit-restore))
+      (set-window-point window (nth 2 quit-restore))
+      (when (and resize (/= (nth 4 quit-restore) (window-total-size window)))
+        (resize-window
+         window (- (nth 4 quit-restore) (window-total-size window))))
+      ;; Reset the quit-restore parameter.
+      (set-window-parameter window 'quit-restore nil)
+      (when (window-live-p (nth 5 quit-restore))
+        (select-window (nth 5 quit-restore))))
+     (t
+      ;; Otherwise, show another buffer in WINDOW and reset the
+      ;; quit-restore parameter.
+      (set-window-parameter window 'quit-restore nil)
+      (unrecord-buffer buffer)
+      (switch-to-prev-buffer window 'bury-or-kill)))
+
+    ;; Kill WINDOW's old-buffer if requested
+    (when kill (kill-buffer buffer))
+    nil))
 
 ;;; Splitting windows.
 (defsubst window-split-min-size (&optional horizontal)
@@ -2569,22 +3149,14 @@ window."
            (<= (window-start new-window) old-point)
            (set-window-point new-window old-point)
            (select-window new-window)))
-    (split-window-save-restore-data new-window old-window)))
+    ;; Always copy quit-restore parameter in interactive use.
+    (let ((quit-restore (window-parameter old-window 'quit-restore)))
+      (when quit-restore
+        (set-window-parameter new-window 'quit-restore quit-restore)))
+    new-window))
 
 (defalias 'split-window-vertically 'split-window-above-each-other)
 
-;; This is to avoid compiler warnings.
-(defvar view-return-to-alist)
-
-(defun split-window-save-restore-data (new-window old-window)
-  (with-current-buffer (window-buffer)
-    (when view-mode
-      (let ((old-info (assq old-window view-return-to-alist)))
-        (when old-info
-          (push (cons new-window (cons (car (cdr old-info)) t))
-                view-return-to-alist))))
-    new-window))
-
 (defun split-window-side-by-side (&optional size)
   "Split selected window into two windows side by side.
 The selected window becomes the left one and gets SIZE columns.
@@ -2603,7 +3175,12 @@ The selected window remains selected.  Return the new window."
     (when (and size (< size 0) (< (- size) window-min-width))
       ;; `split-window' would not signal an error here.
       (error "Size of new window too small"))
-    (split-window-save-restore-data (split-window nil size t) old-window)))
+    (setq new-window (split-window nil size t))
+    ;; Always copy quit-restore parameter in interactive use.
+    (let ((quit-restore (window-parameter old-window 'quit-restore)))
+      (when quit-restore
+        (set-window-parameter new-window 'quit-restore quit-restore)))
+    new-window))
 
 (defalias 'split-window-horizontally 'split-window-side-by-side)
 
@@ -3545,6 +4122,29 @@ consider all visible or iconified frames on the current terminal."
       (window--even-window-heights window-to-use)
       (window--display-buffer-2 buffer window-to-use)))))
 
+(defun display-buffer-other-frame (buffer)
+  "Display buffer BUFFER in another frame.
+This uses the function `display-buffer' as a subroutine; see
+its documentation for additional customization information."
+  (interactive "BDisplay buffer in other frame: ")
+  (let ((pop-up-frames t)
+        same-window-buffer-names same-window-regexps
+        ;;(old-window (selected-window))
+        new-window)
+    (setq new-window (display-buffer buffer t))
+    ;; This may have been here in order to prevent the new frame from hiding
+    ;; the old frame.  But it does more harm than good.
+    ;; Maybe we should call `raise-window' on the old-frame instead?  --Stef
+    ;;(lower-frame (window-frame new-window))
+
+    ;; This may have been here in order to make sure the old-frame gets the
+    ;; focus.  But not only can it cause an annoying flicker, with some
+    ;; window-managers it just makes the window invisible, with no easy
+    ;; way to recover it.  --Stef
+    ;;(make-frame-invisible (window-frame old-window))
+    ;;(make-frame-visible (window-frame old-window))
+    ))
+
 (defun pop-to-buffer (buffer-or-name &optional other-window norecord)
   "Select buffer BUFFER-OR-NAME in some window, preferably a different one.
 BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
@@ -3587,6 +4187,130 @@ at the front of the list of recently selected ones."
       ;; input focus and is risen.
       (select-frame-set-input-focus new-frame))
     buffer))
+
+(defun read-buffer-to-switch (prompt)
+  "Read the name of a buffer to switch to, prompting with PROMPT.
+Return the neame of the buffer as a string.
+
+This function is intended for the `switch-to-buffer' family of
+commands since these need to omit the name of the current buffer
+from the list of completions and default values."
+  (let ((rbts-completion-table (internal-complete-buffer-except)))
+    (minibuffer-with-setup-hook
+        (lambda ()
+          (setq minibuffer-completion-table rbts-completion-table)
+          ;; Since rbts-completion-table is built dynamically, we
+          ;; can't just add it to the default value of
+          ;; icomplete-with-completion-tables, so we add it
+          ;; here manually.
+          (if (and (boundp 'icomplete-with-completion-tables)
+                   (listp icomplete-with-completion-tables))
+              (set (make-local-variable 'icomplete-with-completion-tables)
+                   (cons rbts-completion-table
+                         icomplete-with-completion-tables))))
+      (read-buffer prompt (other-buffer (current-buffer))
+                   (confirm-nonexistent-file-or-buffer)))))
+
+(defun normalize-buffer-to-switch-to (buffer-or-name)
+  "Normalize BUFFER-OR-NAME argument of buffer switching functions.
+If BUFFER-OR-NAME is nil, return the buffer returned by
+`other-buffer'.  Else, if a buffer specified by BUFFER-OR-NAME
+exists, return that buffer.  If no such buffer exists, create a
+buffer with the name BUFFER-OR-NAME and return that buffer."
+  (if buffer-or-name
+      (or (get-buffer buffer-or-name)
+          (let ((buffer (get-buffer-create buffer-or-name)))
+            (set-buffer-major-mode buffer)
+            buffer))
+    (other-buffer)))
+
+(defun switch-to-buffer (buffer-or-name &optional norecord)
+  "Switch to buffer BUFFER-OR-NAME in the selected window.
+If called interactively, prompt for the buffer name using the
+minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
+determines whether to request confirmation before creating a new
+buffer.
+
+BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
+nil.  If BUFFER-OR-NAME is a string that does not identify an
+existing buffer, create a buffer with that name.  If
+BUFFER-OR-NAME is nil, switch to the buffer returned by
+`other-buffer'.
+
+Optional argument NORECORD non-nil means do not put the buffer
+specified by BUFFER-OR-NAME at the front of the buffer list and
+do not make the window displaying it the most recently selected
+one.  Return the buffer switched to.
+
+This function is intended for interactive use only.  Lisp
+functions should call `pop-to-buffer-same-window' instead."
+  (interactive
+   (list (read-buffer-to-switch "Switch to buffer: ")))
+  (let ((buffer (normalize-buffer-to-switch-to buffer-or-name)))
+    (if (and (or (window-minibuffer-p) (eq (window-dedicated-p) t))
+             (not (eq buffer (window-buffer))))
+        ;; Cannot switch to another buffer in a minibuffer or strongly
+        ;; dedicated window that does not show the buffer already.  Call
+        ;; `pop-to-buffer' instead.
+        (pop-to-buffer buffer nil norecord)
+      (unless (eq buffer (window-buffer))
+        ;; I'm not sure why we should NOT call `set-window-buffer' here,
+        ;; but let's keep things as they are (otherwise we could always
+        ;; call `pop-to-buffer-same-window' here).
+        (set-window-buffer nil buffer))
+      (unless norecord
+        (select-window (selected-window)))
+      (set-buffer buffer))))
+
+(defun switch-to-buffer-other-window (buffer-or-name &optional norecord)
+  "Select the buffer specified by BUFFER-OR-NAME in another window.
+BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
+nil.  Return the buffer switched to.
+
+If called interactively, prompt for the buffer name using the
+minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
+determines whether to request confirmation before creating a new
+buffer.
+
+If BUFFER-OR-NAME is a string and does not identify an existing
+buffer, create a new buffer with that name.  If BUFFER-OR-NAME is
+nil, switch to the buffer returned by `other-buffer'.
+
+Optional second argument NORECORD non-nil means do not put this
+buffer at the front of the list of recently selected ones.
+
+This uses the function `display-buffer' as a subroutine; see its
+documentation for additional customization information."
+  (interactive
+   (list (read-buffer-to-switch "Switch to buffer in other window: ")))
+  (let ((pop-up-windows t)
+        same-window-buffer-names same-window-regexps)
+    (pop-to-buffer buffer-or-name t norecord)))
+
+(defun switch-to-buffer-other-frame (buffer-or-name &optional norecord)
+  "Switch to buffer BUFFER-OR-NAME in another frame.
+BUFFER-OR-NAME may be a buffer, a string \(a buffer name), or
+nil.  Return the buffer switched to.
+
+If called interactively, prompt for the buffer name using the
+minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
+determines whether to request confirmation before creating a new
+buffer.
+
+If BUFFER-OR-NAME is a string and does not identify an existing
+buffer, create a new buffer with that name.  If BUFFER-OR-NAME is
+nil, switch to the buffer returned by `other-buffer'.
+
+Optional second arg NORECORD non-nil means do not put this
+buffer at the front of the list of recently selected ones.
+
+This uses the function `display-buffer' as a subroutine; see its
+documentation for additional customization information."
+  (interactive
+   (list (read-buffer-to-switch "Switch to buffer in other frame: ")))
+  (let ((pop-up-frames t)
+        same-window-buffer-names same-window-regexps)
+    (pop-to-buffer buffer-or-name t norecord)))
 
 (defun set-window-text-height (window height)
   "Set the height in lines of the text display area of WINDOW to HEIGHT.
@@ -4258,21 +4982,6 @@ active.  This function is run by `mouse-autoselect-window-timer'."
         (run-hooks 'mouse-leave-buffer-hook))
       (select-window window))))
 
-(defun delete-other-windows-vertically (&optional window)
-  "Delete the windows in the same column with WINDOW, but not WINDOW itself.
-This may be a useful alternative binding for \\[delete-other-windows]
- if you often split windows horizontally."
-  (interactive)
-  (let* ((window (or window (selected-window)))
-         (edges (window-edges window))
-         (w window) delenda)
-    (while (not (eq (setq w (next-window w 1)) window))
-      (let ((e (window-edges w)))
-        (when (and (= (car e) (car edges))
-                   (= (caddr e) (caddr edges)))
-          (push w delenda))))
-    (mapc 'delete-window delenda)))
-
 (defun truncated-partial-width-window-p (&optional window)
   "Return non-nil if lines in WINDOW are specifically truncated due to its width.
 WINDOW defaults to the selected window.
@@ -4293,6 +5002,7 @@ Otherwise, consult the value of `truncate-partial-width-windows'
 (define-key ctl-x-map "1" 'delete-other-windows)
 (define-key ctl-x-map "2" 'split-window-above-each-other)
 (define-key ctl-x-map "3" 'split-window-side-by-side)
+(define-key ctl-x-map "o" 'other-window)
 (define-key ctl-x-map "^" 'enlarge-window)
 (define-key ctl-x-map "}" 'enlarge-window-horizontally)
 (define-key ctl-x-map "{" 'shrink-window-horizontally)