Geteiltes Fenster am äußersten Rand

Ich suche nach einer Möglichkeit, einer vorhandenen (geteilten) Fensterkonfiguration eine neue Fensteraufteilung in voller Höhe hinzuzufügen. Da ich nicht weiß, wie ich es richtig erklären soll, werde ich nur einige ASCII-Grafiken veröffentlichen, die das gewünschte Verhalten für zwei Beispielfensterkonfigurationen zeigen:

             from                              to  

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

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

wo übernimmt die Funktion die gewünschte Breite des neuen Fensters Eund schrumpft die Breiten A, B, C, und sich Dentsprechend. Bearbeiten2 : Beachten Sie, dass die beiden obigen Zeichnungen Beispiele für das erwartete Verhalten für einen konkreten Fall sind. Ich suche nach einer allgemeinen Funktion, die dies unabhängig von der Konfiguration in der from- Spalte ausführt (dh die Anzahl der Fenster [Teilungen] in der from-Spalte sollte beliebig sein).

Ich suche diese Funktionalität auch auf der linken Seite und oben und unten in einem Rahmen.

Bearbeiten: Aus @ Nsukamis Kommentar wurde mir klar, dass die Funktionalität, die ich suche, ein Sonderfall eines abstrakteren Problems ist. Also werde ich dieses Problem formulieren:

Wie speichert man eine Fensterkonfiguration (bestehend aus einer beliebigen Anzahl von Fenstern und Puffern) und "fügt" die gespeicherte Konfiguration in ein vorhandenes Fenster ein?

Das "Einfügen" sollte dann die relativen Fenstergrößen und die Aufteilung beibehalten; Natürlich ist die resultierende eingefügte Konfiguration eine skalierte Kopie.

Die folgende Funktion sollte tun, was Sie wollen. Der Trick besteht darin, das Stammfenster des aktuellen Frames zu teilen.

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

Rufen Sie die Funktion mit der Richtung auf, in die Sie das Fenster und die Größe des neuen Fensters teilen möchten. Das obige gibt das neu erstellte Fenster zurück. Das Konzept sowie die Fenster und Rahmen werden im GNU Emacs Lisp-Referenzhandbuch sehr gut erklärt .

Ich bin mir nicht sicher, ob die beste Lösung, da sie nicht ausreichend abstrahiert ist, tatsächlich nur einen Anwendungsfall löst. Der Trick besteht darin, eine Funktion zu schreiben, um von layoutX zu layoutY zu wechseln, und eine andere, um von layoutY zu layoutX zu wechseln

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

Ich hoffe, dass diese Lösung helfen wird

Wie speichert man eine Fensterkonfiguration (bestehend aus einer beliebigen Anzahl von Fenstern und Puffern) und "fügt" die gespeicherte Konfiguration in ein vorhandenes Fenster ein?

Ich habe gerade ein Paket mit dem Namen layout.el gefunden . Ich habe es noch nie verwendet, aber es scheint das zu sein, wonach Sie suchen. Sie werden uns sagen, ob es in Ordnung ist.

BEARBEITEN:

Wenn Sie versuchen, eine allgemeinere Lösung zu finden, können Sie anscheinend M-x switch-to-buffer-other-framevon einem Puffer in einem Frame, beispielsweise mit einem Layout X, zu einem anderen Puffer in einem anderen Frame mit einem Layout Y wechseln.

Sie können sich auch in einem Layout X befinden, dieses Layout in einem Register speichern C-x r f(Frame-Konfiguration-zu-Register), zu einem anderen Layout wechseln und bei Bedarf zum vorherigen zurückschalten und das, was sich im Register befindet, aufrufen C-x r j (jump- zu registrieren)