Gibt es eine Möglichkeit zu steuern, in welchem ​​Fenster Emacs neue Puffer öffnet?

Ich verwende sr-speedbar mit Emacs und habe den Frame oft in 2-3 verschiedene Fenster aufgeteilt. Wenn ich auf eine Datei in sr-speedbar klicke, wird immer der neue Puffer im untersten Fenster geöffnet. Ich versuche, das Fenster ganz rechts unten als relativ kleinen Ansi-Term beizubehalten, und emacs besteht weiterhin darauf, neue Puffer im kleinen Termfenster zu öffnen, anstatt in dem viel größeren Bereich, den ich zum Bearbeiten von Puffern verwenden möchte.

Gibt es eine Möglichkeit, die Puffererstellungslogik so zu konfigurieren, dass höhere Fenster niedrigeren Fenstern vorgezogen werden?

Ich habe bereits versucht, mein unterstes Fenster zu nehmen und es als geschützt zu markieren, und das hat Emacs dazu gebracht, es in zwei unangemessen kleine Teile aufzuteilen. Dann habe ich versucht, die Fenstergröße zu aktivieren, und anstatt Emacs den Puffer über diesem Fenster öffnen zu lassen, habe ich nur den Fehler erhalten, dass das Fenster zu klein war, um geteilt zu werden. Gut, ich denke, dass es aufgehört hat, mein unterstes Fenster zu verstopfen, aber dumm, dass es mich davon abhält, stattdessen neue Puffer zu öffnen.

Im Idealfall möchte ich Emacs zwingen können, das Fenster ganz oben rechts für die Anzeige neu erstellter Puffer auszuwählen, und nicht versuchen, das Fenster ganz unten rechts zu teilen.

Ich gehe davon aus, dass Sie Emacs 24 verwenden. Ich habe diese Antwort in keiner früheren Version getestet und weiß nicht, wann das Konzept der dedizierten Fenster zu Emacs hinzugefügt wurde. Ich habe Erwähnungen seiner Verwendung gesehen, die aus dem Jahr 2011 stammen, daher gehe ich davon aus, dass Emacs 23 (zumindest) ebenfalls über die entsprechenden Funktionen verfügt.

Sie können verhindern, dass Emacs einen neuen Puffer in einem bestimmten Fenster öffnet, indem Sie das Fenster seinem Puffer zuweisen .

Im einfachsten Fall können Sie dies tun, indem Sie das Fenster auswählen, das Sie zuweisen möchten, sicherstellen, dass derzeit der Puffer angezeigt wird, dem Sie es zuweisen möchten, und dann ausführen M-: (set-window-dedicated-p (selected-window) t). Dadurch wird verhindert, dass Emacs das so geänderte Fenster berücksichtigt, wenn entschieden wird, in welchem ​​Fenster ein Puffer angezeigt werden soll. Um die Widmung zu entfernen, bewerten Sie denselben Ausdruck und ersetzen Sie das zweite Argument durch nil.

Sie können verhindern, dass Emacs versucht, ein Fenster zu teilen, in dem ein bestimmter Puffer angezeigt wird, wobei die pufferlokale Variable Fenstergröße auf einen Wert ungleich Null festgelegt wird.

Im einfachsten Fall können Sie dies tun, indem Sie das Fenster auswählen und ausführen M-: (setq window-size-fixed t). Um nur die Höhe oder Breite von Fenstern festzulegen, in denen der Puffer angezeigt wird, bewerten Sie denselben Ausdruck, indem Sie ihn übergeben 'heightoder 'widthals zweites Argument verwenden. Um die Einschränkung aufzuheben, ersetzen Sie das zweite Argument durch nil.

Im allgemeinen Fall fand ich Ihr Problem interessant genug, um eine Lösung zu finden , die Sie in Ihren Ladepfad einfügen (require)und verwenden können:

;;; dedicate-windows-manually.el --- Manually (un)dedicate windows

;; Copyright (C) 2013 Aaron Miller
;; <[email protected]>

;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2 of
;; the License, or (at your option) any later version.

;; This program is distributed in the hope that it will be
;; useful, but WITHOUT ANY WARRANTY; without even the implied
;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
;; PURPOSE.  See the GNU General Public License for more details.

;; You should have received a copy of the GNU General Public
;; License along with this program; if not, write to the Free
;; Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
;; MA 02111-1307 USA

;;; Commentary:

;; Introduction
;; ============

