1 \input texinfo @c -*-texinfo-*-
3 @setfilename ../../info/remember
4 @settitle Remember Manual
9 * Remember: (remember). Simple information manager for Emacs
15 This manual is for Remember Mode, version 1.9
17 Copyright @copyright{} 2001, 2004, 2005, 2007, 2008
18 Free Software Foundation, Inc.
21 Permission is granted to copy, distribute and/or modify this document
22 under the terms of the GNU Free Documentation License, Version 1.2
23 or any later version published by the Free Software Foundation;
24 with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
25 Texts. A copy of the license is included in the section entitled ``GNU
26 Free Documentation License''.
31 @title Guide to Remember Mode
32 @subtitle a simple information manager
33 @subtitle for Emacs and XEmacs
35 @c The following two commands
36 @c start the copyright page.
38 @vskip 0pt plus 1filll
42 @c So the toc is printed at the start
46 @node Top, Preface, (dir), (dir)
47 @comment node-name, next, previous, up
54 * Preface:: About the documentation.
55 * Introduction:: What is Remember Mode?
56 * Installation:: How to install Remember.
57 * Implementation:: How Remember came into existence.
58 * Quick Start:: Get started using Remember.
59 * Function Reference:: Interactive functions in remember.el.
60 * Keystrokes:: Keystrokes bound in Remember Mode.
61 * Backends:: Backends for saving notes.
62 * GNU Free Documentation License:: The license for this documentation.
63 * Concept Index:: Search for terms.
66 --- The Detailed Node Listing ---
70 * Text File:: Saving to a text file.
71 * Diary:: Saving to a Diary file.
72 * Mailbox:: Saving to a mailbox.
73 * Org:: Saving to an Org Mode file.
78 @node Preface, Introduction, Top, Top
79 @comment node-name, next, previous, up
82 This document describes remember-el, which was written by John Wiegley,
83 was once maintained by Sacha Chua, and is now maintained by the Emacs
86 This document is a work in progress, and your contribution will be
89 @node Introduction, Installation, Preface, Top
90 @comment node-name, next, previous, up
93 Todo lists, schedules, phone databases... everything we use databases
94 for is really just a way to extend the power of our memory, to be able
95 to remember what our conscious mind may not currently have access to.
97 There are many different databases out there---and good ones---which
98 this mode is not trying to replace. Rather, it's how that data gets
99 there that's the question. Most of the time, we just want to say
100 "Remember so-and-so's phone number, or that I have to buy dinner for the
101 cats tonight." That's the FACT. How it's stored is really the
102 computer's problem. But at this point in time, it's most definitely
103 also the user's problem, and sometimes so laboriously so that people
104 just let data slip, rather than expend the effort to record it.
106 ``Remember'' is a mode for remembering data. It uses whatever
107 back-end is appropriate to record and correlate the data, but its main
108 intention is to allow you to express as @emph{little} structure as
109 possible up front. If you later want to express more powerful
110 relationships between your data, or state assumptions that were at
111 first too implicit to be recognized, you can ``study'' the data later
112 and rearrange it. But the initial ``just remember this'' impulse
113 should be as close to simply throwing the data at Emacs as possible.
115 Have you ever noticed that having a laptop to write on doesn't
116 @emph{actually} increase the amount of quality material that you turn
117 out, in the long run? Perhaps it's because the time we save
118 electronically in one way, we're losing electronically in another; the
119 tool should never dominate one's focus. As the mystic Faridu'd-Din
120 `Attar wrote: ``Be occupied as little as possible with things of the
121 outer world but much with things of the inner world; then right action
122 will overcome inaction.''
124 If Emacs could become a more intelligent data store, where brainstorming
125 would focus on the @emph{ideas} involved---rather than the structuring
126 and format of those ideas, or having to stop your current flow of work
127 in order to record them---it would map much more closely to how the mind
128 (well, at least mine) works, and hence would eliminate that very
129 manual-ness which computers from the very beginning have been championed
130 as being able to reduce.
132 @node Installation, Implementation, Introduction, Top
133 @comment node-name, next, previous, up
134 @chapter Installation
136 Installing Remember Mode is as simple as adding the following lines to
137 your Emacs configuration file (usually @file{~/.emacs.d/init.el} or
141 (add-to-list 'load-path "/path/to/remember")
145 @node Implementation, Quick Start, Installation, Top
146 @comment node-name, next, previous, up
147 @chapter Implementation
149 Hyperbole, as a data presentation tool, always struck me as being very
150 powerful, but it seemed to require a lot of ``front-end'' work before
151 that data was really available. The problem with BBDB, or keeping up
152 a Bibl-mode file, is that you have to use different functions to
153 record the data, and it always takes time to stop what you're doing,
154 format the data in the manner expected by that particular data
155 interface, and then resume your work.
157 With ``remember'', you just hit @kbd{M-x remember} (you'd probably
158 want to bind this to an easily accessible keystroke, like @kbd{C-x
159 M-r}), slam in your text however you like, and then hit @kbd{C-c C-c}.
160 It will file the data away for later retrieval, and possibly indexing.
162 Indexing is to data what ``studying'' is in the real world. What you do
163 when you study (or lucubrate, for some of us) is to realize certain
164 relationships implicit in the data, so that you can make use of those
165 relationships. Expressing that a certain quote you remembered was a
166 literary quote, and that you want the ability to pull up all quotes of a
167 literary nature, is what studying does. This is a more labor intensive
168 task than the original remembering of the data, and it's typical in real
169 life to set aside a special period of time for doing this work.
171 ``Remember'' works in the same way. When you enter data, either by
172 typing it into a buffer, or using the contents of the selected region,
173 it will store that data---unindexed, uninterpreted---in a data pool.
174 It will also try to remember as much context information as possible
175 (any text properties that were set, where you copied it from, when,
176 how, etc). Later, you can walk through your accumulated set of data
177 (both organized, and unorganized) and easily begin moving things
178 around, and making annotations that will express the full meaning of
179 that data, as far as you know it.
181 Obviously this latter stage is more user-interface intensive, and it
182 would be nice if ``remember'' could do it as elegantly as possible,
183 rather than requiring a billion keystrokes to reorganize your
184 hierarchy. Well, as the future arrives, hopefully experience and user
185 feedback will help to make this as intuitive a tool as possible.
187 @node Quick Start, Function Reference, Implementation, Top
188 @comment node-name, next, previous, up
194 Load @file{remember.el}.
197 Type @kbd{M-x remember}. The @samp{*Remember*} buffer should be
201 Type in what you want to remember. The first line will be treated as
202 the headline, and the rest of the buffer will contain the body of the
206 Type @kbd{C-c C-c} (@code{remember-finalize}) to save the note and close
207 the @samp{*Remember*} buffer.
210 By default, @code{remember-finalize} saves the note in @file{~/.notes}.
211 You can edit it now to see the remembered and timestamped note. You
212 can edit this file however you want. New entries will always be added
215 To remember a region of text, use the universal prefix. @kbd{C-u M-x
216 remember} displays a @samp{*Remember*} buffer with the region as the
219 As a simple beginning, you can start by using the Text File backend,
220 keeping your @file{~/.notes} file in outline-mode format, with a final
221 entry called @samp{* Raw data}. Remembered data will be added to the
222 end of the file. Every so often, you can move the data that gets
223 appended there into other files, or reorganize your document.
225 You can also store remembered data in other backends.
228 Here is one way to map the remember functions in your @file{.emacs} to
229 very accessible keystrokes facilities using the mode:
232 (autoload 'remember ``remember'' nil t)
233 (autoload 'remember-region ``remember'' nil t)
235 (define-key global-map (kbd "<f9> r") 'remember)
236 (define-key global-map (kbd "<f9> R") 'remember-region)
239 By default, remember uses the first annotation returned by
240 @code{remember-annotation-functions}. To include all of the annotations,
241 set @code{remember-run-all-annotation-functions-flag} to non-nil.
243 @defopt remember-run-all-annotation-functions-flag
244 Non-nil means use all annotations returned by
245 @code{remember-annotation-functions}.
248 You can write custom functions that use a different set of
249 remember-annotation-functions. For example:
252 (defun my/remember-with-filename ()
253 "Always use the filename."
255 (let ((remember-annotation-functions '(buffer-file-name)))
256 (call-interactively 'remember)))
259 @node Function Reference, Keystrokes, Quick Start, Top
260 @comment node-name, next, previous, up
261 @chapter Function Reference
263 @file{remember.el} defines the following interactive functions:
265 @defun remember initial
266 Remember an arbitrary piece of data. With a prefix, it will use the
267 region as @var{initial}.
270 @defun remember-region beg end
271 If called from within the remember buffer, @var{beg} and @var{end} are
272 ignored, and the entire buffer will be remembered. If called from any
273 other buffer, that region, plus any context information specific to
274 that region, will be remembered.
277 @defun remember-clipboard
278 Remember the contents of the current clipboard. This is most useful
279 for remembering things from Netscape or other X Windows applications.
282 @defun remember-finalize
283 Remember the contents of the current buffer.
287 This enters the major mode for output from @command{remember}. This
288 buffer is used to collect data that you want remember. Just hit
289 @kbd{C-c C-c} when you're done entering, and it will go ahead and file
290 the data for latter retrieval, and possible indexing.
293 @node Keystrokes, Backends, Function Reference, Top
294 @comment node-name, next, previous, up
295 @chapter Keystroke Reference
297 @file{remember.el} defines the following keybindings by default:
301 @item C-c C-c (`remember-finalize')
302 Remember the contents of the current buffer.
304 @item C-c C-k (`remember-destroy')
305 Destroy the current *Remember* buffer.
307 @item C-x C-s (`remember-finalize')
308 Remember the contents of the current buffer.
312 @node Backends, GNU Free Documentation License, Keystrokes, Top
313 @comment node-name, next, previous, up
316 You can save remembered notes to a variety of backends.
319 * Text File:: Saving to a text file.
320 * Diary:: Saving to a Diary file.
321 * Mailbox:: Saving to a mailbox.
322 * Org:: Saving to an Org Mode file.
325 @node Text File, Diary, Backends, Backends
326 @comment node-name, next, previous, up
327 @section Saving to a Text File
328 @cindex text file, saving to
330 @subheading Insinuation
333 (setq remember-handler-functions '(remember-append-to-file))
338 @defopt remember-data-file
339 The file in which to store unprocessed data.
342 @defopt remember-leader-text
343 The text used to begin each remember item.
346 @node Diary, Mailbox, Text File, Backends
347 @comment node-name, next, previous, up
348 @section Saving to a Diary file
349 @cindex diary, integration
351 @subheading Insinuation
354 (add-to-list 'remember-handler-functions 'remember-diary-extract-entries)
359 @defopt remember-diary-file
360 File for extracted diary entries.
361 If this is nil, then @code{diary-file} will be used instead."
364 @node Mailbox, Org, Diary, Backends
365 @comment node-name, next, previous, up
366 @section Saving to a Mailbox
367 @cindex mailbox, saving to
369 @subheading Insinuation
372 (add-to-list 'remember-handler-functions 'remember-store-in-mailbox)
377 @defopt remember-mailbox
378 The file in which to store remember data as mail.
381 @defopt remember-default-priority
382 The default priority for remembered mail messages.
385 @node Org, , Mailbox, Backends
386 @comment node-name, next, previous, up
387 @section Saving to an Org Mode file
388 @cindex org mode, integration
390 For instructions on how to integrate Remember with Org Mode,
391 consult @ref{Remember, , , org}.
393 @node GNU Free Documentation License, Concept Index, Backends, Top
394 @appendix GNU Free Documentation License
395 @include doclicense.texi
397 @node Concept Index, , GNU Free Documentation License, Top
398 @comment node-name, next, previous, up
406 arch-tag: 5b980db0-20cc-4167-b845-52dc11d53b9f