Dividi finestra al bordo più esterno

Sto cercando un modo per aggiungere una nuova finestra divisa a tutta altezza a una configurazione di finestra esistente (suddivisa). Poiché non so come spiegarlo correttamente, posterò solo alcuni elementi grafici ASCII che mostrano il comportamento desiderato per due configurazioni di finestre di esempio:

             from                              to  

  +-------------------------+      +---------------------+---+  
  |                         |      |                     |   |  
  |                         |      |                     |   |  
  |            A            |  =>  |           A         | E |  
  |                         |      |                     |   |  
  |                         |      |                     |   |  
  +-------------------------+      +---------------------+---+  

  +------------+------------+      +----------+----------+---+  
  |            |     B      |      |          |   B      |   |
  |     A      +------------+      |     A    +----------+   |
  |            |     C      |  =>  |          |   C      | E | 
  +------------+------------+      +----------+----------+   |
  |            D            |      |          D          |   |
  +-------------------------+      +---------------------+---+  

dove la funzione accetta la larghezza desiderata della nuova finestra Ee riduce la larghezza di A, B, Ce Ddi conseguenza. Modifica2 : Nota che i due disegni sopra sono esempi del comportamento previsto per un caso concreto. Sto cercando una funzione generale che lo fa indipendentemente dalla configurazione nella colonna from (cioè il numero di windows [split] nella colonna from dovrebbe essere arbitrario).

Sto anche cercando questa funzionalità sul lato sinistro e nella parte superiore e inferiore di una cornice.

Modifica: dal commento di @ Nsukami_ mi sono reso conto che la funzionalità che sto cercando è un caso speciale di un problema più astratto. Quindi esprimerò quel problema:

Come si memorizza una configurazione della finestra (composta da un numero qualsiasi di finestre e buffer) e si "incolla" la configurazione memorizzata in una finestra esistente?

La "incolla" dovrebbe quindi preservare le dimensioni relative della finestra e la divisione; naturalmente la configurazione incollata risultante è una copia in scala.

La seguente funzione dovrebbe fare quello che vuoi. Il trucco è dividere la finestra principale del frame corrente.

(defun my-split-main-window (direction size)
  "Split the main window in the DIRECTION where DIRECTION is a symbol with
possible values of right, left, above or below and SIZE is the final size of the
windows, if the window is split horizontally (i.e. in DIRECTION below or above)
SIZE is assumed to be the target height otherwise SIZE is assumed to be the
target width"
  (let* ((new-window (split-window (frame-root-window) nil direction))
         (horizontal (member direction '(right left))))
    (save-excursion 
      (select-window new-window)
      (enlarge-window (- size (if horizontal
                                  (window-width)
                                (window-height)))
                      horizontal))
    new-window))

Chiamare la funzione con la direzione in cui dividere la finestra e le dimensioni della nuova finestra. Quanto sopra restituisce la finestra appena creata. Il concetto e le finestre e i frame sono spiegati molto bene nel Manuale di riferimento di GNU Emacs Lisp .

Non sono sicuro se la soluzione migliore, in quanto non abbastanza astratta, sto effettivamente risolvendo un solo caso d'uso. Il trucco è scrivere una funzione per passare da layoutX a layoutY e un'altra per passare da layoutY a layoutX

(defun from-x-to-y ()
 (interactive)
 (delete-other-windows)
 (split-window-vertically) ;;
 (let ((current-prefix-arg 10)) ;; emulate C-u
   (call-interactively 'enlarge-window) ;; resize
   )
 (split-window-horizontally) ;; -> |
 (next-multiframe-window)
 (split-window-vertically) ;;  -> --
 (previous-multiframe-window)
)

(defun from-y-to-x ()
  (interactive)
  (delete-other-windows)
  (split-window-horizontally) ;; -> |
  (let ((current-prefix-arg -60)) ;; emulate C-u
    (call-interactively 'shrink-window-horizontally) ;; resize
    )
  (split-window-vertically) ;; -> --
  (let ((current-prefix-arg 10)) ;;
    (call-interactively 'enlarge-window) ;;
    )
  (split-window-horizontally) ;;
  (next-multiframe-window)
  (split-window-vertically) 
  (previous-multiframe-window)
)

Spero che questa soluzione possa essere d'aiuto

Come si memorizza una configurazione della finestra (composta da un numero qualsiasi di finestre e buffer) e si "incolla" la configurazione memorizzata in una finestra esistente?

Ho appena trovato un pacchetto chiamato layout.el , non l'ho mai usato ma sembra essere quello che stai cercando, ci dirai se va bene.

MODIFICARE:

Cercando di trovare una soluzione più generica, sembra che tu possa usare M-x switch-to-buffer-other-frameper passare da un buffer in un frame, diciamo con un layout X, a un altro buffer in un altro frame con un layout Y.

Puoi anche essere in un layout X, memorizzare questo layout in un registro C-x r f(frame-configuration-to-register), andare in un altro layout e, se necessario, tornare a quello precedente, chiamando ciò che è all'interno del registro con C-x r j (jump- registrare)