comparison lisp/textmodes/remember.el @ 85861:70f347d257ec

Remember: Put on a low-cookie diet, and improve docstrings.

85860:93f95830a179

(defvar remember-annotation nil
  "Current annotation.")
(defvar remember-initial-contents nil
  "Initial contents to place into *Remember* buffer.")
(defvar remember-before-remember-hook nil
  "Functions run before switching to the *Remember* buffer.")

(defcustom remember-run-all-annotation-functions-flag nil
  "Non-nil means use all annotations returned by
`remember-annotation-functions'."
  :type 'boolean
  :group 'remember)

;;;###autoload
(defun remember (&optional initial)
  "Remember an arbitrary piece of data.
With a prefix, uses the region as INITIAL."
  (interactive
   (list (when current-prefix-arg
           (buffer-substring (point) (mark)))))
  (funcall (if remember-in-new-frame
               #'frame-configuration-to-register

              (goto-char (point-max))
              (insert remember-text)
              (when remember-save-after-remembering (save-buffer))))
        (append-to-file (point-min) (point-max) remember-data-file)))))

;;;###autoload
(defun remember-region (&optional beg end)
  "Remember the data from BEG to END.
If called from within the remember buffer, BEG and END are ignored,
and the entire buffer will be remembered.

This function is meant to be called from the *Remember* buffer.
If you want to remember a region, supply a universal prefix to
`remember' instead. For example: C-u M-x remember."
  ;; Sacha: I have no idea where remember.el gets this context information, but
  ;; you can just use remember-annotation-functions.
  (interactive)
  (let ((b (or beg (min (point) (or (mark) (point-min)))))
        (e (or end (max (point) (or (mark) (point-max))))))

Most useful for remembering things from Netscape or other X Windows
application."
  (interactive)
  (remember (current-kill 0)))

;;;###autoload
(defun remember-buffer ()
  "Remember the contents of the current buffer."
  (interactive)
  (remember-region (point-min) (point-max)))

;;;###autoload
(defun remember-destroy ()
  "Destroy the current *Remember* buffer."
  (interactive)
  (when (equal remember-buffer (buffer-name))
    (kill-buffer (current-buffer))

(defvar remember-mode-map ()
  "Keymap used in Remember mode.")
(when (not remember-mode-map)
  (setq remember-mode-map (make-sparse-keymap))
  (define-key remember-mode-map "\C-x\C-s" 'remember-buffer)
  (define-key remember-mode-map "\C-c\C-c" 'remember-buffer)
  (define-key remember-mode-map "\C-c\C-k" 'remember-destroy))

(defun remember-mode ()
  "Major mode for output from \\[remember].
\\<remember-mode-map>This buffer is used to collect data that you want

85861:70f347d257ec

(defvar remember-annotation nil
  "Current annotation.")
(defvar remember-initial-contents nil
  "Initial contents to place into *Remember* buffer.")

(defcustom remember-before-remember-hook nil
  "Functions run before switching to the *Remember* buffer."
  :type 'hook
  :group 'remember)

(defcustom remember-run-all-annotation-functions-flag nil
  "Non-nil means use all annotations returned by
`remember-annotation-functions'."
  :type 'boolean
  :group 'remember)

;;;###autoload
(defun remember (&optional initial)
  "Remember an arbitrary piece of data.
INITIAL is the text to initially place in the *Remember* buffer,
or nil to bring up a blank *Remember* buffer.

With a prefix, use the region as INITIAL."
  (interactive
   (list (when current-prefix-arg
           (buffer-substring (point) (mark)))))
  (funcall (if remember-in-new-frame
               #'frame-configuration-to-register

              (goto-char (point-max))
              (insert remember-text)
              (when remember-save-after-remembering (save-buffer))))
        (append-to-file (point-min) (point-max) remember-data-file)))))

(defun remember-region (&optional beg end)
  "Remember the data from BEG to END.
It is called from within the *Remember* buffer to save the text
that was entered,

If BEG and END are nil, the entire buffer will be remembered.

If you want to remember a region, supply a universal prefix to
`remember' instead.  For example: C-u M-x remember RET."
  ;; Sacha: I have no idea where remember.el gets this context information, but
  ;; you can just use remember-annotation-functions.
  (interactive)
  (let ((b (or beg (min (point) (or (mark) (point-min)))))
        (e (or end (max (point) (or (mark) (point-max))))))

Most useful for remembering things from Netscape or other X Windows
application."
  (interactive)
  (remember (current-kill 0)))

(defun remember-finalize ()
  "Remember the contents of the current buffer."
  (interactive)
  (remember-region (point-min) (point-max)))

(defun remember-destroy ()
  "Destroy the current *Remember* buffer."
  (interactive)
  (when (equal remember-buffer (buffer-name))
    (kill-buffer (current-buffer))

(defvar remember-mode-map ()
  "Keymap used in Remember mode.")
(when (not remember-mode-map)
  (setq remember-mode-map (make-sparse-keymap))
  (define-key remember-mode-map "\C-x\C-s" 'remember-finalize)
  (define-key remember-mode-map "\C-c\C-c" 'remember-finalize)
  (define-key remember-mode-map "\C-c\C-k" 'remember-destroy))

(defun remember-mode ()
  "Major mode for output from \\[remember].
\\<remember-mode-map>This buffer is used to collect data that you want