Fenêtre divisée à la frontière la plus à l'extérieur

Je recherche un moyen d'ajouter une nouvelle fenêtre pleine hauteur à une configuration de fenêtre existante (divisée). Parce que je ne sais pas comment l'expliquer correctement, je posterai juste quelques graphiques ASCII montrant le comportement souhaité pour deux exemples de configurations de fenêtres:

             from                              to  

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

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

où la fonction accepte la largeur souhaitée de la nouvelle fenêtre Eet se rétrécit la largeur de A, B, C, et en Dconséquence. Edit2 : Notez que les deux dessins ci-dessus sont des exemples du comportement attendu pour un cas concret. Je cherche une fonction générale qui le fait indépendamment de la configuration dans la colonne from (c'est-à-dire que le nombre de fenêtres [splits] dans la colonne from devrait être arbitraire).

Je recherche également cette fonctionnalité sur le côté gauche et en haut et en bas d'un cadre.

Edit: À partir du commentaire de @ Nsukami_, j'ai réalisé que la fonctionnalité que je recherche est un cas particulier d'un problème plus abstrait. Je vais donc formuler ce problème:

Comment stockez-vous une configuration de fenêtre (composée d'un certain nombre de fenêtres et de tampons) et "collez" la configuration stockée dans une fenêtre existante?

La "pâte" devrait alors conserver les tailles de fenêtre relatives et le fractionnement; naturellement, la configuration collée résultante est une copie à l'échelle.

La fonction suivante devrait faire ce que vous voulez. L'astuce consiste à diviser la fenêtre racine de l'image actuelle.

(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))

Appelez la fonction avec la direction dans laquelle vous divisez la fenêtre et la taille de la nouvelle fenêtre. Ce qui précède renvoie la fenêtre nouvellement créée. Le concept, les fenêtres et les cadres sont très bien expliqués dans le manuel de référence GNU Emacs Lisp .

Je ne sais pas si la meilleure solution, car pas assez abstraite, je ne résous en fait qu'un seul cas d'utilisation. L'astuce consiste à écrire une fonction pour passer de layoutX à layoutY, et une autre pour passer de layoutY à 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)
)

J'espère que cette solution vous aidera

Comment stockez-vous une configuration de fenêtre (composée d'un certain nombre de fenêtres et de tampons) et "collez" la configuration stockée dans une fenêtre existante?

Je viens de trouver un package nommé layout.el , je ne l'ai jamais utilisé mais il semble être ce que vous cherchez, vous nous direz si ça va.

ÉDITER:

En essayant de trouver une solution plus générique, il semble que vous pouvez utiliser M-x switch-to-buffer-other-framepour passer d'un tampon dans un cadre, disons avec une disposition X, à un autre tampon dans un autre cadre avec une disposition Y.

Vous pouvez également être dans une disposition X, stocker cette disposition dans un registre C-x r f(frame-configuration-to-register), passer à une autre disposition et, si nécessaire, revenir à la précédente, en appelant ce qui se trouve à l'intérieur du registre C-x r j (jump- enregistrer)