How to shift vertical column of windows left and right in a frame?

Question

Q: how can I shift a window column left and right in a frame?

I use a single frame with multiple windows side-by-side. Usually each window takes up the full height of the frame, but occasionally, one of those windows will be split vertically (eg, when reading mail, the headers above and the message body below).

Now: I often swap buffers from window to window, which is easy enough to do. But: the vertically-split windows almost always contain buffers that logically go together (as in the email example), and I want to move their columns together, rather than just one buffer at a time. In other words, in involves manipulating the window layout itself, rather than just which buffer is visible in which window.

Visual example: I'd like to be able to move the column containing windows (A) and (D) from the left-most column to the middle column:

+-------+-------+-------+    +-------+-------+-------+
|       |       |       |    |       |       |       |
|  (A)  |       |       |    |       |  (A)  |       |
|       |  (B)  |  (C)  | => |  (B)  |       |  (C)  |
+-------+       |       |    |       +-------+       |
|  (D)  |       |       |    |       |  (D)  |       |
+-------+-------+-------+    +-------+-------+-------+

How can one accomplish this cleanly? I say "cleanly" because I've hacked together something that is pretty slow, pretty ugly, and pretty convoluted -- strong suggesting that I'm Doing It Wrong™.

Answer 1

I don't know of any built-in way to do what you want. But if you want to roll your own implementation, perhaps you could use the window-state-get and window-state-put functions to get an abstract representation of the window splitting configuration, modify it, and then install the modified version as the new configuration.

Below is a tentative implementation of this concept to do a rotation of all columns (this is not exactly what you want since it performs a circular permutation of all columns instead of moving the current one left or right):

+-------+-------+-------+    +-------+-------+-------+
|       |       |       |    |       |       |       |
|  (A)  |       |       |    |       |  (A)  |       |
|       |  (B)  |  (C)  | => |  (C)  |       |  (B)  |
+-------+       |       |    |       +-------+       |
|  (D)  |       |       |    |       |  (D)  |       |
+-------+-------+-------+    +-------+-------+-------+

(defun rotate-columns ()
  "Perform a circular permutation of all columns in the current frame"
  (interactive)
  (let ((win-state (window-state-get (frame-root-window))))
    ;; Don't do anything if the root window is not split side-by-side
    (when (eq 'hc (nth 1 win-state))
      (let ((split-state (cddr win-state))
            header columns)

        ;; Isolate the list of columns from the window parameters
        (mapc (lambda (param)
                (if (memq (car param) '(vc leaf))
                    ;; Column: potentially remove the (last . t) parameter
                    (push (cons (car param)
                                (remove-if
                                 (lambda (p) (eq (car p) 'last))
                                 (cdr param)))
                          columns)
                  ;; Header
                  (push param header)))
              split-state)

        ;; Rotate the columns
        ;;   (this is where more complex behaviour should be implemented to
        ;;   detect the currently active column and move it)
        (let* ((first  (car columns))
               (rest   (cdr columns))
               (last   (car rest)))
          ;; Add the (last . t) parameter to the last column
          (setcdr last (cons '(last . t)
                             (cdr last)))
          (setq columns (cons
                         first
                         (nreverse rest))))

        ;; Update the window state data structure...
        (setf (cddr win-state)
              (concatenate 'list
                           (nreverse header)
                           columns)))
      ;; ...and actually install it in the root window
      (delete-other-windows)
      (window-state-put win-state nil 'safe))))

---

Update:

Building upon this stub, I started a more full-fledged library to do this: colshift. It should already implement correctly the shifting operation you asked for...