Emacs * scratch * buffer tekrar açılsın mı?

Emacs'ta çizik tamponunu yanlışlıkla kapatırsam , nasıl yeni bir çizik tamponu oluştururum?

GNU Emacs varsayılan bağlantıları:

C-xb *scratch* RET

veya daha ayrıntılı olarak

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

*scratch*Tampon başlangıçta seçilen tampon ve önemli modu vardır Lisp Etkileşimi . Not: *scratch*arabellek modu değişken tarafından kontrol edilir initial-major-mode.

Genel olarak istediğiniz kadar "çizik" tamponu oluşturabilir ve istediğiniz gibi adlandırabilirsiniz.

C-xb NAME RET

bir ara belleğe geçer ve NAMEyoksa bir arabellek oluşturur. Yeni bir arabellek, kaydedilecek dosyayı seçmek için C-xC-w(veya M-x write-file RET) kullanılana kadar diskteki bir dosyayla ilişkilendirilmez .

M-x text-mode RET

geçerli arabellek ana modunu Metin moduna değiştirir. Mevcut tüm modları (yani, yeni paketler gerektirmeden) bulmak için aşağıdakileri yazarak bir liste alabilirsiniz:

M-x apropos-command -mode$ RET

Benim .emacs içinde aşağıdaki ekleyin:

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

Çizik tampon görmek istemiyorsam, Cx Ck'ye basarım, ancak öldürmez, sadece tampon listesinin sonuna yerleştirin, bu yüzden bir dahaki sefere yeni bir tane oluşturmak zorunda değilim.

Bu EmacsWiki sayfasında bir sürü ipucu var .

İlki:

Çizik tamponu yeniden oluşturmak için çok basit bir fonksiyon:

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

Cx b *scratch*RET y RET, iswitchb modu etkinken.

*scratch*Aksi takdirde sadece Cx b RET.

Bunu yıllar önce emacs kullanmaya ilk başladığımda buldum; Şimdi nerede olduğu hakkında hiçbir fikrim yok ama kişisel .el dosyalarımda her zaman bir ev vardı. Google aramalarında açılır.

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

Dwj'nin çözümünü kullanıyordum ve gerçekten sıfırdan tamponu yeniden adlandırdığınızda (örneğin kaydederek) başarısız olduğunu fark edene kadar, bu konuda oldukça mutluydum .

Sonra benim için iyi sonuç verdi:

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

Ben scratchyeni sıfırdan tamponu (birkaç olması gibi) açılması için bir etkileşimli komutu olarak:

(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

: den benimsenen http://everything2.com/index.pl?node_id=1038451

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

Bu sadece hızlı bir şekilde *scratch*arabelleğe geçmekle kalmaz (bunu sık sık yaptığım için), aynı zamanda bir *scratch*tamponu yeniden oluşturur ve lisp-interaction-modeyanlışlıkla öldürürseniz otomatik olarak etkinleştirir . Bağlamayı istediğiniz gibi değiştirin.

unkillable-scratchMELPA'daki emacs paketinin bunu yapacağını unutmayın . Ayrıca scratch-persistoturumlar arasında arabelleği otomatik olarak kaydedip geri yükleyecek.

Öğretinin dediği gibi, bu fonksiyon:

Çizik tamponuna geçin. Arabellek yoksa onu oluşturun ve ilk mesajı içine yazın. "

Bu, ilk çizik tamponuna benzeyen yeni bir çizik tamponu getirecektir.

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

Kullandığım şey bu - uygun bir tuş vuruşuna bağlıyım. *scratch*Önceden var olup olmadığına bakılmaksızın sizi ara belleğe gönderir ve içinde olmasını sağlarlisp-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)))

Sıfırlama arabelleğimin otomatik olarak kaydedilen gerçek bir dosya olmasını tercih ediyorum ve yeniden açmak bir dosyayı açmak kadar basit. Başlangıçta, varsayılanı öldürürüm ve böyle kendim bulurum.

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

Ben aslında aynı şeyi yapan özel öldürme-tampon fonksiyonu var - benim kişisel karalama kaydedilen dosyayı yeniden açar ve varsayılan çizik öldürür eğer ben geçen görünür tampon öldürdü.

Ben birkaç özelleştirilmiş desktop.elyüke fonksiyonları sonra (kill-buffer "*scratch*") ve (find-file "/Users/HOME/Desktop/.scratch")böylece dosyanın o Emacs çıkarken görülebilen son varsayılan sıfırdan tarafından gömülü almaz veya Emacs başlatırken benim özel sıfırdan tarafından gömüldü.

Ben auto-save-buffers-enhancedözellikle, özellikle hariç tutulmayan herhangi bir dosya uzantısını kaydeder kullanmaktan zevk :

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

Dosya ziyaret ziyaret tamponu oluşturmak istediğinizde @paprika tarafından işlevin hafif bir varyasyonunu kullanın:

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

Şimdiye kadar yayınlanan çözümleri tek bir fonksiyonda birleştirdim:

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

Bu işlevi .emacs dosyasında uygulamak için şunu kullanın:

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

Bu, sıfırlama tamponunu ilk etapta yıkılmaz hale getirecek ve kaydedildiyse yeniden yaratılacaktır. Ayrıca scratcharabelleği hızlı bir şekilde getirmek için bir kısayol işlevi kullanabiliriz :

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

Geçmişte, Emacs'ın başlatıldığı orijinal başlangıç ​​dizinini bilmek yararlı olmuştur. Bu, sıfırlama tamponunun değeri desktop-dirnameveya default-directoryyerel değişkenidir:

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

Yani --startup-directory her zaman makefile, TODO-dosyası vb. Taban dizinini döndürecektir. Masaüstü ( - no-desktop commandline-switch veya desktop-file yok) olması durumunda --scratch-directorydeğişken Emacs bir zamanlar dizini tutacaktır altında başladı.

EmacsWiki'de cevap bul: 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))

Kabul edilen cevaba eklemek için, ILO modunuz açıksa (ve sonra otomatik olarak tamamlanıyor C-x b, böylece yazmanıza izin vermiyorsa *scratch*), deneyin:

C-xb C-b*scratch* RET

C-x b C-b *scratch* RET

C-xb ve sonra yazın *scratch* ↩︎

Lisp etkileşim modunda da yeni bir tampon oluşturmak için.