Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/textmodes/remember.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@27 This version of remember.
(defconst remember-version "2.0" (#$ . 408))
(byte-code "\300\301\302\303\304\305%\210\306\307\302\310\311\312\313\314\304\301&	\210\306\315\302\316\311\317\304\301&\210\306\320\321\322\311\323\304\301&\210\306\324\302\325\311\312\304\301&\210\306\326\327\330\311\312\313\331\304\301&	\210\306\332\302\333\311\317\304\301&\207" [custom-declare-group remember nil "A mode to remember information." :group data custom-declare-variable remember-mode-hook "Functions run upon entering `remember-mode'." :type hook :options (flyspell-mode turn-on-auto-fill org-remember-apply-template) remember-in-new-frame "Non-nil means use a separate frame for capturing remember data." boolean remember-register 82 "The register in which the window configuration is stored." character remember-filter-functions "Functions run to filter remember data.\nAll functions are run in the remember buffer." remember-handler-functions '(remember-append-to-file) "Functions run to process remember data.\nEach function is called with the current buffer narrowed to what the\nuser wants remembered.\nIf any function returns non-nil, the data is assumed to have been\nrecorded somewhere by that function." (remember-store-in-mailbox remember-append-to-file remember-store-in-files remember-diary-extract-entries org-remember-handler) remember-all-handler-functions "If non-nil every function in `remember-handler-functions' is called."] 10)
#@45 The name of the remember data entry buffer.
(defvar remember-buffer "*Remember*" (#$ . 1856))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\314\315\306\307&	\207" [custom-declare-variable remember-save-after-remembering t "Non-nil means automatically save after remembering." :type boolean :group remember remember-annotation-functions '(buffer-file-name) "Hook that returns an annotation to be inserted into the remember buffer." hook :options (org-remember-annotation buffer-file-name)] 10)
#@21 Current annotation.
(defvar remember-annotation nil (#$ . 2384))
#@51 Initial contents to place into *Remember* buffer.
(defvar remember-initial-contents nil (#$ . 2455))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\302\311\304\312\306\307&\207" [custom-declare-variable remember-before-remember-hook nil "Functions run before switching to the *Remember* buffer." :type hook :group remember remember-run-all-annotation-functions-flag "Non-nil means use all annotations returned by `remember-annotation-functions'." boolean] 8)
#@212 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 or a visible region, use the region as INITIAL.
(defalias 'remember #[(&optional initial) "\203\306\202	\307	!\210\n\203\310\311\312\313\314\315\"\"\316#\202!\317\303!\320
!\321\322!\210\2033\323\2024\324!\210\203E\325\326p\327 \"\330\"\210\330\331 \210deU\203| \203Z c\210\f!\"\203f\"c\210\f;\203v\f\332\232\204v\333\f\261\210\313\"eb\210\334\335!*\207" [remember-in-new-frame remember-register remember-run-all-annotation-functions-flag remember-annotation-functions annotation remember-buffer frameset-to-register window-configuration-to-register mapconcat identity delq nil mapcar funcall "\n" run-hook-with-args-until-success get-buffer-create run-hooks remember-before-remember-hook switch-to-buffer-other-frame switch-to-buffer-other-window set-window-dedicated-p get-buffer-window selected-frame t remember-mode "" "\n\n" message "Use C-c C-c to remember the data." buf buffer-offer-save initial remember-annotation remember-initial-contents] 7 (#$ . 2934) (list (if (or current-prefix-arg (and mark-active transient-mark-mode)) (progn (buffer-substring (region-beginning) (region-end)))))])
#@35 Call `remember' in another frame.
(defalias 'remember-other-frame #[(&optional initial) "\302\303	!)\207" [remember-in-new-frame initial t remember] 2 (#$ . 4235) (list (if current-prefix-arg (progn (buffer-substring (point) (mark)))))])
#@39 Return a simple date.  Nothing fancy.
(defalias 'remember-mail-date #[(&optional rfc822-p) "\301\203	\302\202\n\303!\207" [rfc822-p format-time-string "%a, %e %b %Y %T %z" "%a %b %e %T %Y"] 2 (#$ . 4480)])
(put 'remember-mail-date 'byte-optimizer 'byte-compile-inline-expand)
#@73 Using the first line of the current buffer, create a short description.
(defalias 'remember-buffer-desc #[nil "e\212eb\210\300\210`eZ\301V\203e\301\\b\210`){\207" [nil 60] 3 (#$ . 4765)])
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\207" [custom-declare-variable remember-mailbox "~/Mail/remember" "The file in which to store remember data as mail." :type file :group remember remember-default-priority "medium" "The default priority for remembered mail messages." string] 8)
#@232 Store remember data as if it were incoming mail.
In which case `remember-mailbox' should be the name of the mailbox.
Each piece of pseudo-mail created will have an `X-Todo-Priority'
field, for the purpose of appropriate splitting.
(defalias 'remember-store-in-mailbox #[nil "\306\307!\310\311!\312 \313 \314\315!r\fq\210\316\216\317\320\321 \322\310
\203'\323\202(\324!)\325\310
\2035\323\2026\324!)\n\326 \327 	&c\210` c\210n\204T\330c\210\330c\210 b\210\331\332\322\325#\203j\333\334!\210\202[)\335ed!#\210.\325\207" [text desc moment who #1=#:temp-buffer rfc822-p read-string "Who is this item related to? " format-time-string "%s" remember-buffer-desc buffer-string generate-new-buffer " *temp*" #[nil "\301!\205	\302!\207" [#1# buffer-name kill-buffer] 2] format "From %s  %s\nDate: %s\nFrom: %s\nMessage-Id: <remember-%s@%s>\nX-Todo-Priority: %s\nTo: %s <%s>\nSubject: %s\n\n" user-login-name nil "%a, %e %b %Y %T %z" "%a %b %e %T %Y" t system-name user-full-name "\n" re-search-forward "^\\(From[: ]\\)" replace-match ">\\1" append-to-file remember-default-priority user-mail-address here remember-mailbox] 12 (#$ . 5291)])
(byte-code "\300\301\302\303\304\305\306\307\310\311\312\313\314\315&
\210\300\316\317\320\306\321\314\315&\210\300\322\323\324\306\321\314\315\304\325&	\207" [custom-declare-variable remember-data-file (locate-user-emacs-file "notes" ".notes") "The file in which to store unprocessed data.\nWhen set via customize, visited file of the notes buffer (if it\nexists) might be changed." :version "24.4" :type file :set #[(symbol value) "\304\305!!\306\n\"\210\307	!\205r	q\210\310\311!!))\207" [symbol buf value remember-data-file find-buffer-visiting default-value set-default buffer-live-p set-visited-file-name expand-file-name] 3] :initialize custom-initialize-default :group remember remember-leader-text "** " "The text used to begin each remember item." string remember-time-format "%a %b %d %H:%M:%S %Y" "The format for time stamp, passed to `format-time-string'.\nThe default emulates `current-time-string' for backward compatibility." "27.1"] 14)
#@50 Remember, with description DESC, the given TEXT.
(defalias 'remember-append-to-file #[nil "\306 \307 \310\n\311!\312	\313\212db\210n?\205\310)\260\314
!\211\203>rq\210\212db\210\fc\210)\205:\315 )\202C\316\f\317
#,\207" [text desc remember-leader-text remember-time-format remember-text remember-data-file buffer-string remember-buffer-desc "\n" format-time-string " (" ")\n\n" find-buffer-visiting save-buffer append-to-file nil buf remember-save-after-remembering] 9 (#$ . 7417)])
#@318 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: \[universal-argument] \[remember] RET.
(defalias 'remember-region #[(&optional beg end) "\206\f`\305 \206e^	\206`\305 \206d]\214\n}\210\f\203*\306\307!\210\202.\310\307!\210\311 +\207" [beg end e b remember-all-handler-functions mark run-hooks remember-handler-functions run-hook-with-args-until-success remember-destroy] 3 (#$ . 7924) nil])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\315\306\307\310\311&	\207" [custom-declare-variable remember-data-directory "~/remember" "The directory in which to store remember data as files.\nUsed by `remember-store-in-files'." :type directory :version "24.4" :group remember remember-directory-file-name-format "%Y-%m-%d_%T-%z" "Format string for the file name in which to store unprocessed data.\nThis is passed to `format-time-string'.\nUsed by `remember-store-in-files'." string] 10)
#@177 Store remember data in a file in `remember-data-directory'.
The file is named by calling `format-time-string' using
`remember-directory-file-name-format' as the format string.
(defalias 'remember-store-in-files #[nil "\305!\306 \307\310!rq\210\311\216	c\210\312\313\314\315\f\n#!!-\207" [remember-directory-file-name-format text name #1=#:temp-buffer remember-data-directory format-time-string buffer-string generate-new-buffer " *temp*" #[nil "\301!\205	\302!\207" [#1# buffer-name kill-buffer] 2] write-file convert-standard-filename format "%s/%s"] 6 (#$ . 9086)])
#@109 Remember the contents of the current clipboard.
Most useful for remembering things from other applications.
(defalias 'remember-clipboard #[nil "\300\301\302!!\207" [remember current-kill 0] 3 (#$ . 9669) nil])
#@46 Remember the contents of the current buffer.
(defalias 'remember-finalize #[nil "\300ed\"\207" [remember-region] 3 (#$ . 9886) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias remember-buffer remember-finalize nil make-obsolete "23.1"] 4)
#@40 Destroy the current *Remember* buffer.
(defalias 'remember-destroy #[nil "\302 \232\205\303p!\210\304	!\207" [remember-buffer remember-register buffer-name kill-buffer jump-to-register] 2 (#$ . 10154) nil])
#@91 File for extracted diary entries.
If this is nil, then `diary-file' will be used instead.
(custom-declare-variable 'remember-diary-file nil '(#$ . 10370) :type '(choice (const :tag "diary-file" nil) file) :group 'remember)
#@46 Translate MSG to an entry readable by diary.
(defalias 'remember-diary-convert-entry #[(entry) "\304 \305\216	\203\n\306	Q\307\310\n\"\203]\311\312!\210\313\314\267\202F\315\316\n\"\317\315\320\n\"\317\315\321\n\"\260\202V\315\321\n\"\322\315\320\n\"\322\315\316\n\"\260\202V\315\320\n\"\317\315\316\n\"\317\315\321\n\"\260\323\211\n$\202^\n*\207" [save-match-data-internal remember-annotation entry calendar-date-style match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] " " string-match "\\([0-9]+\\)\\.\\([0-9]+\\)\\.\\([0-9]+\\)" require calendar replace-match #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (european 32 iso 51)) match-string 3 "/" 2 1 "-" t] 8 (#$ . 10599)])
(autoload 'diary-make-entry "diary-lib")
#@40 Extract diary entries from the region.
(defalias 'remember-diary-extract-entries #[nil "\212eb\210\302\303\304\302\305#\203\306\307\310!!B\202\203'\311\312\313\314#\302	#\210*\302\207" [list remember-diary-file nil re-search-forward "^DIARY:\\s-*\\(.+\\)" t remember-diary-convert-entry match-string 1 diary-make-entry mapconcat identity "\n"] 5 (#$ . 11416)])
#@33 Keymap used in `remember-mode'.
(defvar remember-mode-map (byte-code "\301 \302\303\304#\210\302\305\304#\210\302\306\307#\210)\207" [map make-sparse-keymap define-key "" remember-finalize "" "" remember-destroy] 4) (#$ . 11793))
(defvar remember-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [remember-mode-hook variable-documentation put "Hook run after entering Remember mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp remember-mode-map definition-name remember-mode] 4)
(defvar remember-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [remember-mode-abbrev-table remember-mode-map variable-documentation put purecopy "Keymap for `remember-mode'." boundp remember-mode-syntax-table definition-name remember-mode (lambda (#1=#:def-tmp-var) (defvar remember-mode-syntax-table #1#)) make-syntax-table "Syntax table for `remember-mode'." (lambda (#1#) (defvar remember-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `remember-mode'." derived-mode-parent indented-text-mode] 5)
#@461 Major mode for output from \[remember].
This buffer is used to collect data that you want to remember.
\<remember-mode-map>
Just hit \[remember-finalize] when you're done entering, and it will file
the data away for latter retrieval, and possible indexing.

\{remember-mode-map}

In addition to any hooks its parent mode `indented-text-mode' might have run,
this mode runs the hook `remember-mode-hook', as the final or penultimate step
during initialization.
(defalias 'remember-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210\316\331\"\210)\332\333!\207" [delay-mode-hooks major-mode mode-name remember-mode-map remember-mode-syntax-table parent make-local-variable t indented-text-mode remember-mode "Remember" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table nil run-mode-hooks remember-mode-hook remember-mode-abbrev-table local-abbrev-table] 6 (#$ . 13218) nil])
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\210\300\314\315\316\304\317\306\307&\207" [custom-declare-variable remember-notes-buffer-name "*notes*" "Name of the notes buffer.\nSetting it to *scratch* will hijack the *scratch* buffer for the\npurpose of storing notes." :type string :version "24.4" remember-notes-initial-major-mode nil "Major mode to use in the notes buffer when it's created.\nIf this is nil, use `initial-major-mode'." (choice (const :tag "Use `initial-major-mode'" nil) (function :tag "Major mode" text-mode)) remember-notes-bury-on-kill t "Non-nil means `kill-buffer' will bury the notes buffer instead of killing." boolean] 8)
#@55 Save (if it is modified) and bury the current buffer.
(defalias 'remember-notes-save-and-bury-buffer #[nil "\300 \203\301 \210\302 \207" [buffer-modified-p save-buffer bury-buffer] 1 (#$ . 15142) nil])
#@39 Keymap used in `remember-notes-mode'.
(defvar remember-notes-mode-map (byte-code "\301 \302\303\304#\210)\207" [map make-sparse-keymap define-key "" remember-notes-save-and-bury-buffer] 4) (#$ . 15352))
#@107 Non-nil if Remember-Notes mode is enabled.
Use the command `remember-notes-mode' to change this variable.
(defvar remember-notes-mode nil (#$ . 15567))
(make-variable-buffer-local 'remember-notes-mode)
#@429 Minor mode for the `remember-notes' buffer.
This sets `buffer-save-without-query' so that `save-some-buffers' will
save the notes buffer without asking.

If called interactively, enable Remember-Notes mode if ARG is
positive, and disable it if ARG is zero or negative.  If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.

\{remember-notes-mode-map}
(defalias 'remember-notes-mode #[(&optional arg) "\305 	\306=\203\n?\202\307	!\310V\211\203!\311\312\313\314\315$\210\315\316\317\n\203+\320\202,\321\"\210\322\323!\203Q\305 \203@\305 \232\203Q\324\325\326\n\203L\327\202M\330\f#\210))\331 \210\n\207" [#1=#:last-message arg remember-notes-mode buffer-save-without-query local current-message toggle prefix-numeric-value 0 add-hook kill-buffer-query-functions remember-notes--kill-buffer-query nil t run-hooks remember-notes-mode-hook remember-notes-mode-on-hook remember-notes-mode-off-hook called-interactively-p any " in current buffer" message "Remember-Notes mode %sabled%s" "en" "dis" force-mode-line-update] 6 (#$ . 15776) (list (or current-prefix-arg 'toggle))])
(defvar remember-notes-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\300!\205\307\211%\207" [remember-notes-mode-map remember-notes-mode-hook variable-documentation put "Hook run after entering or leaving `remember-notes-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode remember-notes-mode nil boundp] 6)
#@877 Return the notes buffer, creating it if needed, and maybe switch to it.
This buffer is for notes that you want to preserve across Emacs sessions.
The notes are saved in `remember-data-file'.

If a buffer is already visiting that file, just return it.

Otherwise, create the buffer, and rename it to `remember-notes-buffer-name',
unless a buffer of that name already exists.  Set the major mode according
to `remember-notes-initial-major-mode', and enable `remember-notes-mode'
minor mode.

Use \<remember-notes-mode-map>\[remember-notes-save-and-bury-buffer] to save and bury the notes buffer.

Interactively, or if SWITCH-TO is non-nil, switch to the buffer.
Return the buffer.

Set `initial-buffer-choice' to `remember-notes' to visit your notes buffer
when Emacs starts.  Set `remember-notes-buffer-name' to "*scratch*"
to turn the *scratch* buffer into your notes buffer.
(defalias 'remember-notes #[(&optional switch-to) "\306!\206'r\307!q\210	\203\310	!\204\311	!\210\n\206 \210\312\313!\210p)
\2030\314\f!\210\f)\207" [remember-data-file remember-notes-buffer-name remember-notes-initial-major-mode initial-major-mode buf switch-to find-buffer-visiting find-file-noselect get-buffer rename-buffer remember-notes-mode 1 switch-to-buffer] 2 (#$ . 17392) "p"])
#@203 Function that `remember-notes-mode' adds to `kill-buffer-query-functions'.
Save the current buffer if modified.  If `remember-notes-bury-on-kill'
is non-nil, bury it and return nil; otherwise return t.
(defalias 'remember-notes--kill-buffer-query #[nil "\301 \203\302 \210\203\303 \210\304\207\305\207" [remember-notes-bury-on-kill buffer-modified-p save-buffer bury-buffer nil t] 1 (#$ . 18676)])
(provide 'remember)