Merge from trunk.

16 files changed, 1642 insertions, 255 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 2341c0c973a..1ac216dfbe2 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,74 @@
+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.
+        (adjust-window-trailing-edge, enlarge-window, shrink-window):
+        Move here from window.c.
+        (maximize-window, minimize-window): New functions.
+        (delete-window, delete-other-windows, split-window): Move here
+        from window.c.
+        (window-split-min-size): New function.
+        (split-window-keep-point): Mention split-window-above-each-other
+        instead of split-window-vertically.
+        (split-window-above-each-other, split-window-vertically): Rename
+        split-window-vertically to split-window-above-each-other and
+        provide defalias for old definition.
+        (split-window-side-by-side, split-window-horizontally): Rename
+        split-window-horizontally to split-window-side-by-side and provide
+        defalias for the old definition.
+        (ctl-x-map): Move bindings for delete-window,
+        delete-other-windows and enlarge-window here from window.c.
+        Replace bindings for split-window-vertically and
+        split-window-horizontally by bindings for
+        split-window-above-each-other and split-window-side-by-side.
+
+        * cus-start.el (all): Remove entries for window-min-height and
+        window-min-width.  Add entries for window-splits and
+        window-nest.
+
+2011-06-09  Glenn Morris  <rgm@gnu.org>
+
+        * calendar/appt.el (appt-mode-line): New function.
+        (appt-check, appt-disp-window): Use it.
+
+        * files.el (hack-one-local-variable-eval-safep):
+        Allow minor-modes with explicit +/-1 arguments.
+
+2011-06-09  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * term/xterm.el (xterm): Add defgroup.
+        (xterm-extra-capabilities): Add defcustom to supply known xterm
+        capabilities, skip querying them, or query them (default).
+        (terminal-init-xterm): Use it.
+        (terminal-init-xterm-modify-other-keys): New function to set up
+        modifyOtherKeys support to simplify `terminal-init-xterm'.
+
+2011-06-09  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.el (resize-window-reset, resize-window-reset-1)
+        (resize-subwindows-skip-p, resize-subwindows-normal)
+        (resize-subwindows, resize-other-windows, resize-this-window)
+        (resize-root-window, resize-root-window-vertically)
+        (window-deletable-p, window-or-subwindow-p)
+        (frame-root-window-p): New functions.
+
+2011-06-09  Glenn Morris  <rgm@gnu.org>
+
+        * net/ange-ftp.el (ange-ftp-switches-ok): New function.
+        (ange-ftp-get-files): Use it.
+
+2011-06-09  Alexander Klimov  <alserkli@inbox.ru>  (tiny change)
+
+        * mail/sendmail.el (mail-recover-1, mail-recover):
+        * files.el (recover-file, recover-session):
+        Handle dired-listing-switches not being just a single short option.
+
+2011-06-09  Glenn Morris  <rgm@gnu.org>
+
+        * calendar/appt.el (appt-display-message, appt-disp-window):
+        Handle lists of appointments.
+
 2011-06-08  Martin Rudalics  <rudalics@gmx.at>
 
         * window.el (one-window-p): Move down in code.  Rewrite
diff --git a/lisp/calendar/appt.el b/lisp/calendar/appt.el
index 5089df1d8ed..6148babfd11 100644
--- a/lisp/calendar/appt.el
+++ b/lisp/calendar/appt.el
@@ -214,21 +214,60 @@ If this is non-nil, appointment checking is active.")
 (defun appt-display-message (string mins)
   "Display a reminder about an appointment.
 The string STRING describes the appointment, due in integer MINS minutes.
-The format of the visible reminder is controlled by `appt-display-format'.
-The variable `appt-audible' controls the audible reminder."
+The arguments may also be lists, where each element relates to a
+separate appointment.  The variable `appt-display-format' controls
+the format of the visible reminder.  If `appt-audible' is non-nil,
+also calls `beep' for an audible reminder."
   (if appt-audible (beep 1))