;; The functions here defined allow you to manually dedicate and
;; undedicate windows, that is, prevent `set-window-buffer' from
;; considering them when selecting a window in which to display a
;; given buffer.

;; Windows dedicated in this fashion will also be protected from
;; splitting by setting `window-size-fixed'.

;; Installation
;; ============

;; Place this file in your load path; then, place the following
;; command somewhere in your initialization file:

;; (require 'dedicate-windows-manually)

;; Now you can use M-x dedicate-window to dedicate the selected window
;; to its currently displayed buffer, M-x undedicate-window to release
;; a dedication so applied, and M-x dedicate-window-toggle to switch
;; between the states.

;; These functions will operate only on manually dedicated or
;; undedicated windows; that is, M-x dedicate-window will not dedicate
;; a window which is already dedicated (i.e. "(window-dedicated-p
;; window) -> t", and M-x undedicate-window will not undedicate a
;; window which was not dedicated by way of M-x dedicate-window.

;; If you find yourself frequently doing M-x dedicate-window-toggle,
;; you might wish to place something like this in your init file:

;; (global-set-key (kbd "C-x 4 C-d") 'dedicate-window-toggle)

;; Bugs:
;; * Changing the lighter string while you have windows dedicated is
;;   probably not a good idea.
;; * I should certainly find a better way to change the mode line.

;;; Code:

(defcustom dedicated-window-lighter-string " [D]"
  "A string, propertized with `dedicated-window-lighter-face', prepended
to the mode line of manually dedicated windows.")

(defvar dedicated-windows-by-hand nil
  "A list of windows known to have been manually dedicated. Windows not
in this list will not be undedicated by `undedicate-window'.")

(defun dedicate-window-was-by-hand-p (window)
  (let ((result nil))
    (loop for w in dedicated-windows-by-hand
          collect (if (eq w window) (setq result t)))
    result))

(defun dedicate-window (&optional window flag)
  "Dedicate a window to its buffer, and prevent it from being split.

Optional argument WINDOW, if non-nil, should specify a window. Otherwise,
or when called interactively, the currently selected window is used.

Optional argument FLAG, if non-nil, will be passed verbatim to
`set-window-dedicated-p'."
  (interactive nil)
  (if (eq nil window) (setq window (selected-window)))
  (if (eq nil flag) (setq flag t))
  (if (window-dedicated-p window)
      (message "Window is already dedicated.")
    (progn
      (add-to-list 'dedicated-windows-by-hand window)
      (setq mode-line-format
            (append `(,dedicated-window-lighter-string) mode-line-format))
      (setq window-size-fixed t)
      (set-window-dedicated-p window flag))))

(defun undedicate-window (&optional window)
  "Un-dedicate a window from its buffer.

Optional argument WINDOW, if non-nil, should specify a window listed in
`dedicated-windows-by-hand'. Otherwise, or when called interactively,
the currently selected window is used.

If WINDOW is not in `dedicated-windows-by-hand', a complaint will be
issued and nothing will be done."
  (interactive nil)
  (if (eq nil window) (setq window (selected-window)))
  (if (not (window-dedicated-p window))
      (message "Window is not dedicated.")
    (if (not (dedicate-window-was-by-hand-p window))
        (message "Window is not dedicated by hand.")
      (progn
        (setq dedicated-windows-by-hand
              (remove window dedicated-windows-by-hand))
        (setq mode-line-format
              (remove dedicated-window-lighter-string mode-line-format))
        (setq window-size-fixed nil)
        (set-window-dedicated-p window nil)))))

(defun dedicate-window-toggle (&optional window)
  "Toggle a window's manual buffer dedication state.

Optional argument WINDOW, if non-nil, should specify a window. Otherwise,
or when called interactively, the value of `selected-window' is used."
  (interactive nil)
  (if (eq nil window) (setq window (selected-window)))
  (if (window-dedicated-p window)
      (undedicate-window window)
    (dedicate-window window)))

(provide 'dedicate-windows-manually)

;;; dedicate-windows-manually.el ends here

In den letzten Emacs-Versionen wurde die Option display-buffer-alisthinzugefügt. Es bietet eine fein abgestimmte Steuerung der Pufferanzeige, der verwendeten Fenster usw. Da Sie jedoch so viele Aufgaben ausführen können, ist es auch recht komplex und schwer zu beschreiben. Konsultieren Sie die Dokumentation : C-h v display-buffer-alist.