web-dev-qa-db-fra.com

Rouvrez le * tampon * dans Emacs?

Si j'ai accidentellement fermé le scratch buffer dans Emacs, comment créer un nouveau scratch buffer?

emacs
161
Fortepianissimo

Liaisons par défaut de GNU Emacs:

C-xb *scratch* RET

ou, plus verbalement

M-x switch-to-buffer *scratch* RET

Le tampon *scratch* est le tampon sélectionné au démarrage et a le mode majeur interaction LISP . Remarque: le mode pour le tampon *scratch* est contrôlé par la variable initial-major-mode .

En général, vous pouvez créer autant de tampons "de travail" que vous le souhaitez et les nommer comme vous le souhaitez.

C-xb NAMEname__ RET

bascule vers un tampon NAMEname__, le créant s'il n'existe pas. Un nouveau tampon n'est pas associé à un fichier sur le disque jusqu'à ce que vous utilisiez C-xC-w (ou M-x write-file RET) pour choisir un fichier où il devrait être sauvegardé.

M-x text-mode RET

change le mode principal du tampon actuel en mode texte. Pour trouver tous les modes disponibles (c'est-à-dire sans nécessiter de nouveaux packages), vous pouvez obtenir une liste en tapant:

M-x apropos-command -mode$ RET

197
Trey Jackson

J'ajoute ce qui suit dans mes .emacs:

;; bury *scratch* buffer instead of kill it
(defadvice kill-buffer (around kill-buffer-around-advice activate)
  (let ((buffer-to-kill (ad-get-arg 0)))
    (if (equal buffer-to-kill "*scratch*")
        (bury-buffer)
      ad-do-it)))

Si je ne veux pas voir scratch buffer j'appuie sur Cx Ck, mais cela ne le tue pas, il suffit de le placer à la fin de la liste des tampons, donc j'en ai besoin la prochaine fois que je n'aurai pas à créer nouveau.

22
user45273

Il y a une foule de conseils sur cette page EmacsWiki .

Voici le premier:

Une fonction très simple pour recréer le tampon de travail:

(defun create-scratch-buffer nil
   "create a scratch buffer"
   (interactive)
   (switch-to-buffer (get-buffer-create "*scratch*"))
   (LISP-interaction-mode))
15
idbrii

C-x b *scratch* RET et RET avec iswitchb-mode activé.

Autrement, C-x b *scratch* RET sinon.

8
Steven Huwig

J'ai trouvé cela il y a des années lorsque j'ai commencé à utiliser emacs; Je ne sais pas où maintenant mais il a toujours eu une maison dans mes fichiers personnels .el. Il apparaît dans les recherches Google.

;;; Prevent killing the *scratch* buffer -- source forgotten
;;;----------------------------------------------------------------------
;;; Make the *scratch* buffer behave like "The thing your aunt gave you,
;;; which you don't know what is."
(save-excursion
  (set-buffer (get-buffer-create "*scratch*"))
  (make-local-variable 'kill-buffer-query-functions)
  (add-hook 'kill-buffer-query-functions 'kill-scratch-buffer))

(defun kill-scratch-buffer ()
  ;; The next line is just in case someone calls this manually
  (set-buffer (get-buffer-create "*scratch*"))

  ;; Kill the current (*scratch*) buffer
  (remove-hook 'kill-buffer-query-functions 'kill-scratch-buffer)
  (kill-buffer (current-buffer))

  ;; Make a brand new *scratch* buffer
  (set-buffer (get-buffer-create "*scratch*"))
  (LISP-interaction-mode)
  (make-local-variable 'kill-buffer-query-functions)
  (add-hook 'kill-buffer-query-functions 'kill-scratch-buffer)

  ;; Since we killed it, don't let caller do that.
  nil)
;;;----------------------------------------------------------------------
4
dwj

J'ai scratch comme commande interactive pour ouvrir un nouveau tampon de travail (j'aime en avoir plusieurs):

(defun scratch ()
  "create a new scratch buffer to work in. (could be *scratch* - *scratchX*)"
  (interactive)
  (let ((n 0)
        bufname)
    (while (progn
             (setq bufname (concat "*scratch"
                                   (if (= n 0) "" (int-to-string n))
                                   "*"))
             (setq n (1+ n))
             (get-buffer bufname)))
  (switch-to-buffer (get-buffer-create bufname))
  (if (= n 1) initial-major-mode))) ; 1, because n was incremented

adopté de: http://everything2.com/index.pl?node_id=1038451

3
paprika

J'avais l'habitude d'utiliser la solution de dwj et j'en étais assez heureuse jusqu'au jour où j'ai réalisé qu'elle échouait lorsque vous renommiez le tampon de travail (par exemple en le sauvegardant).

Alors j'ai adopté ceci, qui fonctionne bien pour moi:

  (run-with-idle-timer 1 t
    '(lambda () (get-buffer-create "*scratch*")))
3
Gyom

Notez que le package emacs unkillable-scratch dans MELPA le fera. Il existe également scratch-persist qui enregistrera et restaurera automatiquement le tampon entre les sessions.

3
nj35
(global-set-key (kbd "C-x M-z")
                '(lambda ()
                   (interactive)
                   (switch-to-buffer "*scratch*")))

Cela basculera non seulement rapidement vers le tampon *scratch* (puisque je le fais fréquemment), mais recréera un tampon *scratch* et activera automatiquement LISP-interaction-mode si vous le tuez accidentellement. Changer la liaison comme vous le souhaitez.

2
CodyChan

C’est ce que j’utilise - je l’ai lié à une frappe pratique. Il vous envoie dans le tampon *scratch*, qu'il existe déjà ou non, et le configure pour être dans LISP-interaction-mode

(defun eme-goto-scratch () 
  "this sends you to the scratch buffer"
  (interactive)
  (let ((eme-scratch-buffer (get-buffer-create "*scratch*")))
    (switch-to-buffer eme-scratch-buffer)
    (LISP-interaction-mode)))
2
Edric

Je préfère que mon tampon de travail soit un fichier réel qui est automatiquement enregistré, et sa réouverture est aussi simple que d'ouvrir un fichier. Au démarrage, je tue le défaut et trouve le mien comme celui-ci.

(add-hook 'emacs-startup-hook
  (lambda ()
    (kill-buffer "*scratch*")
    (find-file "/Users/HOME/Desktop/.scratch")))

J'ai une fonction kill-buffer personnalisée qui fait essentiellement la même chose: rouvre mon fichier sauvegardé personnel et supprime le scratch par défaut if si j'ai tué le dernier tampon visible.

J'ai personnalisé quelques-unes des fonctions desktop.el pour charger after(kill-buffer "*scratch*") et (find-file "/Users/HOME/Desktop/.scratch"), de sorte que le dernier fichier visible sur Emacs existant ne soit pas enterré par le scratch par défaut ou par mon scratch personnalisé lors du lancement d'Emacs.

J'aime utiliser auto-save-buffers-enhanced, qui enregistre automatiquement toute extension de fichier non spécifiquement exclue:

https://github.com/kentaro/auto-save-buffers-enhanced/blob/master/auto-save-buffers-enhanced.el

(require 'auto-save-buffers-enhanced)
(auto-save-buffers-enhanced t)
(setq auto-save-buffers-enhanced-save-scratch-buffer-to-file-p 1)
(setq auto-save-buffers-enhanced-exclude-regexps '("\\.txt" "\\.el" "\\.tex"))

J'utilise une légère variation de la fonction de @paprika lorsque je veux créer un tampon de visite sans fichier:

(defun lawlist-new-buffer ()
  "Create a new buffer -- \*lawlist\*"
(interactive)
  (let* (
    (n 0)
    bufname)
  (catch 'done
    (while t
      (setq bufname (concat "*lawlist"
        (if (= n 0) "" (int-to-string n))
          "*"))
      (setq n (1+ n))
      (if (not (get-buffer bufname))
        (throw 'done nil)) ))
  (switch-to-buffer (get-buffer-create bufname))
  (text-mode) ))
2
lawlist

J'ai combiné les solutions publiées jusqu'à présent en une seule fonction:

(defun --scratch-buffer(&optional reset)
  "Get the *scratch* buffer object.
Make new scratch buffer unless it exists. 
If RESET is non-nil arrange it that it can't be killed."
  (let ((R (get-buffer "*scratch*")))
    (unless R
      (message "Creating new *scratch* buffer")
      (setq R (get-buffer-create "*scratch*") reset t))
        (when reset
          (save-excursion
            (set-buffer R)
            (LISP-interaction-mode)
            (make-local-variable 'kill-buffer-query-functions)
            (add-hook 'kill-buffer-query-functions '(lambda()(bury-buffer) nil)
          )))
    R))

Pour appliquer cette fonction dans votre .emacs use:

(--scratch-buffer t)
(run-with-idle-timer 3 t '--scratch-buffer)

Cela rendra le tampon d'effacement indestructible en premier lieu et, s'il est enregistré, il sera recréé. De plus, nous pouvons utiliser une fonction de raccourci scratch pour afficher rapidement le tampon:

(defun scratch()
  "Switch to *scratch*.  With prefix-arg delete its contents."
  (interactive)
  (switch-to-buffer (--scratch-buffer))
  (if current-prefix-arg
      (delete-region (point-min) (point-max))
    (goto-char (point-max))))

Dans le passé, il était utile de connaître le répertoire de démarrage d'origine à partir duquel Emacs a été démarré. Il s’agit de la valeur de desktop-dirname ou de la variable locale default-directory du tampon de travail:

(defvar --scratch-directory
  (save-excursion (set-buffer "*scratch*") default-directory)
  "The `default-directory' local variable of the *scratch* buffer.")

(defconst --no-desktop (member "--no-desktop" command-line-args)
  "True when no desktop file is loaded (--no-desktop command-line switch set).")

(defun --startup-directory ()
  "Return directory from which Emacs was started: `desktop-dirname' or the `--scratch-directory'.
Note also `default-minibuffer-frame'."
  (if (and (not --no-desktop) desktop-dirname) 
      desktop-dirname
    --scratch-directory))

So --startup-directory retournera toujours le répertoire de base de votre makefile, fichier TODO, etc. S'il n'y a pas de bureau ( --no-desktop commandline-switch ou pas de fichier desktop) la variable --scratch-directory contiendra le répertoire dans lequel Emacs a déjà été démarré.

1
Andreas Spindler

Comme le dit la docstring, cette fonction va:

Basculez vers le tampon de travail. Si le tampon n'existe pas, créez-le et écrivez-y le message initial. "

Cela créera un nouveau tampon de travail qui ressemble au tampon de travail initial.

(defun switch-buffer-scratch ()
  "Switch to the scratch buffer. If the buffer doesn't exist,
create it and write the initial message into it."
  (interactive)
  (let* ((scratch-buffer-name "*scratch*")
         (scratch-buffer (get-buffer scratch-buffer-name)))
    (unless scratch-buffer
      (setq scratch-buffer (get-buffer-create scratch-buffer-name))
      (with-current-buffer scratch-buffer
        (LISP-interaction-mode)
        (insert initial-scratch-message)))
    (switch-to-buffer scratch-buffer)))

(global-set-key "\C-cbs" 'switch-buffer-scratch)
1
kjfletch

trouver la réponse dans EmacsWiki: http://www.emacswiki.org/emacs/RecreateScratchBuffer

(defun create-scratch-buffer nil
   "create a scratch buffer"
   (interactive)
   (switch-to-buffer (get-buffer-create "*scratch*"))
   (LISP-interaction-mode))
0
Qian

Pour ajouter à la réponse acceptée, si vous avez activé le mode OIT (et qu’il se complète automatiquement après C-xb, ne vous laissant donc pas écrire *scratch*), essayez alors:

C-xbC-b*scratch* RET

C-x b C-b *scratch* RET

0
petre