+  ;; Backwards compatibility: avoid passing lists to a-d-w-f if not necessary.
+  (and (listp mins)
+       (= (length mins) 1)
+       (setq mins (car mins)
+             string (car string)))
   (cond ((eq appt-display-format 'window)
-         (funcall appt-disp-window-function
-                  (number-to-string mins)
-                  ;; TODO - use calendar-month-abbrev-array rather than %b?
-                  (format-time-string "%a %b %e " (current-time))
-                  string)
+         ;; TODO use calendar-month-abbrev-array rather than %b?
+         (let ((time (format-time-string "%a %b %e " (current-time)))
+               err)
+           (condition-case err
+               (funcall appt-disp-window-function
+                        (if (listp mins)
+                            (mapcar 'number-to-string mins)
+                          (number-to-string mins))
+                        time string)
+             (wrong-type-argument
+              (if (not (listp mins))
+                  (signal (car err) (cdr err))
+                (message "Argtype error in `appt-disp-window-function' - \
+update it for multiple appts?")
+                ;; Fallback to just displaying the first appt, as we used to.
+                (funcall appt-disp-window-function
+                         (number-to-string (car mins)) time
+                         (car string))))))
          (run-at-time (format "%d sec" appt-display-duration)
                       nil
                       appt-delete-window-function))
         ((eq appt-display-format 'echo)
-         (message "%s" string))))
-
+         (message "%s" (if (listp string)
+                           (mapconcat 'identity string "\n")
+                         string)))))
+
+(defun appt-mode-line (min-to-app &optional abbrev)
+  "Return an appointment string suitable for use in the mode-line.
+MIN-TO-APP is a list of minutes, as strings.
+If ABBREV is non-nil, abbreviates some text."
+  ;; All this silliness is just to make the formatting slightly nicer.
+  (let* ((multiple (> (length min-to-app) 1))
+         (imin (if (or (not multiple)
+                       (not (delete (car min-to-app) min-to-app)))
+                   (car min-to-app))))
+    (format "%s%s %s"
+            (if abbrev "App't" "Appointment")
+            (if multiple "s" "")
+            (if (equal imin "0") "now"
+              (format "in %s %s"
+                      (or imin (mapconcat 'identity min-to-app ","))
+                      (if abbrev "min."
+                        (format "minute%s" (if (equal imin "1") "" "s"))))))))
 
 (defun appt-check (&optional force)
   "Check for an appointment and update any reminder display.
@@ -351,9 +390,8 @@ displayed in a window:
           (when appt-display-mode-line
             (setq appt-mode-string
                   (concat " " (propertize
-                               (format "App't %s"
-                                       (if (zerop min-to-app) "NOW"
-                                         (format "in %s min." min-to-app)))
+                               (appt-mode-line (mapcar 'number-to-string
+                                                       (list min-to-app)) t)
                                'face 'mode-line-emphasis))))
           ;; When an appointment is reached, delete it from the
           ;; list.  Reset the count to 0 in case we display another
@@ -373,8 +411,10 @@ displayed in a window:
 
 (defun appt-disp-window (min-to-app new-time appt-msg)
   "Display appointment due in MIN-TO-APP (a string) minutes.
-NEW-TIME is a string giving the date.  Displays the appointment
-message APPT-MSG in a separate buffer."
+NEW-TIME is a string giving the current date.
+Displays the appointment message APPT-MSG in a separate buffer.
+The arguments may also be lists, where each element relates to a
+separate appointment."
   (let ((this-window (selected-window))
         (appt-disp-buf (get-buffer-create appt-buffer-name)))
     ;; Make sure we're not in the minibuffer before splitting the window.
@@ -395,17 +435,29 @@ message APPT-MSG in a separate buffer."
         (when (>= (window-height) (* 2 window-min-height))
           (select-window (split-window))))
       (switch-to-buffer appt-disp-buf))
+    (or (listp min-to-app)
+        (setq min-to-app (list min-to-app)
+              appt-msg (list appt-msg)))
+    ;; I don't really see the point of the new-time argument.
+    ;; It repeatedly reminds you of the date?
+    ;; It would make more sense if it was eg the time of the appointment.
+    ;; Let's allow it to be a list or not independent of the other elements.
+    (or (listp new-time)
+        (setq new-time (list new-time)))
     ;; FIXME Link to diary entry?
     (calendar-set-mode-line
-     (format " Appointment %s. %s "
-             (if (string-equal "0" min-to-app) "now"
-               (format "in %s minute%s" min-to-app
-                       (if (string-equal "1" min-to-app) "" "s")))
-             new-time))
+     (format " %s. %s" (appt-mode-line min-to-app)
+             (mapconcat 'identity new-time ", ")))
     (setq buffer-read-only nil
           buffer-undo-list t)
     (erase-buffer)
-    (insert appt-msg)
+    ;; If we have appointments at different times, prepend the times.
+    (if (or (= 1 (length min-to-app))
+            (not (delete (car min-to-app) min-to-app)))
+        (insert (mapconcat 'identity appt-msg "\n"))
+      (dotimes (i (length appt-msg))
+        (insert (format "%s%sm: %s" (if (> i 0) "\n" "")
+                        (nth i min-to-app) (nth i appt-msg)))))
     (shrink-window-if-larger-than-buffer (get-buffer-window appt-disp-buf t))
     (set-buffer-modified-p nil)
     (setq buffer-read-only t)
diff --git a/lisp/cus-start.el b/lisp/cus-start.el
index 6113a4321c5..389716b35b9 100644
--- a/lisp/cus-start.el
+++ b/lisp/cus-start.el
@@ -388,19 +388,18 @@ since it could result in memory overflow and make Emacs crash."
              ;; window.c
              (temp-buffer-show-function windows (choice (const nil) function))
              (next-screen-context-lines windows integer)
-             (window-min-height windows integer)
-             (window-min-width windows integer)
              (scroll-preserve-screen-position
               windows (choice
                        (const :tag "Off (nil)" :value nil)
                        (const :tag "Full screen (t)" :value t)
                        (other :tag "Always" 1)) "22.1")
-             (recenter-redisplay windows
-                                 (choice
-                                  (const :tag "Never (nil)" :value nil)
-                                  (const :tag "Only on ttys" :value tty)
-                                  (other :tag "Always" t))
-                                 "23.1")
+             (recenter-redisplay
+              windows (choice
+                       (const :tag "Never (nil)" :value nil)
+                       (const :tag "Only on ttys" :value tty)
+                       (other :tag "Always" t)) "23.1")
+             (window-splits windows boolean "24.1")
+             (window-nest windows boolean "24.1")
              ;; xdisp.c
              (show-trailing-whitespace whitespace-faces boolean nil
                                        :safe booleanp)
diff --git a/lisp/doc-view.el b/lisp/doc-view.el
index 06c3b70a3a6..666c6a8b034 100644
--- a/lisp/doc-view.el
+++ b/lisp/doc-view.el
@@ -1550,7 +1550,7 @@ See the command `doc-view-mode' for more information on this mode."
 (provide 'doc-view)
 
 ;; Local Variables:
-;; eval: (outline-minor-mode)
+;; eval: (outline-minor-mode 1)
 ;; End:
 
 ;;; doc-view.el ends here
diff --git a/lisp/files.el b/lisp/files.el
index cc1ad23925d..317153dc9bf 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -2635,7 +2635,7 @@ we don't actually set it to the same mode the buffer already has."
   ;; Look for -*-MODENAME-*- or -*- ... mode: MODENAME; ... -*-
   (let (end done mode modes)
     ;; Once we drop the deprecated feature where mode: is also allowed to
-    ;; specify minor-modes (ie, there can be more than one "mode:), we can
+    ;; specify minor-modes (ie, there can be more than one "mode:"), we can
     ;; remove this section and just let (hack-local-variables t) handle it.
     ;; Find a -*- mode tag.
     (save-excursion
@@ -3367,7 +3367,7 @@ It is dangerous if either of these conditions are met:
       (and (symbolp (car exp))
            ;; Allow (minor)-modes calls with no arguments.
            ;; This obsoletes the use of "mode:" for such things.  (Bug#8613)
-           (or (and (null (cdr exp))
+           (or (and (member (cdr exp) '(nil (1) (-1)))
                     (string-match "-mode\\'" (symbol-name (car exp))))
                (let ((prop (get (car exp) 'safe-local-eval-function)))
                  (cond ((eq prop t)
@@ -5256,7 +5256,7 @@ non-nil, it is called instead of rereading visited file contents."
                (save-excursion
                  (let ((switches dired-listing-switches))
                    (if (file-symlink-p file)
-                       (setq switches (concat switches "L")))
+                       (setq switches (concat switches " -L")))
                    (set-buffer standard-output)
                    ;; Use insert-directory-safely, not insert-directory,
                    ;; because these files might not exist.  In particular,
@@ -5299,7 +5299,7 @@ Then you'll be asked about a number of files to recover."
       (error "No previous sessions to recover")))
   (let ((ls-lisp-support-shell-wildcards t))
     (dired (concat auto-save-list-file-prefix "*")
-           (concat dired-listing-switches "t")))
+           (concat dired-listing-switches " -t")))
   (save-excursion
     (goto-char (point-min))
     (or (looking-at " Move to the session you want to recover,")
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index ff3eb98bb97..2bfaf32f958 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,24 @@
+2011-06-10  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-group.el (gnus-group-update-group): Add new argument
+        `info-unchanged' that stops updating dribble buffer.
+
+        * gnus-start.el (gnus-dribble-enter): Add new argument `regexp' that
+        deletes lines matching to it in dribble buffer.
+
+        * gnus-agent.el (gnus-agent-fetch-group-1):
+        * gnus-group.el (gnus-group-update-group-line, gnus-group-make-group):
+        * gnus-srvr.el (gnus-server-update-server, gnus-server-set-info):
+        * gnus-start.el (gnus-group-change-level):
+        * gnus-sum.el (gnus-summary-move-article): Delete old dribble entry.
+
+        * gnus-sum.el (gnus-summary-update-info): Don't update dribble buffer
+        if newsgroup info is not changed.
+
+        * gnus-group.el (gnus-group-get-new-news-this-group):
+        * gnus-sum.el (gnus-summary-read-group-1, gnus-summary-exit-no-update):
+        Don't update dribble buffer.
+
 2011-06-01  Teodor Zlatanov  <tzz@lifelogs.com>
 
         * gnus-registry.el (gnus-registry-remove-ignored): New function to
diff --git a/lisp/gnus/gnus-agent.el b/lisp/gnus/gnus-agent.el
index b4f0dc38e7e..424c55c40f5 100644
--- a/lisp/gnus/gnus-agent.el
+++ b/lisp/gnus/gnus-agent.el
@@ -2614,7 +2614,9 @@ modified) original contents, they are first saved to their own file."
                     (gnus-dribble-enter
                      (concat "(gnus-group-set-info '"
                              (gnus-prin1-to-string info)
-                             ")"))))))))))))
+                             ")")
+                     (concat "^(gnus-group-set-info '(\""
+                             (regexp-quote group) "\""))))))))))))
 
 ;;;
 ;;; Agent Category Mode
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index 4c474b0aa23..518f215a7ba 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -1437,7 +1437,8 @@ if it is a string, only list groups matching REGEXP."
            (gnus-dribble-enter
             (concat "(gnus-group-set-info '"
                     (gnus-prin1-to-string (nth 2 entry))
-                    ")")))
+                    ")")
+            (concat "^(gnus-group-set-info '(\"" (regexp-quote group) "\"")))
       (setq gnus-group-indentation (gnus-group-group-indentation))
       (gnus-delete-line)
       (gnus-group-insert-group-line-info group)
@@ -1685,10 +1686,11 @@ and ends at END."
                                      (gnus-active group))
   (gnus-group-update-group group))
 
-(defun gnus-group-update-group (group &optional visible-only)
+(defun gnus-group-update-group (group &optional visible-only
+                                      info-unchanged)
   "Update all lines where GROUP appear.
 If VISIBLE-ONLY is non-nil, the group won't be displayed if it isn't
-already."
+already.  If INFO-UNCHANGED is non-nil, dribble buffer is not updated."
   (with-current-buffer gnus-group-buffer
     (save-excursion
       ;; The buffer may be narrowed.
@@ -1697,14 +1699,17 @@ already."
         (let ((ident (gnus-intern-safe group gnus-active-hashtb))
               (loc (point-min))
               found buffer-read-only)
-          ;; Enter the current status into the dribble buffer.
-          (let ((entry (gnus-group-entry group)))
-            (when (and entry
-                       (not (gnus-ephemeral-group-p group)))
-              (gnus-dribble-enter
-               (concat "(gnus-group-set-info '"
-                       (gnus-prin1-to-string (nth 2 entry))
-                       ")"))))
+          (unless info-unchanged
+            ;; Enter the current status into the dribble buffer.
+            (let ((entry (gnus-group-entry group)))
+              (when (and entry
+                         (not (gnus-ephemeral-group-p group)))
+                (gnus-dribble-enter
+                 (concat "(gnus-group-set-info '"
+                         (gnus-prin1-to-string (nth 2 entry))
+                         ")")
+                 (concat "^(gnus-group-set-info '(\""
+                         (regexp-quote group) "\"")))))
           ;; Find all group instances.  If topics are in use, each group
           ;; may be listed in more than once.
           (while (setq loc (text-property-any
@@ -2715,7 +2720,8 @@ server."
     (unless (gnus-ephemeral-group-p name)
       (gnus-dribble-enter
        (concat "(gnus-group-set-info '"
-               (gnus-prin1-to-string (cdr info)) ")")))
+               (gnus-prin1-to-string (cdr info)) ")")
+       (concat "^(gnus-group-set-info '(\"" (regexp-quote name) "\"")))
     ;; Insert the line.
     (gnus-group-insert-group-line-info nname)
     (forward-line -1)
@@ -4032,7 +4038,7 @@ If DONT-SCAN is non-nil, scan non-activated groups as well."
             (when gnus-agent
               (gnus-agent-save-group-info
                method (gnus-group-real-name group) active))
-            (gnus-group-update-group group))
+            (gnus-group-update-group group nil t))
         (if (eq (gnus-server-status (gnus-find-method-for-group group))
                 'denied)
             (gnus-error 3 "Server denied access")
diff --git a/lisp/gnus/gnus-srvr.el b/lisp/gnus/gnus-srvr.el
index 9bf2d37a3e4..ec98b2ff749 100644
--- a/lisp/gnus/gnus-srvr.el
+++ b/lisp/gnus/gnus-srvr.el
@@ -362,7 +362,8 @@ The following commands are available:
       (when entry
         (gnus-dribble-enter
          (concat "(gnus-server-set-info \"" server "\" '"
-                 (gnus-prin1-to-string (cdr entry)) ")\n")))
+                 (gnus-prin1-to-string (cdr entry)) ")\n")
+         (concat "^(gnus-server-set-info \"" (regexp-quote server) "\"")))
       (when (or entry oentry)
         ;; Buffer may be narrowed.
         (save-restriction
@@ -381,7 +382,8 @@ The following commands are available:
   (when (and server info)
     (gnus-dribble-enter
      (concat "(gnus-server-set-info \"" server "\" '"
-             (gnus-prin1-to-string info) ")"))
+             (gnus-prin1-to-string info) ")")
+     (concat "^(gnus-server-set-info \"" (regexp-quote server) "\""))
     (let* ((server (nth 1 info))
            (entry (assoc server gnus-server-alist))
            (cached (assoc server gnus-server-method-cache)))
diff --git a/lisp/gnus/gnus-start.el b/lisp/gnus/gnus-start.el
index 719d0c9e472..aa9af012a1c 100644
--- a/lisp/gnus/gnus-start.el
+++ b/lisp/gnus/gnus-start.el
@@ -832,13 +832,22 @@ prompt the user for the name of an NNTP server to use."
      gnus-current-startup-file)
    "-dribble"))
 
-(defun gnus-dribble-enter (string)
-  "Enter STRING into the dribble buffer."
+(defun gnus-dribble-enter (string &optional regexp)
+  "Enter STRING into the dribble buffer.
+If REGEXP is given, lines that match it will be deleted."
   (when (and (not gnus-dribble-ignore)
              gnus-dribble-buffer
              (buffer-name gnus-dribble-buffer))
     (let ((obuf (current-buffer)))
       (set-buffer gnus-dribble-buffer)
+      (when regexp
+        (goto-char (point-min))
+        (let (end)
+          (while (re-search-forward regexp nil t)
+            (unless (bolp) (forward-line 1))
+            (setq end (point))
+            (goto-char (match-beginning 0))
+            (delete-region (point-at-bol) end))))
       (goto-char (point-max))
       (insert string "\n")
       ;; This has been commented by Josh Huber <huber@alum.wpi.edu>
@@ -1354,8 +1363,8 @@ for new groups, and subscribe the new groups as zombies."
           (when (cdr entry)
             (setcdr (gnus-group-entry (caadr entry)) entry))
           (gnus-dribble-enter
-           (format
-            "(gnus-group-set-info '%S)" info)))))
+           (format "(gnus-group-set-info '%S)" info)
+           (concat "^(gnus-group-set-info '(\"" (regexp-quote group) "\"")))))
       (when gnus-group-change-level-function
         (funcall gnus-group-change-level-function
                  group level oldlevel previous)))))
diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 1c4382b24a6..f974d386acb 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -4098,7 +4098,7 @@ If NO-DISPLAY, don't generate a summary buffer."
         (setq gnus-newsgroup-prepared t)
         (gnus-run-hooks 'gnus-summary-prepared-hook)
         (unless (gnus-ephemeral-group-p group)
-          (gnus-group-update-group group))
+          (gnus-group-update-group group nil t))
         t)))))
 
 (defun gnus-summary-auto-select-subject ()
@@ -7140,7 +7140,12 @@ The prefix argument ALL means to select all articles."
                  t)))
         (unless (listp (cdr gnus-newsgroup-killed))
           (setq gnus-newsgroup-killed (list gnus-newsgroup-killed)))
-        (let ((headers gnus-newsgroup-headers))
+        (let ((headers gnus-newsgroup-headers)
+              (ephemeral-p (gnus-ephemeral-group-p group))
+              info)
+          (unless ephemeral-p
+            (setq info (copy-sequence (gnus-get-info group))
+                  info (delq (gnus-info-params info) info)))
           ;; Set the new ranges of read articles.
           (with-current-buffer gnus-group-buffer
             (gnus-undo-force-boundary))
@@ -7160,8 +7165,12 @@ The prefix argument ALL means to select all articles."
             (gnus-mark-xrefs-as-read group headers gnus-newsgroup-unreads))
           ;; Do not switch windows but change the buffer to work.
           (set-buffer gnus-group-buffer)
-          (unless (gnus-ephemeral-group-p group)
-            (gnus-group-update-group group)))))))
+          (unless ephemeral-p
+            (gnus-group-update-group
+             group nil
+             (equal info
+                    (setq info (copy-sequence (gnus-get-info group))
+                          info (delq (gnus-info-params info) info))))))))))
 
 (defun gnus-summary-save-newsrc (&optional force)
   "Save the current number of read/marked articles in the dribble buffer.
@@ -7314,7 +7323,7 @@ If FORCE (the prefix), also save the .newsrc file(s)."
       ;; Clear the current group name.
       (setq gnus-newsgroup-name nil)
       (unless (gnus-ephemeral-group-p group)
-        (gnus-group-update-group group))
+        (gnus-group-update-group group nil t))
       (when (equal (gnus-group-group-name) group)
         (gnus-group-next-unread-group 1))
       (when quit-config
@@ -9994,7 +10003,9 @@ ACTION can be either `move' (the default), `crosspost' or `copy'."
               (gnus-dribble-enter
                (concat "(gnus-group-set-info '"
                        (gnus-prin1-to-string (gnus-get-info to-group))
-                       ")"))))
+                       ")")
+               (concat "^(gnus-group-set-info '(\""
+                       (regexp-quote to-group) "\""))))
 
           ;; Update the Xref header in this article to point to
           ;; the new crossposted article we have just created.
diff --git a/lisp/mail/sendmail.el b/lisp/mail/sendmail.el
index 2c5fa014a94..f4ef9b91903 100644
--- a/lisp/mail/sendmail.el
+++ b/lisp/mail/sendmail.el
@@ -1801,7 +1801,7 @@ The seventh argument ACTIONS is a list of actions to take
       ;; unbound on exit from the let.
       (require 'dired)
       (let ((dired-trivial-filenames t))
-        (dired-other-window wildcard (concat dired-listing-switches "t")))
+        (dired-other-window wildcard (concat dired-listing-switches " -t")))
       (rename-buffer "*Auto-saved Drafts*" t)
       (save-excursion
         (goto-char (point-min))
@@ -1881,7 +1881,7 @@ you can move to one of them and type C-c C-c to recover that one."
                   ;; `ls' is not a standard program (it will use
                   ;; ls-lisp instead).
                   (dired-noselect file-name
-                                  (concat dired-listing-switches "t"))))
+                                  (concat dired-listing-switches " -t"))))
              (save-selected-window
                (select-window (display-buffer dispbuf t))
                (goto-char (point-min))
diff --git a/lisp/net/ange-ftp.el b/lisp/net/ange-ftp.el
index b1d8279e93f..0493ead7bbf 100644
--- a/lisp/net/ange-ftp.el
+++ b/lisp/net/ange-ftp.el
@@ -2806,6 +2806,19 @@ match subdirectories as well.")
   (and files (puthash (file-name-as-directory directory)
                       files ange-ftp-files-hashtable)))
 
+(defun ange-ftp-switches-ok (switches)
+  "Return SWITCHES (a string) if suitable for our use."
+  (and (stringp switches)
+       ;; We allow the A switch, which lists all files except "." and
+       ;; "..".  This is OK because we manually insert these entries
+       ;; in the hash table.
+       (string-match
+        "--\\(almost-\\)?all\\>\\|\\(\\`\\| \\)-[[:alpha:]]*[aA]" switches)
+       (string-match "\\(\\`\\| \\)-[[:alpha:]]*l" switches)
+       (not (string-match
+             "--recursive\\>\\|\\(\\`\\| \\)-[[:alpha:]]*R" switches))
+       switches))
+
 (defun ange-ftp-get-files (directory &optional no-error)
   "Given a DIRECTORY, return a hashtable of file entries.
 This will give an error or return nil, depending on the value of
@@ -2817,30 +2830,12 @@ NO-ERROR, if a listing for DIRECTORY cannot be obtained."
                           ;; This is an efficiency hack. We try to
                           ;; anticipate what sort of listing dired
                           ;; might want, and cache just such a listing.
-                          (if (and (boundp 'dired-actual-switches)
-                                   (stringp dired-actual-switches)
-                                   ;; We allow the A switch, which lists
-                                   ;; all files except "." and "..".
-                                   ;; This is OK because we manually
-                                   ;; insert these entries
-                                   ;; in the hash table.
-                                   (string-match
-                                    "[aA]" dired-actual-switches)
-                                   (string-match
-                                    "l" dired-actual-switches)
-                                   (not (string-match
-                                         "R" dired-actual-switches)))
-                              dired-actual-switches
-                            (if (and (boundp 'dired-listing-switches)
-                                     (stringp dired-listing-switches)
-                                     (string-match
-                                      "[aA]" dired-listing-switches)
-                                     (string-match
-                                      "l" dired-listing-switches)
-                                     (not (string-match
-                                           "R" dired-listing-switches)))
-                                dired-listing-switches
-                              "-al"))
+                          (or (and (boundp 'dired-actual-switches)
+                                   (ange-ftp-switches-ok dired-actual-switches))
+                              (and (boundp 'dired-listing-switches)
+                                   (ange-ftp-switches-ok
+                                    dired-listing-switches))
+                              "-al")
                           t no-error)
              (gethash directory ange-ftp-files-hashtable)))))
 
diff --git a/lisp/net/soap-client.el b/lisp/net/soap-client.el
index 9862332bf3f..b7b0b61f4e1 100644
--- a/lisp/net/soap-client.el
+++ b/lisp/net/soap-client.el
@@ -1745,7 +1745,7 @@ operations in a WSDL document."
 
 
 ;;; Local Variables:
-;;; eval: (outline-minor-mode)
+;;; eval: (outline-minor-mode 1)
 ;;; outline-regexp: ";;;;+"
 ;;; End:
 
diff --git a/lisp/term/xterm.el b/lisp/term/xterm.el
index 0db33b5a4de..c2b870bd535 100644
--- a/lisp/term/xterm.el
+++ b/lisp/term/xterm.el
@@ -24,6 +24,23 @@
 
 ;;; Code:
 
+(defgroup xterm nil
+  "XTerm support."
+  :version "24.1"
+  :group 'emacs)
+
+(defcustom xterm-extra-capabilities 'check
+  "Set to a list if the XTerm supports modifyOtherKeys or
+reporting the background color.  Set to 'check to check for those
+features.  Set to nil to skip the checks."
+  :group 'xterm
+  :type '(choice (const :tag "No" nil)
+                 (const :tag "Check" check)
+                 ;; NOTE: If you add entries here, make sure to update
+                 ;; `tocheck-capabilities' in `terminal-init-xterm' as well.
+                 (set (const :tag "modifyOtherKeys support" modifyOtherKeys)
+                      (const :tag "report background" reportBackground))))
+
 (defvar xterm-function-map
   (let ((map (make-sparse-keymap)))
 
@@ -460,81 +477,116 @@
       (set-keymap-parent map (keymap-parent input-decode-map))
       (set-keymap-parent input-decode-map map)))
 
-    (xterm-register-default-colors)
-    (tty-set-up-initial-frame-faces)
+  (xterm-register-default-colors)
+  (tty-set-up-initial-frame-faces)
 
-    ;; Try to turn on the modifyOtherKeys feature on modern xterms.
-    ;; When it is turned on many more key bindings work: things like
-    ;; C-. C-, etc.
-    ;; To do that we need to find out if the current terminal supports
-    ;; modifyOtherKeys. At this time only xterm does.
+  ;; Try to turn on the modifyOtherKeys feature on modern xterms.
+  ;; When it is turned on many more key bindings work: things like
+  ;; C-. C-, etc.
+  ;; To do that we need to find out if the current terminal supports
+  ;; modifyOtherKeys. At this time only xterm does.
+  (when xterm-extra-capabilities
     (let ((coding-system-for-read 'binary)
-          (chr nil)
-          (str nil)
-          (recompute-faces nil)
-          version)
-      ;; Pending input can be mistakenly returned by the calls to
-      ;; read-event below.  Discard it.
-      (discard-input)
-      ;; Try to find out the type of terminal by sending a "Secondary
-      ;; Device Attributes (DA)" query.
-      (send-string-to-terminal "\e[>0c")
-
-      ;; The reply should be of the form: \e [ > NUMBER1 ; NUMBER2 ; NUMBER3 c
-      ;; If the timeout is completely removed for read-event, this
-      ;; might hang for terminals that pretend to be xterm, but don't
-      ;; respond to this escape sequence.  RMS' opinion was to remove
-      ;; it completely.  That might be right, but let's first try to
-      ;; see if by using a longer timeout we get rid of most issues.
-      (when (equal (read-event nil nil 2) ?\e)
-        (when (equal (read-event nil nil 2) ?\[)
-          (while (not (equal (setq chr (read-event nil nil 2)) ?c))
-            (setq str (concat str (string chr))))
-          (when (string-match ">0;\\([0-9]+\\);0" str)
-            (setq version (string-to-number
-                           (substring str (match-beginning 1) (match-end 1))))
-            ;; xterm version 242 supports reporting the background
-            ;; color, maybe earlier versions do too...
-            (when (>= version 242)
-              (send-string-to-terminal "\e]11;?\e\\")
-              (when (equal (read-event nil nil 2) ?\e)
-                (when (equal (read-event nil nil 2) ?\])
-                  (setq str "")
-                  (while (not (equal (setq chr (read-event nil nil 2)) ?\\))
-                    (setq str (concat str (string chr))))
-                  (when (string-match "11;rgb:\\([a-f0-9]+\\)/\\([a-f0-9]+\\)/\\([a-f0-9]+\\)" str)
-                    (setq recompute-faces
-                          (xterm-maybe-set-dark-background-mode
-                           (string-to-number (match-string 1 str) 16)
-                           (string-to-number (match-string 2 str) 16)
-                           (string-to-number (match-string 3 str) 16)))))))
-            ;; NUMBER2 is the xterm version number, look for something
-            ;; greater than 216, the version when modifyOtherKeys was
-            ;; introduced.
-            (when (>= version 216)
-              ;; Make sure that the modifyOtherKeys state is restored when
-              ;; suspending, resuming and exiting.
-              (add-hook 'suspend-hook 'xterm-turn-off-modify-other-keys)
-              (add-hook 'suspend-resume-hook 'xterm-turn-on-modify-other-keys)
-              (add-hook 'kill-emacs-hook 'xterm-remove-modify-other-keys)
-              (add-hook 'delete-terminal-functions 'xterm-remove-modify-other-keys)
-              ;; Add the selected frame to the list of frames that
-              ;; need to deal with modify-other-keys.
-              (push (frame-terminal (selected-frame))
-                    xterm-modify-other-keys-terminal-list)
-              (xterm-turn-on-modify-other-keys))
-
-            ;; Recompute faces here in case the background mode was
-            ;; set to dark.  We used to call
-            ;; `tty-set-up-initial-frame-faces' only once, but that
-            ;; caused the light background faces to be computed
-            ;; incorrectly.  See:
-            ;; http://permalink.gmane.org/gmane.emacs.devel/119627
-            (when recompute-faces
-              (tty-set-up-initial-frame-faces))))))
+          (chr nil)
+          (str nil)
+          (background-regex
+           "11;rgb:\\([a-f0-9]+\\)/\\([a-f0-9]+\\)/\\([a-f0-9]+\\)")
+          (recompute-faces nil)
+          ;; If `xterm-extra-capabilities' is 'check, we don't know
+          ;; the capabilities.  We need to check for those defined
+          ;; as `xterm-extra-capabilities' set options.  Otherwise,
+          ;; we don't need to check for any capabilities because
+          ;; they are given by setting `xterm-extra-capabilities' to
+          ;; a list (which could be empty).
+          (tocheck-capabilities (when (eq 'check xterm-extra-capabilities)
+                                  '(modifyOtherKeys reportBackground)))
+          ;; The given capabilities are either the contents of
+          ;; `xterm-extra-capabilities', if it's a list, or an empty
+          ;; list.
+          (given-capabilities (when (consp xterm-extra-capabilities)
+                                xterm-extra-capabilities))
+          version)
+
+      ;; Do the following if `xterm-extra-capabilities' is anything but nil.
+      (when xterm-extra-capabilities
+        ;; 1. Set `version'
+
+        ;; Pending input can be mistakenly returned by the calls to
+        ;; read-event below.  Discard it.
+        (discard-input)
+        ;; Try to find out the type of terminal by sending a "Secondary
+        ;; Device Attributes (DA)" query.
+        (send-string-to-terminal "\e[>0c")
+
+        ;; The reply should be: \e [ > NUMBER1 ; NUMBER2 ; NUMBER3 c
+        ;; If the timeout is completely removed for read-event, this
+        ;; might hang for terminals that pretend to be xterm, but don't
+        ;; respond to this escape sequence.  RMS' opinion was to remove
+        ;; it completely.  That might be right, but let's first try to
+        ;; see if by using a longer timeout we get rid of most issues.
+        (when (equal (read-event nil nil 2) ?\e)
+          (when (equal (read-event nil nil 2) ?\[)
+            (while (not (equal (setq chr (read-event nil nil 2)) ?c))
+              (setq str (concat str (string chr))))
+            (when (string-match ">0;\\([0-9]+\\);0" str)
+              (setq version
+                    (string-to-number
+                     (substring str (match-beginning 1) (match-end 1)))))))
+
+        ;; 2. If reportBackground is known to be supported, or the
+        ;; version is 242 or higher, assume the xterm supports
+        ;; reporting the background color (TODO: maybe earlier
+        ;; versions do too...)
+        (when (or (memq 'reportBackground given-capabilities)
+                  (and (memq 'reportBackground tocheck-capabilities)
+                       (>= version 242)))
+          (send-string-to-terminal "\e]11;?\e\\")
+          (when (equal (read-event nil nil 2) ?\e)
+            (when (equal (read-event nil nil 2) ?\])
+              (setq str "")
+              (while (not (equal (setq chr (read-event nil nil 2)) ?\\))
+                (setq str (concat str (string chr))))
+              (when (string-match background-regex str)
+                (setq recompute-faces
+                      (xterm-maybe-set-dark-background-mode
+                       (string-to-number (match-string 1 str) 16)
+                       (string-to-number (match-string 2 str) 16)
+                       (string-to-number (match-string 3 str) 16)))))))
+
+        ;; 3. If modifyOtherKeys is known to be supported or the
+        ;; version is 216 (the version when modifyOtherKeys was
+        ;; introduced) or higher, initialize the modifyOtherKeys
+        ;; support.
+        (when (or (memq 'modifyOtherKeys given-capabilities)
+                  (and (memq 'modifyOtherKeys tocheck-capabilities)
+                       (>= version 216)))
+          (terminal-init-xterm-modify-other-keys))
+
+        ;; Recompute faces here in case the background mode was
+        ;; set to dark.  We used to call
+        ;; `tty-set-up-initial-frame-faces' only once, but that
+        ;; caused the light background faces to be computed
+        ;; incorrectly.  See:
+        ;; http://permalink.gmane.org/gmane.emacs.devel/119627
+        (when recompute-faces
+          (tty-set-up-initial-frame-faces)))))
 
     (run-hooks 'terminal-init-xterm-hook))
 
+(defun terminal-init-xterm-modify-other-keys ()
+  "Terminal initialization for xterm's modifyOtherKeys support."
+  ;; Make sure that the modifyOtherKeys state is restored when
+  ;; suspending, resuming and exiting.
+  (add-hook 'suspend-hook 'xterm-turn-off-modify-other-keys)
+  (add-hook 'suspend-resume-hook 'xterm-turn-on-modify-other-keys)
+  (add-hook 'kill-emacs-hook 'xterm-remove-modify-other-keys)
+  (add-hook 'delete-terminal-functions 'xterm-remove-modify-other-keys)
+  ;; Add the selected frame to the list of frames that
+  ;; need to deal with modify-other-keys.
+  (push (frame-terminal (selected-frame))
+      xterm-modify-other-keys-terminal-list)
+  (xterm-turn-on-modify-other-keys))
+
 ;; Set up colors, for those versions of xterm that support it.
 (defvar xterm-standard-colors
   ;; The names in the comments taken from XTerm-col.ad in the xterm
diff --git a/lisp/window.el b/lisp/window.el
index eafa8a4764a..a88e56be83c 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -161,10 +161,41 @@ these functions to inhibit processing of window parameters.")
   "The absolut minimum number of lines of a window.
 Anything less might crash Emacs.")
 
+(defcustom window-min-height 4
+  "The minimum number of lines of any window.
+The value has to accomodate a mode- or header-line if present.  A
+value less than `window-safe-min-height' is ignored.  The value
+of this variable is honored when windows are resized or split.
+
+Applications should never rebind this variable.  To resize a
+window to a height less than the one specified here, an
+application should instead call `resize-window' with a non-nil
+IGNORE argument.  In order to have `split-window' make a window
+shorter, explictly specify the SIZE argument of that function."
+  :type 'integer
+  :version "24.1"
+  :group 'windows)
+
 (defconst window-safe-min-width 2
   "The absolut minimum number of columns of a window.
 Anything less might crash Emacs.")
 
+(defcustom window-min-width 10
+  "The minimum number of columns of any window.
+The value has to accomodate margins, fringes, or scrollbars if
+present.  A value less than `window-safe-min-width' is ignored.
+The value of this variable is honored when windows are resized or
+split.
+
+Applications should never rebind this variable.  To resize a
+window to a width less than the one specified here, an
+application should instead call `resize-window' with a non-nil
+IGNORE argument.  In order to have `split-window' make a window
+narrower, explictly specify the SIZE argument of that function."
+  :type 'integer
+  :version "24.1"
+  :group 'windows)
+
 (defun window-iso-combination-p (&optional window horizontal)
   "If WINDOW is a vertical combination return WINDOW's first child.
 WINDOW can be any window and defaults to the selected one.
@@ -1312,7 +1343,741 @@ The optional argument MINIBUF specifies whether the minibuffer
 window shall be counted.  See `walk-windows' for the precise
 meaning of this argument."
    (length (window-list-1 nil minibuf)))
+
+;;; Resizing windows.
+(defun resize-window-reset (&optional frame horizontal)
+  "Reset resize values for all windows on FRAME.
+FRAME defaults to the selected frame.
+
+This function stores the current value of `window-total-size' applied
+with argument HORIZONTAL in the new total size of all windows on
+FRAME.  It also resets the new normal size of each of these
+windows."
+  (resize-window-reset-1
+   (frame-root-window (normalize-live-frame frame)) horizontal))
+
+(defun resize-window-reset-1 (window horizontal)
+  "Internal function of `resize-window-reset'."
+  ;; Register old size in the new total size.
+  (set-window-new-total window (window-total-size window horizontal))
+  ;; Reset new normal size.
+  (set-window-new-normal window)
+  (when (window-child window)
+    (resize-window-reset-1 (window-child window) horizontal))
+  (when (window-right window)
+    (resize-window-reset-1 (window-right window) horizontal)))
+
+;; The following routine is used to manually resize the minibuffer
+;; window and is currently used, for example, by ispell.el.
+(defun resize-mini-window (window delta)
+  "Resize minibuffer window WINDOW by DELTA lines.
+If WINDOW cannot be resized by DELTA lines make it as large \(or
+as small) as possible but don't signal an error."
+  (when (window-minibuffer-p window)
+    (let* ((frame (window-frame window))
+           (root (frame-root-window frame))
+           (height (window-total-size window))
+           (min-delta
+            (- (window-total-size root)
+               (window-min-size root))))
+      ;; Sanitize DELTA.
+      (cond
+       ((<= (+ height delta) 0)
+        (setq delta (- (- height 1))))
+       ((> delta min-delta)
+        (setq delta min-delta)))
+
+      ;; Resize now.
+      (resize-window-reset frame)
+      ;; Ideally we should be able to resize just the last subwindow of
+      ;; root here.  See the comment in `resize-root-window-vertically'
+      ;; for why we do not do that.
+      (resize-this-window root (- delta) nil nil t)
+      (set-window-new-total window (+ height delta))
+      ;; The following routine catches the case where we want to resize
+      ;; a minibuffer-only frame.
+      (resize-mini-window-internal window))))
+
+(defun resize-window (window delta &optional horizontal ignore)
+  "Resize WINDOW vertically by DELTA lines.
+WINDOW can be an arbitrary window and defaults to the selected
+one.  An attempt to resize the root window of a frame will raise
+an error though.
+
+DELTA a positive number means WINDOW shall be enlarged by DELTA
+lines.  DELTA negative means WINDOW shall be shrunk by -DELTA
+lines.
+
+Optional argument HORIZONTAL non-nil means resize WINDOW
+horizontally by DELTA columns.  In this case a positive DELTA
+means enlarge WINDOW by DELTA columns.  DELTA negative means
+WINDOW shall be shrunk by -DELTA columns.
+
+Optional argument IGNORE non-nil means ignore any restrictions
+imposed by fixed size windows, `window-min-height' or
+`window-min-width' settings.  IGNORE any window means ignore
+restrictions for that window only.  IGNORE equal `safe' means
+live windows may get as small as `window-safe-min-height' lines
+and `window-safe-min-width' columns.
+
+This function resizes other windows proportionally and never
+deletes any windows.  If you want to move only the low (right)
+edge of WINDOW consider using `adjust-window-trailing-edge'
+instead."
+  (setq window (normalize-any-window window))
+  (let* ((frame (window-frame window))
+         sibling)
+    (cond
+     ((eq window (frame-root-window frame))
+      (error "Cannot resize the root window of a frame"))
+     ((window-minibuffer-p window)
+      (resize-mini-window window delta))
+     ((window-resizable-p window delta horizontal ignore)
+      (resize-window-reset frame horizontal)
+      (resize-this-window window delta horizontal ignore t)
+      (if (and (not (window-splits window))
+               (window-iso-combined-p window horizontal)
+               (setq sibling (or (window-right window) (window-left window)))
+               (window-sizable-p sibling (- delta) horizontal ignore))
+          ;; If window-splits returns nil for WINDOW, WINDOW is part of
+          ;; an iso-combination, and WINDOW's neighboring right or left
+          ;; sibling can be resized as requested, resize that sibling.
+          (let ((normal-delta
+                 (/ (float delta)
+                    (window-total-size (window-parent window) horizontal))))
+            (resize-this-window sibling (- delta) horizontal nil t)
+            (set-window-new-normal
+             window (+ (window-normal-size window horizontal)
+                       normal-delta))
+            (set-window-new-normal
+             sibling (- (window-normal-size sibling horizontal)
+                        normal-delta)))
+        ;; Otherwise, resize all other windows in the same combination.
+        (resize-other-windows window delta horizontal ignore))
+      (resize-window-apply frame horizontal))
+     (t
+      (error "Cannot resize window %s" window)))))
+
+(defsubst resize-subwindows-skip-p (window)
+  "Return non-nil if WINDOW shall be skipped by resizing routines."
+  (memq (window-new-normal window) '(ignore stuck skip)))
+
+(defun resize-subwindows-normal (parent horizontal window this-delta &optional trail other-delta)
+  "Set the new normal height of subwindows of window PARENT.
+HORIZONTAL non-nil means set the new normal width of these
+windows.  WINDOW specifies a subwindow of PARENT that has been
+resized by THIS-DELTA lines \(columns).
+
+Optional argument TRAIL either 'before or 'after means set values
+for windows before or after WINDOW only.  Optional argument
+OTHER-DELTA a number specifies that this many lines \(columns)
+have been obtained from \(or returned to) an ancestor window of
+PARENT in order to resize WINDOW."
+  (let* ((delta-normal
+          (if (and (= (- this-delta) (window-total-size window horizontal))
+                   (zerop other-delta))
+              ;; When WINDOW gets deleted and we can return its entire
+              ;; space to its siblings, use WINDOW's normal size as the
+              ;; normal delta.
+              (- (window-normal-size window horizontal))
+            ;; In any other case calculate the normal delta from the
+            ;; relation of THIS-DELTA to the total size of PARENT.
+            (/ (float this-delta) (window-total-size parent horizontal))))
+         (sub (window-child parent))
+         (parent-normal 0.0)
+         (skip (eq trail 'after)))
+
+    ;; Set parent-normal to the sum of the normal sizes of all
+    ;; subwindows of PARENT that shall be resized, excluding only WINDOW
+    ;; and any windows specified by the optional TRAIL argument.
+    (while sub
+      (cond
+       ((eq sub window)
+        (setq skip (eq trail 'before)))
+       (skip)
+       (t
+        (setq parent-normal
+              (+ parent-normal (window-normal-size sub horizontal)))))
+      (setq sub (window-right sub)))
+
+    ;; Set the new normal size of all subwindows of PARENT from what
+    ;; they should have contributed for recovering THIS-DELTA lines
+    ;; (columns).
+    (setq sub (window-child parent))
+    (setq skip (eq trail 'after))
+    (while sub
+      (cond
+       ((eq sub window)
+        (setq skip (eq trail 'before)))
+       (skip)
+       (t
+        (let ((old-normal (window-normal-size sub horizontal)))
+          (set-window-new-normal
+           sub (min 1.0 ; Don't get larger than 1.
+                    (max (- old-normal
+                            (* (/ old-normal parent-normal)
+                               delta-normal))
+                         ;; Don't drop below 0.
+                         0.0))))))
+      (setq sub (window-right sub)))
+
+    (when (numberp other-delta)
+      ;; Set the new normal size of windows from what they should have
+      ;; contributed for recovering OTHER-DELTA lines (columns).
+      (setq delta-normal (/ (float (window-total-size parent horizontal))
+                            (+ (window-total-size parent horizontal)
+                               other-delta)))
+      (setq sub (window-child parent))
+      (setq skip (eq trail 'after))
+      (while sub
+        (cond
+         ((eq sub window)
+          (setq skip (eq trail 'before)))
+         (skip)
+         (t
+          (set-window-new-normal
+           sub (min 1.0 ; Don't get larger than 1.
+                    (max (* (window-new-normal sub) delta-normal)
+                         ;; Don't drop below 0.
+                         0.0)))))
+        (setq sub (window-right sub))))
+
+    ;; Set the new normal size of WINDOW to what is left by the sum of
+    ;; the normal sizes of its siblings.
+    (set-window-new-normal
+     window
+     (let ((sum 0))
+       (setq sub (window-child parent))
+       (while sub
+         (cond
+          ((eq sub window))
+          ((not (numberp (window-new-normal sub)))
+           (setq sum (+ sum (window-normal-size sub horizontal))))
+          (t
+           (setq sum (+ sum (window-new-normal sub)))))
+         (setq sub (window-right sub)))
+       ;; Don't get larger than 1 or smaller than 0.
+       (min 1.0 (max (- 1.0 sum) 0.0))))))
+
+(defun resize-subwindows (parent delta &optional horizontal window ignore trail edge)
+  "Resize subwindows of window PARENT vertically by DELTA lines.
+PARENT must be a vertically combined internal window.
+
+Optional argument HORIZONTAL non-nil means resize subwindows of
+PARENT horizontally by DELTA columns.  In this case PARENT must
+be a horizontally combined internal window.
+
+WINDOW, if specified, must denote a child window of PARENT that
+is resized by DELTA lines.
+
+Optional argument IGNORE non-nil means ignore any restrictions
+imposed by fixed size windows, `window-min-height' or
+`window-min-width' settings.  IGNORE equal `safe' means live
+windows may get as small as `window-safe-min-height' lines and
+`window-safe-min-width' columns.  IGNORE any window means ignore
+restrictions for that window only.
+
+Optional arguments TRAIL and EDGE, when non-nil, restrict the set
+of windows that shall be resized.  If TRAIL equals `before',
+resize only windows on the left or above EDGE.  If TRAIL equals
+`after', resize only windows on the right or below EDGE.  Also,
+preferably only resize windows adjacent to EDGE.
+
+Return the symbol `normalized' if new normal sizes have been
+already set by this routine."
+  (let* ((first (window-child parent))
+         (sub first)
+         (parent-total (+ (window-total-size parent horizontal) delta))
+         best-window best-value)
+
+    (if (and edge (memq trail '(before after))
+             (progn
+               (setq sub first)
+               (while (and (window-right sub)
+                           (or (and (eq trail 'before)
+                                    (not (resize-subwindows-skip-p
+                                          (window-right sub))))
+                               (and (eq trail 'after)
+                                    (resize-subwindows-skip-p sub))))
+                 (setq sub (window-right sub)))
+               sub)
+             (if horizontal
+                 (if (eq trail 'before)
+                     (= (+ (window-left-column sub)
+                           (window-total-size sub t))
+                        edge)
+                   (= (window-left-column sub) edge))
+               (if (eq trail 'before)
+                   (= (+ (window-top-line sub)
+                         (window-total-size sub))
+                      edge)
+                 (= (window-top-line sub) edge)))
+             (window-sizable-p sub delta horizontal ignore))
+        ;; Resize only windows adjacent to EDGE.
+        (progn
+          (resize-this-window sub delta horizontal ignore t trail edge)
+          (if (and window (eq (window-parent sub) parent))
+              (progn
+                ;; Assign new normal sizes.
+                (set-window-new-normal
+                 sub (/ (float (window-new-total sub)) parent-total))
+                (set-window-new-normal
+                 window (- (window-normal-size window horizontal)
+                           (- (window-new-normal sub)
+                              (window-normal-size sub horizontal)))))
+            (resize-subwindows-normal parent horizontal sub 0 trail delta))
+          ;; Return 'normalized to notify `resize-other-windows' that
+          ;; normal sizes have been already set.
+          'normalized)
+      ;; Resize all windows proportionally.
+      (setq sub first)
+      (while sub
+        (cond
+         ((or (resize-subwindows-skip-p sub)
+              ;; Ignore windows to skip and fixed-size subwindows - in
+              ;; the latter case make it a window to skip.
+              (and (not ignore)
+                   (window-size-fixed-p sub horizontal)
+                   (set-window-new-normal sub 'ignore))))
+         ((< delta 0)
+          ;; When shrinking store the number of lines/cols we can get
+          ;; from this window here together with the total/normal size
+          ;; factor.
+          (set-window-new-normal
+           sub
+           (cons
+            ;; We used to call this with NODOWN t, "fixed" 2011-05-11.
+            (window-min-delta sub horizontal ignore trail t) ; t)
+            (- (/ (float (window-total-size sub horizontal))
+                  parent-total)
+               (window-normal-size sub horizontal)))))
+         ((> delta 0)
+          ;; When enlarging store the total/normal size factor only
+          (set-window-new-normal
+           sub
+           (- (/ (float (window-total-size sub horizontal))
+                 parent-total)
+              (window-normal-size sub horizontal)))))
+
+        (setq sub (window-right sub)))
+
+      (cond
+       ((< delta 0)
+        ;; Shrink windows by delta.
+        (setq best-window t)
+        (while (and best-window (not (zerop delta)))
+          (setq sub first)
+          (setq best-window nil)
+          (setq best-value most-negative-fixnum)
+          (while sub
+            (when (and (consp (window-new-normal sub))
+                       (not (zerop (car (window-new-normal sub))))
+                       (> (cdr (window-new-normal sub)) best-value))
+              (setq best-window sub)
+              (setq best-value (cdr (window-new-normal sub))))
+
+            (setq sub (window-right sub)))
+
+          (when best-window
+            (setq delta (1+ delta)))
+          (set-window-new-total best-window -1 t)
+          (set-window-new-normal
+           best-window
+           (if (= (car (window-new-normal best-window)) 1)
+               'skip ; We can't shrink best-window any further.
+             (cons (1- (car (window-new-normal best-window)))
+                   (- (/ (float (window-new-total best-window))
+                         parent-total)
+                      (window-normal-size best-window horizontal)))))))
+       ((> delta 0)
+        ;; Enlarge windows by delta.
+        (setq best-window t)
+        (while (and best-window (not (zerop delta)))
+          (setq sub first)
+          (setq best-window nil)
+          (setq best-value most-positive-fixnum)
+          (while sub
+            (when (and (numberp (window-new-normal sub))
+                       (< (window-new-normal sub) best-value))
+              (setq best-window sub)
+              (setq best-value (window-new-normal sub)))
+
+            (setq sub (window-right sub)))
+
+          (when best-window
+            (setq delta (1- delta)))
+          (set-window-new-total best-window 1 t)
+          (set-window-new-normal
+           best-window
+           (- (/ (float (window-new-total best-window))
+                 parent-total)
+              (window-normal-size best-window horizontal))))))
+
+      (when best-window
+        (setq sub first)
+        (while sub
+          (when (or (consp (window-new-normal sub))
+                    (numberp (window-new-normal sub)))
+            ;; Reset new normal size fields so `resize-window-apply'
+            ;; won't use them to apply new sizes.
+            (set-window-new-normal sub))
+
+          (unless (eq (window-new-normal sub) 'ignore)
+            ;; Resize this subwindow's subwindows (back-engineering
+            ;; delta from sub's old and new total sizes).
+            (let ((delta (- (window-new-total sub)
+                            (window-total-size sub horizontal))))
+              (unless (and (zerop delta) (not trail))
+                ;; For the TRAIL non-nil case we have to resize SUB
+                ;; recursively even if it's size does not change.
+                (resize-this-window
+                 sub delta horizontal ignore nil trail edge))))
+          (setq sub (window-right sub)))))))
+
+(defun resize-other-windows (window delta &optional horizontal ignore trail edge)
+  "Resize other windows when WINDOW is resized vertically by DELTA lines.
+Optional argument HORIZONTAL non-nil means resize other windows
+when WINDOW is resized horizontally by DELTA columns.  WINDOW
+itself is not resized by this function.
 
+Optional argument IGNORE non-nil means ignore any restrictions
+imposed by fixed size windows, `window-min-height' or
+`window-min-width' settings.  IGNORE equal `safe' means live
+windows may get as small as `window-safe-min-height' lines and
+`window-safe-min-width' columns.  IGNORE any window means ignore
+restrictions for that window only.
+
+Optional arguments TRAIL and EDGE, when non-nil, refine the set
+of windows that shall be resized.  If TRAIL equals `before',
+resize only windows on the left or above EDGE.  If TRAIL equals
+`after', resize only windows on the right or below EDGE.  Also,
+preferably only resize windows adjacent to EDGE."
+  (when (window-parent window)
+    (let* ((parent (window-parent window))
+           (sub (window-child parent)))
+      (if (window-iso-combined-p sub horizontal)
+          ;; In an iso-combination try to extract DELTA from WINDOW's
+          ;; siblings.
+          (let ((first sub)
+                (skip (eq trail 'after))
+                this-delta other-delta)
+            ;; Decide which windows shall be left alone.
+            (while sub
+              (cond
+               ((eq sub window)
+                ;; Make sure WINDOW is left alone when
+                ;; resizing its siblings.
+                (set-window-new-normal sub 'ignore)
+                (setq skip (eq trail 'before)))
+               (skip
+                ;; Make sure this sibling is left alone when
+                ;; resizing its siblings.
+                (set-window-new-normal sub 'ignore))
+               ((or (window-size-ignore sub ignore)
+                    (not (window-size-fixed-p sub horizontal)))
+                ;; Set this-delta to t to signal that we found a sibling
+                ;; of WINDOW whose size is not fixed.
+                (setq this-delta t)))
+
+              (setq sub (window-right sub)))
+
+            ;; Set this-delta to what we can get from WINDOW's siblings.
+            (if (= (- delta) (window-total-size window horizontal))
+                ;; A deletion, presumably.  We must handle this case
+                ;; specially since `window-resizable' can't be used.
+                (if this-delta
+                    ;; There's at least one resizable sibling we can
+                    ;; give WINDOW's size to.
+                    (setq this-delta delta)
+                  ;; No resizable sibling exists.
+                  (setq this-delta 0))
+              ;; Any other form of resizing.
+              (setq this-delta
+                    (window-resizable window delta horizontal ignore trail t)))
+
+            ;; Set other-delta to what we still have to get from
+            ;; ancestor windows of parent.
+            (setq other-delta (- delta this-delta))
+            (unless (zerop other-delta)
+              ;; Unless we got everything from WINDOW's siblings, PARENT
+              ;; must be resized by other-delta lines or columns.
+              (set-window-new-total parent other-delta 'add))
+
+            (if (zerop this-delta)
+                ;; We haven't got anything from WINDOW's siblings but we
+                ;; must update the normal sizes to respect other-delta.
+                (resize-subwindows-normal
+                 parent horizontal window this-delta trail other-delta)
+              ;; We did get something from WINDOW's siblings which means
+              ;; we have to resize their subwindows.
+              (unless (eq (resize-subwindows parent (- this-delta) horizontal
+                                             window ignore trail edge)
+                          ;; `resize-subwindows' returning 'normalized,
+                          ;; means it has set the normal sizes already.
+                          'normalized)
+                ;; Set the normal sizes.
+                (resize-subwindows-normal
+                 parent horizontal window this-delta trail other-delta))
+              ;; Set DELTA to what we still have to get from ancestor
+              ;; windows.
+              (setq delta other-delta)))
+
+        ;; In an ortho-combination all siblings of WINDOW must be
+        ;; resized by DELTA.
+        (set-window-new-total parent delta 'add)
+        (while sub
+          (unless (eq sub window)
+            (resize-this-window sub delta horizontal ignore t))
+          (setq sub (window-right sub))))
+
+      (unless (zerop delta)
+        ;; "Go up."
+        (resize-other-windows parent delta horizontal ignore trail edge)))))
+
+(defun resize-this-window (window delta &optional horizontal ignore add trail edge)
+  "Resize WINDOW vertically by DELTA lines.
+Optional argument HORIZONTAL non-nil means resize WINDOW
+horizontally by DELTA columns.
+
+Optional argument IGNORE non-nil means ignore any restrictions
+imposed by fixed size windows, `window-min-height' or
+`window-min-width' settings.  IGNORE equal `safe' means live
+windows may get as small as `window-safe-min-height' lines and
+`window-safe-min-width' columns.  IGNORE any window means ignore
+restrictions for that window only.
+
+Optional argument ADD non-nil means add DELTA to the new total
+size of WINDOW.
+
+Optional arguments TRAIL and EDGE, when non-nil, refine the set
+of windows that shall be resized.  If TRAIL equals `before',
+resize only windows on the left or above EDGE.  If TRAIL equals
+`after', resize only windows on the right or below EDGE.  Also,
+preferably only resize windows adjacent to EDGE.
+
+This function recursively resizes WINDOW's subwindows to fit the
+new size.  Make sure that WINDOW is `window-resizable' before
+calling this function.  Note that this function does not resize
+siblings of WINDOW or WINDOW's parent window.  You have to
+eventually call `resize-window-apply' in order to make resizing
+actually take effect."
+  (when add
+    ;; Add DELTA to the new total size of WINDOW.
+    (set-window-new-total window delta t))
+
+  (let ((sub (window-child window)))
+    (cond
+     ((not sub))
+     ((window-iso-combined-p sub horizontal)
+      ;; In an iso-combination resize subwindows according to their
+      ;; normal sizes.
+      (resize-subwindows window delta horizontal nil ignore trail edge))
+     ;; In an ortho-combination resize each subwindow by DELTA.
+     (t
+      (while sub
+        (resize-this-window sub delta horizontal ignore t trail edge)
+        (setq sub (window-right sub)))))))
+
+(defun resize-root-window (window delta horizontal ignore)
+  "Resize root window WINDOW vertically by DELTA lines.
+HORIZONTAL non-nil means resize root window WINDOW horizontally
+by DELTA columns.
+
+IGNORE non-nil means ignore any restrictions imposed by fixed
+size windows, `window-min-height' or `window-min-width' settings.
+
+This function is only called by the frame resizing routines.  It
+resizes windows proportionally and never deletes any windows."
+  (when (and (windowp window) (numberp delta)
+             (window-sizable-p window delta horizontal ignore))
+    (resize-window-reset (window-frame window) horizontal)
+    (resize-this-window window delta horizontal ignore t)))
+
+(defun resize-root-window-vertically (window delta)
+  "Resize root window WINDOW vertically by DELTA lines.
+If DELTA is less than zero and we can't shrink WINDOW by DELTA
+lines, shrink it as much as possible.  If DELTA is greater than
+zero, this function can resize fixed-size subwindows in order to
+recover the necessary lines.
+
+Return the number of lines that were recovered.
+
+This function is only called by the minibuffer window resizing
+routines.  It resizes windows proportionally and never deletes
+any windows."
+  (when (numberp delta)
+    (let (ignore)
+      (cond
+       ((< delta 0)
+        (setq delta (window-sizable window delta)))
+       ((> delta 0)
+        (unless (window-sizable window delta)
+          (setq ignore t))))
+
+      (resize-window-reset (window-frame window))
+      ;; Ideally, we would resize just the last window in a combination
+      ;; but that's not feasible for the following reason: If we grow
+      ;; the minibuffer window and the last window cannot be shrunk any
+      ;; more, we shrink another window instead.  But if we then shrink
+      ;; the minibuffer window again, the last window might get enlarged
+      ;; and the state after shrinking is not the state before growing.
+      ;; So, in practice, we'd need a history variable to record how to
+      ;; proceed.  But I'm not sure how such a variable could work with
+      ;; repeated minibuffer window growing steps.
+      (resize-this-window window delta nil ignore t)
+      delta)))
+
+(defun adjust-window-trailing-edge (window delta &optional horizontal)
+  "Move WINDOW's bottom edge by DELTA lines.
+Optional argument HORIZONTAL non-nil means move WINDOW's right
+edge by DELTA columns.  WINDOW defaults to the selected window.
+
+If DELTA is greater zero, then move the edge downwards or to the
+right.  If DELTA is less than zero, move the edge upwards or to
+the left.  If the edge can't be moved by DELTA lines or columns,
+move it as far as possible in the desired direction."
+  (setq window (normalize-any-window window))
+  (let ((frame (window-frame window))
+        (right window)
+        left this-delta min-delta max-delta failed)
+    ;; Find the edge we want to move.
+    (while (and (or (not (window-iso-combined-p right horizontal))
+                    (not (window-right right)))
+                (setq right (window-parent right))))
+    (cond
+     ((and (not right) (not horizontal) (not resize-mini-windows)
+           (eq (window-frame (minibuffer-window frame)) frame))
+      (resize-mini-window (minibuffer-window frame) (- delta)))
+     ((or (not (setq left right)) (not (setq right (window-right right))))
+      (if horizontal
+          (error "No window on the right of this one")
+        (error "No window below this one")))
+     (t
+      ;; Set LEFT to the first resizable window on the left.  This step is
+      ;; needed to handle fixed-size windows.
+      (while (and left (window-size-fixed-p left horizontal))
+        (setq left
+              (or (window-left left)
+                  (progn
+                    (while (and (setq left (window-parent left))
+                                (not (window-iso-combined-p left horizontal))))
+                    (window-left left)))))
+      (unless left
+        (if horizontal
+            (error "No resizable window on the left of this one")
+          (error "No resizable window above this one")))
+
+      ;; Set RIGHT to the first resizable window on the right.  This step
+      ;; is needed to handle fixed-size windows.
+      (while (and right (window-size-fixed-p right horizontal))
+        (setq right
+              (or (window-right right)
+                  (progn
+                    (while (and (setq right (window-parent right))
+                                (not (window-iso-combined-p right horizontal))))
+                    (window-right right)))))
+      (unless right
+        (if horizontal
+            (error "No resizable window on the right of this one")
+          (error "No resizable window below this one")))
+
+      ;; LEFT and RIGHT (which might be both internal windows) are now the
+      ;; two windows we want to resize.
+      (cond
+       ((> delta 0)
+        (setq max-delta (window-max-delta-1 left 0 horizontal nil 'after))
+        (setq min-delta (window-min-delta-1 right (- delta) horizontal nil 'before))
+        (when (or (< max-delta delta) (> min-delta (- delta)))
+          ;; We can't get the whole DELTA - move as far as possible.
+          (setq delta (min max-delta (- min-delta))))
+        (unless (zerop delta)
+          ;; Start resizing.
+          (resize-window-reset frame horizontal)
+          ;; Try to enlarge LEFT first.
+          (setq this-delta (window-resizable left delta horizontal))
+          (unless (zerop this-delta)
+            (resize-this-window
+             left this-delta horizontal nil t 'before
+             (if horizontal
+                 (+ (window-left-column left) (window-total-size left t))
+               (+ (window-top-line left) (window-total-size left)))))
+          ;; Shrink windows on right of LEFT.
+          (resize-other-windows
+           left delta horizontal nil 'after
+           (if horizontal
+               (window-left-column right)
+             (window-top-line right)))))
+       ((< delta 0)
+        (setq max-delta (window-max-delta-1 right 0 horizontal nil 'before))
+        (setq min-delta (window-min-delta-1 left delta horizontal nil 'after))
+        (when (or (< max-delta (- delta)) (> min-delta delta))
+          ;; We can't get the whole DELTA - move as far as possible.
+          (setq delta (max (- max-delta) min-delta)))
+        (unless (zerop delta)
+          ;; Start resizing.
+          (resize-window-reset frame horizontal)
+          ;; Try to enlarge RIGHT.
+          (setq this-delta (window-resizable right (- delta) horizontal))
+          (unless (zerop this-delta)
+            (resize-this-window
+             right this-delta horizontal nil t 'after
+             (if horizontal
+                 (window-left-column right)
+               (window-top-line right))))
+          ;; Shrink windows on left of RIGHT.
+          (resize-other-windows
+           right (- delta) horizontal nil 'before
+           (if horizontal
+               (+ (window-left-column left) (window-total-size left t))
+             (+ (window-top-line left) (window-total-size left)))))))
+      (unless (zerop delta)
+        ;; Don't report an error in the standard case.
+        (unless (resize-window-apply frame horizontal)
+          ;; But do report an error if applying the changes fails.
+          (error "Failed adjusting window %s" window)))))))
+
+(defun enlarge-window (delta &optional horizontal)
+  "Make selected window DELTA lines taller.
+Interactively, if no argument is given, make the selected window
+one line taller.  If optional argument HORIZONTAL is non-nil,
+make selected window wider by DELTA columns.  If DELTA is
+negative, shrink selected window by -DELTA lines or columns.
+Return nil."
+  (interactive "p")
+  (resize-window (selected-window) delta horizontal))
+
+(defun shrink-window (delta &optional horizontal)
+  "Make selected window DELTA lines smaller.
+Interactively, if no argument is given, make the selected window
+one line smaller.  If optional argument HORIZONTAL is non-nil,
+make selected window narrower by DELTA columns.  If DELTA is
+negative, enlarge selected window by -DELTA lines or columns.
+Return nil."
+  (interactive "p")
+  (resize-window (selected-window) (- delta) horizontal))
+
+(defun maximize-window (&optional window)
+  "Maximize WINDOW.
+Make WINDOW as large as possible without deleting any windows.
+WINDOW can be any window and defaults to the selected window."
+  (interactive)
+  (setq window (normalize-any-window window))
+  (resize-window window (window-max-delta window))
+  (resize-window window (window-max-delta window t) t))
+
+(defun minimize-window (&optional window)
+  "Minimize WINDOW.
+Make WINDOW as small as possible without deleting any windows.
+WINDOW can be any window and defaults to the selected window."
+  (interactive)
+  (setq window (normalize-any-window window))
+  (resize-window window (- (window-min-delta window)))
+  (resize-window window (- (window-min-delta window t)) t))
+
+(defsubst frame-root-window-p (window)
+  "Return non-nil if WINDOW is the root window of its frame."
+  (eq window (frame-root-window window)))
+
 ;; 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)
@@ -1347,6 +2112,501 @@ and no others."
     (eq base-window
         (next-window base-window (if nomini 'arg) all-frames))))
 
+;;; Deleting windows.
+(defun window-deletable-p (&optional window)
+  "Return t if WINDOW can be safely deleted from its frame.
+Return `frame' if deleting WINDOW should delete its frame
+instead."
+  (setq window (normalize-any-window window))
+  (unless ignore-window-parameters
+    ;; Handle atomicity.
+    (when (window-parameter window 'window-atom)
+      (setq window (window-atom-root window))))
+  (let ((parent (window-parent window))
+        (frame (window-frame window))
+        (dedicated (and (window-buffer window) (window-dedicated-p window)))
+        (quit-restore (window-parameter window 'quit-restore)))
+    (cond
+     ((frame-root-window-p window)
+      (when (and (or dedicated
+                     (and (eq (car-safe quit-restore) 'new-frame)
+                          (eq (nth 1 quit-restore) (window-buffer window))))
+                 (other-visible-frames-p frame))
+        ;; WINDOW is the root window of its frame.  Return `frame' but
+        ;; only if WINDOW is (1) either dedicated or quit-restore's car
+        ;; is new-frame and the window still displays the same buffer
+        ;; and (2) there are other frames left.
+        'frame))
+     ((and (not ignore-window-parameters)
+           (eq (window-parameter window 'window-side) 'none)
+           (or (not parent)
+               (not (eq (window-parameter parent 'window-side) 'none))))
+      ;; Can't delete last main window.
+      nil)
+     (t))))
+
+(defun window-or-subwindow-p (subwindow window)
+  "Return t if SUBWINDOW is either WINDOW or a subwindow of WINDOW."
+  (or (eq subwindow window)
+      (let ((parent (window-parent subwindow)))
+        (catch 'done
+          (while parent
+            (if (eq parent window)
+                (throw 'done t)
+              (setq parent (window-parent parent))))))))
+
+(defun delete-window (&optional window)
+  "Delete WINDOW.
+WINDOW can be an arbitrary window and defaults to the selected
+one.  Return nil.
+
+If the variable `ignore-window-parameters' is non-nil or the
+`delete-window' parameter of WINDOW equals t, do not process any
+parameters of WINDOW.  Otherwise, if the `delete-window'
+parameter of WINDOW specifies a function, call that function with
+WINDOW as its sole argument and return the value returned by that
+function.
+
+Otherwise, if WINDOW is part of an atomic window, call
+`delete-window' with the root of the atomic window as its
+argument.  If WINDOW is the only window on its frame or the last
+non-side window, signal an error."
+  (interactive)
+  (setq window (normalize-any-window window))
+  (let* ((frame (window-frame window))
+         (function (window-parameter window 'delete-window))
+         (parent (window-parent window))
+         atom-root)
+    (window-check frame)
+    (catch 'done
+      ;; Handle window parameters.
+      (cond
+       ;; Ignore window parameters if `ignore-window-parameters' tells
+       ;; us so or `delete-window' equals t.
+       ((or ignore-window-parameters (eq function t)))
+       ((functionp function)
+        ;; The `delete-window' parameter specifies the function to call.
+        ;; If that function is `ignore' nothing is done.  It's up to the
+        ;; function called here to avoid infinite recursion.
+        (throw 'done (funcall function window)))
+       ((and (window-parameter window 'window-atom)
+             (setq atom-root (window-atom-root window))
+             (not (eq atom-root window)))
+        (throw 'done (delete-window atom-root)))
+       ((and (eq (window-parameter window 'window-side) 'none)
+             (or (not parent)
+                 (not (eq (window-parameter parent 'window-side) 'none))))
+        (error "Attempt to delete last non-side window"))
+       ((not parent)
+        (error "Attempt to delete minibuffer or sole ordinary window")))
+
+      (let* ((horizontal (window-hchild parent))
+             (size (window-total-size window horizontal))
+             (frame-selected
+              (window-or-subwindow-p (frame-selected-window frame) window))
+             ;; Emacs 23 preferably gives WINDOW's space to its left
+             ;; sibling.
+             (sibling (or (window-left window) (window-right window))))
+        (resize-window-reset frame horizontal)
+        (cond
+         ((and (not (window-splits window))
+               sibling (window-sizable-p sibling size))
+          ;; Resize WINDOW's sibling.
+          (resize-this-window sibling size horizontal nil t)
+          (set-window-new-normal
+           sibling (+ (window-normal-size sibling horizontal)
+                      (window-normal-size window horizontal))))
+         ((window-resizable-p window (- size) horizontal nil nil nil t)
+          ;; Can do without resizing fixed-size windows.
+          (resize-other-windows window (- size) horizontal))
+         (t
+          ;; Can't do without resizing fixed-size windows.
+          (resize-other-windows window (- size) horizontal t)))
+        ;; Actually delete WINDOW.
+        (delete-window-internal window)
+        (when (and frame-selected
+                   (window-parameter
+                    (frame-selected-window frame) 'no-other-window))
+          ;; `delete-window-internal' has selected a window that should
+          ;; not be selected, fix this here.
+          (other-window -1 frame))
+        (run-window-configuration-change-hook frame)
+        (window-check frame)
+        ;; Always return nil.
+        nil))))
+
+(defun delete-other-windows (&optional window)
+  "Make WINDOW fill its frame.
+WINDOW may be any window and defaults to the selected one.
+Return nil.
+
+If the variable `ignore-window-parameters' is non-nil or the
+`delete-other-windows' parameter of WINDOW equals t, do not
+process any parameters of WINDOW.  Otherwise, if the
+`delete-other-windows' parameter of WINDOW specifies a function,
+call that function with WINDOW as its sole argument and return
+the value returned by that function.
+
+Otherwise, if WINDOW is part of an atomic window, call this
+function with the root of the atomic window as its argument.  If
+WINDOW is a non-side window, make WINDOW the only non-side window
+on the frame.  Side windows are not deleted. If WINDOW is a side
+window signal an error."
+  (interactive)
+  (setq window (normalize-any-window window))
+  (let* ((frame (window-frame window))
+         (function (window-parameter window 'delete-other-windows))
+         (window-side (window-parameter window 'window-side))
+         atom-root side-main)
+    (window-check frame)
+    (catch 'done
+      (cond
+       ;; Ignore window parameters if `ignore-window-parameters' is t or
+       ;; `delete-other-windows' is t.
+       ((or ignore-window-parameters (eq function t)))
+       ((functionp function)
+        ;; The `delete-other-windows' parameter specifies the function
+        ;; to call.  If the function is `ignore' no windows are deleted.
+        ;; It's up to the function called to avoid infinite recursion.
+        (throw 'done (funcall function window)))
+       ((and (window-parameter window 'window-atom)
+             (setq atom-root (window-atom-root window))
+             (not (eq atom-root window)))
+        (throw 'done (delete-other-windows atom-root)))
+       ((eq window-side 'none)
+        ;; Set side-main to the major non-side window.
+        (setq side-main (window-with-parameter 'window-side 'none nil t)))
+       ((memq window-side window-sides)
+        (error "Cannot make side window the only window")))
+      ;; If WINDOW is the main non-side window, do nothing.
+      (unless (eq window side-main)
+        (delete-other-windows-internal window side-main)
+        (run-window-configuration-change-hook frame)
+        (window-check frame))
+      ;; Always return nil.
+      nil)))
+
+;;; Splitting windows.
+(defsubst window-split-min-size (&optional horizontal)
+  "Return minimum height of any window when splitting windows.
+Optional argument HORIZONTAL non-nil means return minimum width."
+  (if horizontal
+      (max window-min-width window-safe-min-width)
+    (max window-min-height window-safe-min-height)))
+
+(defun split-window (&optional window size side)
+  "Make a new window adjacent to WINDOW.
+WINDOW can be any window and defaults to the selected one.
+Return the new window which is always a live window.
+
+Optional argument SIZE a positive number means make WINDOW SIZE
+lines or columns tall.  If SIZE is negative, make the new window
+-SIZE lines or columns tall.  If and only if SIZE is non-nil, its
+absolute value can be less than `window-min-height' or
+`window-min-width'; so this command can make a new window as
+small as one line or two columns.  SIZE defaults to half of
+WINDOW's size.  Interactively, SIZE is the prefix argument.
+
+Optional third argument SIDE nil (or `below') specifies that the
+new window shall be located below WINDOW.  SIDE `above' means the
+new window shall be located above WINDOW.  In both cases SIZE
+specifies the new number of lines for WINDOW \(or the new window
+if SIZE is negative) including space reserved for the mode and/or
+header line.
+
+SIDE t (or `right') specifies that the new window shall be
+located on the right side of WINDOW.  SIDE `left' means the new
+window shall be located on the left of WINDOW.  In both cases
+SIZE specifies the new number of columns for WINDOW \(or the new
+window provided SIZE is negative) including space reserved for
+fringes and the scrollbar or a divider column.  Any other non-nil
+value for SIDE is currently handled like t (or `right').
+
+If the variable `ignore-window-parameters' is non-nil or the
+`split-window' parameter of WINDOW equals t, do not process any
+parameters of WINDOW.  Otherwise, if the `split-window' parameter
+of WINDOW specifies a function, call that function with all three
+arguments and return the value returned by that function.
+
+Otherwise, if WINDOW is part of an atomic window, \"split\" the
+root of that atomic window.  The new window does not become a
+member of that atomic window.
+
+If WINDOW is live, properties of the new window like margins and
+scrollbars are inherited from WINDOW.  If WINDOW is an internal
+window, these properties as well as the buffer displayed in the
+new window are inherited from the window selected on WINDOW's
+frame.  The selected window is not changed by this function."
+  (interactive "i")
+  (setq window (normalize-any-window window))
+  (let* ((horizontal (not (memq side '(nil below above))))
+         (frame (window-frame window))
+         (parent (window-parent window))
+         (function (window-parameter window 'split-window))
+         (window-side (window-parameter window 'window-side))
+         ;; Rebind `window-nest' since in some cases we may have to
+         ;; override its value.
+         (window-nest window-nest)
+         atom-root)
+
+    (window-check frame)
+    (catch 'done
+      (cond
+       ;; Ignore window parameters if either `ignore-window-parameters'
+       ;; is t or the `split-window' parameter equals t.
+       ((or ignore-window-parameters (eq function t)))
+       ((functionp function)
+        ;; The `split-window' parameter specifies the function to call.
+        ;; If that function is `ignore', do nothing.
+        (throw 'done (funcall function window size side)))
+       ;; If WINDOW is a subwindow of an atomic window, split the root
+       ;; window of that atomic window instead.
+       ((and (window-parameter window 'window-atom)
+             (setq atom-root (window-atom-root window))
+             (not (eq atom-root window)))
+        (throw 'done (split-window atom-root size side))))
+
+      (when (and window-side
+                 (or (not parent)
+                     (not (window-parameter parent 'window-side))))
+        ;; WINDOW is a side root window.  To make sure that a new parent
+        ;; window gets created set `window-nest' to t.
+        (setq window-nest t))
+
+      (when (and window-splits size (> size 0))
+        ;; If `window-splits' is non-nil and SIZE is a non-negative
+        ;; integer, we cannot reasonably resize other windows.  Rather
+        ;; bind `window-nest' to t to make sure that subsequent window
+        ;; deletions are handled correctly.
+        (setq window-nest t))
+
+      (let* ((parent-size
+              ;; `parent-size' is the size of WINDOW's parent, provided
+              ;; it has one.
+              (when parent (window-total-size parent horizontal)))
+             ;; `resize' non-nil means we are supposed to resize other
+             ;; windows in WINDOW's combination.
+             (resize
+              (and window-splits (not window-nest)
+                   ;; Resize makes sense in iso-combinations only.
+                   (window-iso-combined-p window horizontal)))
+             ;; `old-size' is the current size of WINDOW.
+             (old-size (window-total-size window horizontal))
+             ;; `new-size' is the specified or calculated size of the
+             ;; new window.
+             (new-size
+              (cond
+               ((not size)
+                (max (window-split-min-size horizontal)
+                     (if resize
+                         ;; When resizing try to give the new window the
+                         ;; average size of a window in its combination.
+                         (min (- parent-size
+                                 (window-min-size parent horizontal))
+                              (/ parent-size
+                                 (1+ (window-iso-combinations
+                                      parent horizontal))))
+                       ;; Else try to give the new window half the size
+                       ;; of WINDOW (plus an eventual odd line).
+                       (+ (/ old-size 2) (% old-size 2)))))
+               ((>= size 0)
+                ;; SIZE non-negative specifies the new size of WINDOW.
+
+                ;; Note: Specifying a non-negative SIZE is practically
+                ;; always done as workaround for making the new window
+                ;; appear above or on the left of the new window (the
+                ;; ispell window is a typical example of that).  In all
+                ;; these cases the SIDE argument should be set to 'above
+                ;; or 'left in order to support the 'resize option.
+                ;; Here we have to nest the windows instead, see above.
+                (- old-size size))
+               (t
+                ;; SIZE negative specifies the size of the new window.
+                (- size))))
+             new-parent new-normal)
+
+        ;; Check SIZE.
+        (cond
+         ((not size)
+          (cond
+           (resize
+            ;; SIZE unspecified, resizing.
+            (when (and (not (window-sizable-p parent (- new-size) horizontal))
+                       ;; Try again with minimum split size.
+                       (setq new-size
+                             (max new-size (window-split-min-size horizontal)))
+                       (not (window-sizable-p parent (- new-size) horizontal)))
+              (error "Window %s too small for splitting" parent)))
+           ((> (+ new-size (window-min-size window horizontal)) old-size)
+            ;; SIZE unspecified, no resizing.
+            (error "Window %s too small for splitting" window))))
+         ((and (>= size 0)
+               (or (>= size old-size)
+                   (< new-size (if horizontal
+                                   window-safe-min-width
+                                 window-safe-min-width))))
+          ;; SIZE specified as new size of old window.  If the new size
+          ;; is larger than the old size or the size of the new window
+          ;; would be less than the safe minimum, signal an error.
+          (error "Window %s too small for splitting" window))
+         (resize
+          ;; SIZE specified, resizing.
+          (unless (window-sizable-p parent (- new-size) horizontal)
+            ;; If we cannot resize the parent give up.
+            (error "Window %s too small for splitting" parent)))
+         ((or (< new-size
+                 (if horizontal window-safe-min-width window-safe-min-height))
+              (< (- old-size new-size)
+                 (if horizontal window-safe-min-width window-safe-min-height)))
+          ;; SIZE specification violates minimum size restrictions.
+          (error "Window %s too small for splitting" window)))
+
+        (resize-window-reset frame horizontal)
+
+        (setq new-parent
+              ;; Make new-parent non-nil if we need a new parent window;
+              ;; either because we want to nest or because WINDOW is not
+              ;; iso-combined.
+              (or window-nest (not (window-iso-combined-p window horizontal))))
+        (setq new-normal
+              ;; Make new-normal the normal size of the new window.
+              (cond
+               (size (/ (float new-size) (if new-parent old-size parent-size)))
+               (new-parent 0.5)
+               (resize (/ 1.0 (1+ (window-iso-combinations parent horizontal))))
+               (t (/ (window-normal-size window horizontal) 2.0))))
+
+        (if resize
+            ;; Try to get space from OLD's siblings.  We could go "up" and
+            ;; try getting additional space from surrounding windows but
+            ;; we won't be able to return space to those windows when we
+            ;; delete the one we create here.  Hence we do not go up.
+            (progn
+              (resize-subwindows parent (- new-size) horizontal)
+              (let* ((normal (- 1.0 new-normal))
+                     (sub (window-child parent)))
+                (while sub
+                  (set-window-new-normal
+                   sub (* (window-normal-size sub horizontal) normal))
+                  (setq sub (window-right sub)))))
+          ;; Get entire space from WINDOW.
+          (set-window-new-total window (- old-size new-size))
+          (resize-this-window window (- new-size) horizontal)
+          (set-window-new-normal
+           window (- (if new-parent 1.0 (window-normal-size window horizontal))
+                     new-normal)))
+
+        (let* ((new (split-window-internal window new-size side new-normal)))
+          ;; Inherit window-side parameters, if any.
+          (when (and window-side new-parent)
+            (set-window-parameter (window-parent new) 'window-side window-side)
+            (set-window-parameter new 'window-side window-side))
+
+          (run-window-configuration-change-hook frame)
+          (window-check frame)
+          ;; Always return the new window.
+          new)))))
+
+;; I think this should be the default; I think people will prefer it--rms.
+(defcustom split-window-keep-point t
+  "If non-nil, \\[split-window-above-each-other] keeps the original point \
+in both children.
+This is often more convenient for editing.
+If nil, adjust point in each of the two windows to minimize redisplay.
+This is convenient on slow terminals, but point can move strangely.
+
+This option applies only to `split-window-above-each-other' and
+functions that call it.  `split-window' always keeps the original
+point in both children."
+  :type 'boolean
+  :group 'windows)
+
+(defun split-window-above-each-other (&optional size)
+  "Split selected window into two windows, one above the other.
+The upper window gets SIZE lines and the lower one gets the rest.
+SIZE negative means the lower window gets -SIZE lines and the
+upper one the rest.  With no argument, split windows equally or
+close to it.  Both windows display the same buffer, now current.
+
+If the variable `split-window-keep-point' is non-nil, both new
+windows will get the same value of point as the selected window.
+This is often more convenient for editing.  The upper window is
+the selected window.
+
+Otherwise, we choose window starts so as to minimize the amount of
+redisplay; this is convenient on slow terminals.  The new selected
+window is the one that the current value of point appears in.  The
+value of point can change if the text around point is hidden by the
+new mode line.
+
+Regardless of the value of `split-window-keep-point', the upper
+window is the original one and the return value is the new, lower
+window."
+  (interactive "P")
+  (let ((old-window (selected-window))
+        (old-point (point))
+        (size (and size (prefix-numeric-value size)))
+        moved-by-window-height moved new-window bottom)
+    (when (and size (< size 0) (< (- size) window-min-height))
+      ;; `split-window' would not signal an error here.
+      (error "Size of new window too small"))
+    (setq new-window (split-window nil size))
+    (unless split-window-keep-point
+      (with-current-buffer (window-buffer)
+        (goto-char (window-start))
+        (setq moved (vertical-motion (window-height)))
+        (set-window-start new-window (point))
+        (when (> (point) (window-point new-window))
+          (set-window-point new-window (point)))
+        (when (= moved (window-height))
+          (setq moved-by-window-height t)
+          (vertical-motion -1))
+        (setq bottom (point)))
+      (and moved-by-window-height
+           (<= bottom (point))
+           (set-window-point old-window (1- bottom)))
+      (and moved-by-window-height
+           (<= (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)))
+
+(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.
+SIZE negative means the right window gets -SIZE lines.
+
+SIZE includes the width of the window's scroll bar; if there are
+no scroll bars, it includes the width of the divider column to
+the window's right, if any.  SIZE omitted or nil means split
+window equally.
+
+The selected window remains selected.  Return the new window."
+  (interactive "P")
+  (let ((old-window (selected-window))
+        (size (and size (prefix-numeric-value size)))
+        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)))
+
+(defalias 'split-window-horizontally 'split-window-side-by-side)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; `balance-windows' subroutines using `window-tree'
 
@@ -2327,102 +3587,6 @@ at the front of the list of recently selected ones."
       ;; input focus and is risen.
       (select-frame-set-input-focus new-frame))
     buffer))
-
-;; I think this should be the default; I think people will prefer it--rms.
-(defcustom split-window-keep-point t
-  "If non-nil, \\[split-window-vertically] keeps the original point \
-in both children.
-This is often more convenient for editing.
-If nil, adjust point in each of the two windows to minimize redisplay.
-This is convenient on slow terminals, but point can move strangely.
-
-This option applies only to `split-window-vertically' and
-functions that call it.  `split-window' always keeps the original
-point in both children."
-  :type 'boolean
-  :group 'windows)
-
-(defun split-window-vertically (&optional size)
-  "Split selected window into two windows, one above the other.
-The upper window gets SIZE lines and the lower one gets the rest.
-SIZE negative means the lower window gets -SIZE lines and the
-upper one the rest.  With no argument, split windows equally or
-close to it.  Both windows display the same buffer, now current.
-
-If the variable `split-window-keep-point' is non-nil, both new
-windows will get the same value of point as the selected window.
-This is often more convenient for editing.  The upper window is
-the selected window.
-
-Otherwise, we choose window starts so as to minimize the amount of
-redisplay; this is convenient on slow terminals.  The new selected
-window is the one that the current value of point appears in.  The
-value of point can change if the text around point is hidden by the
-new mode line.
-
-Regardless of the value of `split-window-keep-point', the upper
-window is the original one and the return value is the new, lower
-window."
-  (interactive "P")
-  (let ((old-window (selected-window))
-        (old-point (point))
-        (size (and size (prefix-numeric-value size)))
-        moved-by-window-height moved new-window bottom)
-    (and size (< size 0)
-         ;; Handle negative SIZE value.
-         (setq size (+ (window-height) size)))
-    (setq new-window (split-window nil size))
-    (unless split-window-keep-point
-      (with-current-buffer (window-buffer)
-        (goto-char (window-start))
-        (setq moved (vertical-motion (window-height)))
-        (set-window-start new-window (point))
-        (when (> (point) (window-point new-window))
-          (set-window-point new-window (point)))
-        (when (= moved (window-height))
-          (setq moved-by-window-height t)
-          (vertical-motion -1))
-        (setq bottom (point)))
-      (and moved-by-window-height
-           (<= bottom (point))
-           (set-window-point old-window (1- bottom)))
-      (and moved-by-window-height
-           (<= (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)))
-
-;; 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-horizontally (&optional size)
-  "Split selected window into two windows side by side.
-The selected window becomes the left one and gets SIZE columns.
-SIZE negative means the right window gets -SIZE lines.
-
-SIZE includes the width of the window's scroll bar; if there are
-no scroll bars, it includes the width of the divider column to
-the window's right, if any.  SIZE omitted or nil means split
-window equally.
-
-The selected window remains selected.  Return the new window."
-  (interactive "P")
-  (let ((old-window (selected-window))
-        (size (and size (prefix-numeric-value size))))
-    (and size (< size 0)
-         ;; Handle negative SIZE value.
-         (setq size (+ (window-width) size)))
-    (split-window-save-restore-data (split-window nil size t) old-window)))
-
 
 (defun set-window-text-height (window height)
   "Set the height in lines of the text display area of WINDOW to HEIGHT.
@@ -3124,9 +4288,12 @@ Otherwise, consult the value of `truncate-partial-width-windows'
       (if (integerp t-p-w-w)
           (< (window-width window) t-p-w-w)
         t-p-w-w))))
-
-(define-key ctl-x-map "2" 'split-window-vertically)
-(define-key ctl-x-map "3" 'split-window-horizontally)
+
+(define-key ctl-x-map "0" 'delete-window)
+(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 "^" 'enlarge-window)
 (define-key ctl-x-map "}" 'enlarge-window-horizontally)
 (define-key ctl-x-map "{" 'shrink-window-horizontally)
 (define-key ctl-x-map "-" 'shrink-window-if-larger-than-buffer)