Existe-t-il un moyen de contrôler dans quelle fenêtre Emacs ouvre de nouveaux tampons?

J'utilise sr-speedbar avec emacs, et j'ai souvent le cadre divisé en 2-3 fenêtres différentes, et chaque fois que je clique sur un fichier dans sr-speedbar, il ouvre toujours le nouveau tampon dans la fenêtre la plus basse. J'essaie de garder la fenêtre en bas à droite comme un terme relativement petit, et emacs continue d'insister pour ouvrir de nouveaux tampons dans la fenêtre à court terme plutôt que dans la zone beaucoup plus grande que j'aimerais utiliser pour éditer les tampons.

Existe-t-il un moyen de configurer la logique de création de tampon pour préférer les fenêtres supérieures aux fenêtres inférieures?

J'ai déjà essayé de prendre ma fenêtre la plus basse et de la marquer comme protégée, et cela a juste fait qu'emacs la divise en deux parties déraisonnablement petites. Ensuite, j'ai essayé d'activer window-size-fixed et au lieu de laisser emacs ouvrir le tampon au-dessus de cette fenêtre, cela m'a juste donné une erreur que la fenêtre était trop petite pour être divisée. Bon, je suppose que cela a cessé d'encombrer ma fenêtre la plus basse, mais stupide qu'il m'empêche d'ouvrir de nouveaux tampons à la place.

Idéalement, j'aimerais pouvoir forcer emacs à sélectionner la fenêtre en haut à droite pour afficher les tampons nouvellement créés, sans essayer de diviser la fenêtre en bas à droite.

Je suppose que vous utilisez Emacs 24; Je n'ai testé cette réponse dans aucune version antérieure et je ne sais pas quand le concept de fenêtres dédiées a été ajouté à Emacs. J'ai vu des mentions de son utilisation qui datent de 2011, donc je suppose qu'Emacs 23 (au moins) a également la capacité.

Vous pouvez empêcher Emacs d'ouvrir un nouveau tampon dans une fenêtre donnée en dédiant la fenêtre à son tampon .

Dans le cas le plus simple, vous pouvez le faire en sélectionnant la fenêtre que vous souhaitez dédier, en vous assurant qu'elle affiche actuellement le tampon auquel vous souhaitez le dédier, puis en le faisant M-: (set-window-dedicated-p (selected-window) t). Cela empêchera Emacs de considérer la fenêtre ainsi modifiée au moment de décider dans quelle fenêtre afficher un tampon. Pour supprimer la dédicace, évaluez la même expression, en remplaçant le deuxième argument par nil.

Vous pouvez empêcher Emacs de tenter de diviser une fenêtre qui affiche un tampon donné en définissant la variable buffer-local window-size-fixed sur une valeur non nulle.

Dans le cas le plus simple, vous pouvez le faire en sélectionnant la fenêtre et en faisant M-: (setq window-size-fixed t). Pour corriger uniquement la hauteur ou la largeur des fenêtres affichant le tampon, évaluez la même expression, en passant 'heightou 'widthcomme deuxième argument; pour supprimer la restriction, remplacez le deuxième argument par nil.

Dans le cas général, j'ai trouvé votre problème suffisamment intéressant pour pirater une solution , que vous pouvez déposer dans votre chemin de chargement (require), et utiliser:

;;; 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

Dans les versions récentes d'Emacs, une option a display-buffer-alistété ajoutée. Il offre un contrôle précis sur l'affichage du tampon, les fenêtres utilisées, etc. Cependant, parce qu'il vous permet de faire beaucoup de choses, il est également assez complexe et difficile à décrire. Consultez la documentation: C-h v display-buffer-alist.