Se fechei acidentalmente o buffer de arranhões no Emacs, como crio um novo buffer de arranhões ?
Se fechei acidentalmente o buffer de arranhões no Emacs, como crio um novo buffer de arranhões ?
Respostas:
Ligações padrão do GNU Emacs:
C-xb
*scratch*
RET
ou, mais detalhadamente
M-x
switch-to-buffer *scratch*
RET
O *scratch*
buffer é o buffer selecionado na inicialização e possui o modo principal Interação Lisp . Nota: o modo para o *scratch*
buffer é controlado pela variável initial-major-mode
.
Em geral, você pode criar quantos buffers "zero" quiser e nomeá-los como quiser.
C-xb
NAME
RET
muda para um buffer NAME
, criando-o se ele não existir. Um novo buffer não está associado a um arquivo no disco até você usar C-xC-w(ou M-x write-file
RET) para escolher um arquivo em que ele deve ser salvo.
M-x
text-mode
RET
altera o modo principal do buffer atual para modo de texto. Para encontrar todos os modos disponíveis (ou seja, sem exigir novos pacotes), você pode obter uma lista digitando:
M-x
apropos-command -mode$
RET
.emacs
definir um modo de rascunho padrão diferente , este será o modo para o novo modo de rascunho - não a Listar interação.
Eu adiciono o seguinte no meu .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)))
Se não quiser ver o buffer de rascunho , pressiono Cx Ck, mas não o mata, basta colocá-lo no final da lista de buffers, para que eu precise da próxima vez que não precisar criar um novo.
Há várias dicas nesta página do EmacsWiki .
Aqui está o primeiro:
Uma função muito simples para recriar o buffer temporário:
(defun create-scratch-buffer nil
"create a scratch buffer"
(interactive)
(switch-to-buffer (get-buffer-create "*scratch*"))
(lisp-interaction-mode))
Cx b *scratch*
RET e RET com o modo iswitchb ativado.
Apenas Cx b *scratch*
RET caso contrário.
initial-major-mode
variável (lisp-interação-mode por padrão).
Eu descobri isso anos atrás, quando comecei a usar o emacs; Não tenho idéia de onde agora, mas sempre tive uma casa em meus arquivos .el pessoais. Ele aparece nas pesquisas do 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)
;;;----------------------------------------------------------------------
Eu costumava usar a solução dwj e fiquei bastante feliz com isso, até o dia em que percebi que ela falhou quando você realmente renomeou o buffer de rascunho (por exemplo, salvando-o).
Então eu adotei isso, o que funciona bem para mim:
(run-with-idle-timer 1 t
'(lambda () (get-buffer-create "*scratch*")))
Eu tenho scratch
como um comando interativo para abrir um novo buffer temporário (eu gosto de ter vários):
(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
adotado em: http://everything2.com/index.pl?node_id=1038451
bufname
RET)?
ido-mode
e geralmente tenho alguns buffers abertos. Criar um novo buffer usando C-x b
seria realmente tedioso. Eu precisaria criar um nome exclusivo que não corresponda a nenhum dos buffers atualmente presentes.
(global-set-key (kbd "C-x M-z")
'(lambda ()
(interactive)
(switch-to-buffer "*scratch*")))
Isso não apenas mudará rapidamente para o *scratch*
buffer (já que eu faço isso com freqüência), mas recriará um *scratch*
buffer e será ativado lisp-interaction-mode
automaticamente se você o matar acidentalmente. Mude a encadernação conforme desejar.
Como o docstring diz, esta função irá:
Mude para o buffer temporário. Se o buffer não existir, crie-o e escreva a mensagem inicial nele. "
Isso trará um novo buffer de arranque, que se parece com o buffer de arranque inicial.
(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)
É isso que eu uso - vinculo isso a um pressionamento de tecla conveniente. Envia você para o *scratch*
buffer, independentemente de ele já existir ou não, e o define comolisp-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)))
Prefiro que meu buffer temporário seja um arquivo real que é salvo automaticamente e reabri-lo é tão simples quanto abrir um arquivo. Na inicialização, eu mato o padrão e encontro o meu assim.
(add-hook 'emacs-startup-hook
(lambda ()
(kill-buffer "*scratch*")
(find-file "/Users/HOME/Desktop/.scratch")))
Eu tenho uma função customizada kill-buffer que basicamente faz a mesma coisa - reabre meu arquivo pessoal de rascunho salvo e mata o rascunho padrão se eu matasse o último buffer visível.
Eu personalizei algumas das desktop.el
funções para carregar depois (kill-buffer "*scratch*")
e(find-file "/Users/HOME/Desktop/.scratch")
para que o arquivo visível pela última vez ao sair do Emacs não fique oculto pelo rascunho padrão ou oculto pelo meu rascunho personalizado ao iniciar o Emacs.
Gosto de usar auto-save-buffers-enhanced
, que salva automaticamente qualquer extensão de arquivo que não seja especificamente excluída:
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"))
Eu uso uma ligeira variação da função do @paprika quando quero criar um buffer de visita sem arquivo:
(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) ))
Combinei as soluções postadas até agora em uma função:
(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))
Para aplicar esta função no seu .emacs, use:
(--scratch-buffer t)
(run-with-idle-timer 3 t '--scratch-buffer)
Isso tornará o buffer temporário indestrutível em primeiro lugar e, se salvo, ele será recriado. Além disso, podemos usar uma função de atalho scratch
para ativar o buffer rapidamente:
(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))))
No passado, provou ser útil conhecer o diretório de inicialização original a partir do qual o Emacs foi iniciado. Este é o valor desktop-dirname
ou a default-directory
variável local do buffer de rascunho:
(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))
Portanto, --startup-directory sempre retornará o diretório base do seu makefile, arquivo TODO, etc. Caso não haja área de trabalho ( --no-desktop commandline-switch ou sem desktop-file), a --scratch-directory
variável manterá o diretório que o Emacs era uma vez começou em.
encontre resposta no 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))