Maximize Emacs windows without making others disappear

Question

Is there an Emacs equivalent of Vim's C-w _? This command "maximizes" the current window by making it as tall as possible (thus shrinking all of the other windows to be as small as possible).

Importantly, in Vim the other windows don't disappear when you enlarge the current window too far. Instead the current window stops enlarging so that the other windows can continue to live.

In Emacs, windows disappear when they shrink below window-min-height lines. This is annoying. Instead I want the other windows to shrink to window-min-height lines high, and then stop shrinking so they don't go away. Then I could just do (enlarge-window 1000). However I can't figure out how to get this to work.

I'm open to other strategies for maximizing windows if the above isn't possible.

Answer 1

I don't know the answer you have asked for.

As an alternate workflow, are you away that the open buffers are available with switch-to-buffer (bound to C-x b by default) and that if you tab at this point you'll get a list to choose from?

So I just use delete-other-windows (bound to C-x 1 by default), and use switch-to-buffer to go back.

Answer 2

In my opinion that's a little bit odd behavior, but this should get you started:

edit: filtering out windows which line up on either side, per comments:

(defun maximize-window ()
  (interactive)
  (let* ((lpos (first (window-edges)))
         (rpos (third (window-edges)))
         (in-same-column-p
          (lambda (w) (or (= lpos (first (window-edges w)))
                          (= rpos (third (window-edges w))))))
         (other-windows (remove-if-not in-same-column-p
                                       (rest (window-list))))
         (other-heights (* (length other-windows) window-min-height))
         (my-height (- (frame-height) other-heights)))
    (setf (window-height) (- my-height 1))))

Answer 3

Here's my shot at it. It seems to work pretty well for window configurations of up to 5 windows. But has gotten confused when I had 12 up (most windows pointing to the same buffer). So, it should work for you unless you've got crazy window configurations:

Note: It shrinks windows to the minimum size as specified by the variables window-min-width and window-min-height, which may be more than the actual minimum.

(defun my-maximize-current-window ()
  "Maximize the current window"
  (interactive)
  (my-shrink-all-but-window-in-tree (get-buffer-window (current-buffer)) (car (window-tree))))

(defun my-shrink-all-but-window-in-tree (window tree)
  (if (windowp tree)
      (when (eq tree window) tree)
    (let* ((left (my-shrink-all-but-window-in-tree window (caddr tree)))
           (right (my-shrink-all-but-window-in-tree window (cadddr tree)))
           (vertical (car tree))
           (found (or left right)))
      (my-shrink-windows (not vertical) (if right (caddr tree) (cadddr tree)))
      (select-window window)
      (when found (cons tree found)))))

(defun my-shrink-windows (vertical treetoshrink)
  (if (windowp treetoshrink)
      (let ((size (if vertical
                      (min 0  (- window-min-width (window-width treetoshrink)))
                    (min 0  (- window-min-height (window-height treetoshrink))))))

        (select-window treetoshrink nil)
        (enlarge-window size
                        vertical))
    (my-shrink-windows vertical (caddr treetoshrink))
    (my-shrink-windows vertical (cadddr treetoshrink))))