Imported Upstream version 7.9.2

1 files changed, 1152 insertions, 0 deletions

diff --git a/lisp/org-remember.el b/lisp/org-remember.el
new file mode 100644
index 0000000..7a1eb77
--- /dev/null
+++ b/lisp/org-remember.el
@@ -0,0 +1,1152 @@
+;;; org-remember.el --- Fast note taking in Org-mode
+
+;; Copyright (C) 2004-2012 Free Software Foundation, Inc.
+
+;; Author: Carsten Dominik <carsten at orgmode dot org>
+;; Keywords: outlines, hypermedia, calendar, wp
+;; Homepage: http://orgmode.org
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Commentary:
+
+;; This file contains the system to take fast notes with Org-mode.
+;; This system is used together with John Wiegley's `remember.el'.
+
+;;; Code:
+
+(eval-when-compile
+  (require 'cl))
+(require 'org)
+(require 'org-compat)
+(require 'org-datetree)
+
+(declare-function remember-mode "remember" ())
+(declare-function remember "remember" (&optional initial))
+(declare-function remember-buffer-desc "remember" ())
+(declare-function remember-finalize "remember" ())
+(declare-function org-pop-to-buffer-same-window
+		  "org-compat" (&optional buffer-or-name norecord label))
+
+(defvar remember-save-after-remembering)
+(defvar remember-register)
+(defvar remember-buffer)
+(defvar remember-handler-functions)
+(defvar remember-annotation-functions)
+(defvar org-clock-heading)
+(defvar org-clock-heading-for-remember)
+
+(defgroup org-remember nil
+  "Options concerning interaction with remember.el."
+  :tag "Org Remember"
+  :group 'org)
+
+(defcustom org-remember-store-without-prompt t
+  "Non-nil means \\<org-remember-mode-map>\\[org-remember-finalize] \
+stores the remember note without further prompts.
+It then uses the file and headline specified by the template or (if the
+template does not specify them) by the variables `org-default-notes-file'
+and `org-remember-default-headline'.  To force prompting anyway, use
+\\[universal-argument] \\[org-remember-finalize] to file the note.
+
+When this variable is nil, \\[org-remember-finalize] gives you the prompts, and
+\\[universal-argument] \\[org-remember-finalize] triggers the fasttrack."
+  :group 'org-remember
+  :type 'boolean)
+
+(defcustom org-remember-interactive-interface 'refile
+  "The interface to be used for interactive filing of remember notes.
+This is only used when the interactive mode for selecting a filing
+location is used (see the variable `org-remember-store-without-prompt').
+Allowed values are:
+outline                  The interface shows an outline of the relevant file
+                         and the correct heading is found by moving through
+                         the outline or by searching with incremental search.
+outline-path-completion  Headlines in the current buffer are offered via
+                         completion.
+refile                   Use the refile interface, and offer headlines,
+                         possibly from different buffers."
+  :group 'org-remember
+  :type '(choice
+	  (const :tag "Refile" refile)
+	  (const :tag "Outline" outline)
+	  (const :tag "Outline-path-completion" outline-path-completion)))
+
+(defcustom org-remember-default-headline ""
+  "The headline that should be the default location in the notes file.
+When filing remember notes, the cursor will start at that position.
+You can set this on a per-template basis with the variable
+`org-remember-templates'."
+  :group 'org-remember
+  :type 'string)
+
+(defcustom org-remember-templates nil
+  "Templates for the creation of remember buffers.
+When nil, just let remember make the buffer.
+When non-nil, this is a list of (up to) 6-element lists.  In each entry,
+the first element is the name of the template, which should be a single
+short word.  The second element is a character, a unique key to select
+this template.  The third element is the template.
+
+The fourth element is optional and can specify a destination file for
+remember items created with this template.  The default file is given
+by `org-default-notes-file'.  If the file name is not an absolute path,
+it will be interpreted relative to `org-directory'.
+
+An optional fifth element can specify the headline in that file that should
+be offered first when the user is asked to file the entry.  The default
+headline is given in the variable `org-remember-default-headline'.  When
+this element is `top' or `bottom', the note will be placed as a level-1
+entry at the beginning or end of the file, respectively.
+
+An optional sixth element specifies the contexts in which the template
+will be offered to the user.  This element can be a list of major modes
+or a function, and the template will only be offered if `org-remember'
+is called from a mode in the list, or if the function returns t.
+Templates that specify t or nil for the context will always be added
+to the list of selectable templates.
+
+The template specifies the structure of the remember buffer.  It should have
+a first line starting with a star, to act as the org-mode headline.
+Furthermore, the following %-escapes will be replaced with content:
+
+  %^{PROMPT}  prompt the user for a string and replace this sequence with it.
+              A default value and a completion table can be specified like this:
+              %^{prompt|default|completion2|completion3|...}
+              The arrow keys access a prompt-specific history.
+  %a          annotation, normally the link created with `org-store-link'
+  %A          like %a, but prompt for the description part
+  %i          initial content, copied from the active region.  If %i is
+              indented, the entire inserted text will be indented as well.
+  %t          time stamp, date only
+  %T          time stamp with date and time
+  %u, %U      like the above, but inactive time stamps
+  %^t         like %t, but prompt for date.  Similarly %^T, %^u, %^U.
+              You may define a prompt like %^{Please specify birthday}t
+  %n          user name (taken from `user-full-name')
+  %c          current kill ring head
+  %x          content of the X clipboard
+  %:keyword   specific information for certain link types, see below
+  %^C         interactive selection of which kill or clip to use
+  %^L         like %^C, but insert as link
+  %k          title of the currently clocked task
+  %K          link to the currently clocked task
+  %^g         prompt for tags, completing tags in the target file
+  %^G         prompt for tags, completing all tags in all agenda files
+  %^{PROP}p   Prompt the user for a value for property PROP
+  %[PATHNAME] insert the contents of the file given by PATHNAME
+  %(SEXP)     evaluate elisp `(SEXP)' and replace with the result
+  %!          store this note immediately after completing the template\
+              \\<org-remember-mode-map>
+              (skipping the \\[org-remember-finalize] that normally triggers storing)
+  %&          jump to target location immediately after storing note
+  %?          after completing the template, position cursor here.
+
+Apart from these general escapes, you can access information specific to the
+link type that is created.  For example, calling `remember' in emails or gnus
+will record the author and the subject of the message, which you can access
+with %:fromname and %:subject, respectively.  Here is a complete list of what
+is recorded for each link type.
+
+Link type          |  Available information
+-------------------+------------------------------------------------------
+bbdb               |  %:type %:name %:company
+vm, wl, mh, rmail  |  %:type %:subject %:message-id
+                   |  %:from %:fromname %:fromaddress
+                   |  %:to   %:toname   %:toaddress
+                   |  %:fromto (either \"to NAME\" or \"from NAME\")
+gnus               |  %:group, for messages also all email fields and
+                   |  %:org-date (the Date: header in Org format)
+w3, w3m            |  %:type %:url
+info               |  %:type %:file %:node
+calendar           |  %:type %:date"
+  :group 'org-remember
+  :get (lambda (var) ; Make sure all entries have at least 5 elements
+	 (mapcar (lambda (x)
+		   (if (not (stringp (car x))) (setq x (cons "" x)))
+		   (cond ((= (length x) 4) (append x '(nil)))
+			 ((= (length x) 3) (append x '(nil nil)))
+			 (t x)))
+		 (default-value var)))
+  :type '(repeat
+	  :tag "enabled"
+	  (list :value ("" ?a "\n" nil nil nil)
+		(string :tag "Name")
+		(character :tag "Selection Key")
+		(string :tag "Template")
+		(choice :tag "Destination file"
+			(file :tag "Specify")
+			(function :tag "Function")
+			(const :tag "Use `org-default-notes-file'" nil))
+		(choice :tag "Destin. headline"
+			(string :tag "Specify")
+			(function :tag "Function")
+			(const :tag "Use `org-remember-default-headline'" nil)
+			(const :tag "At beginning of file" top)
+			(const :tag "At end of file" bottom)
+			(const :tag "In a date tree" date-tree))
+		(choice :tag "Context"
+			(const :tag "Use in all contexts" nil)
+			(const :tag "Use in all contexts" t)
+			(repeat :tag "Use only if in major mode"
+				(symbol :tag "Major mode"))
+			(function :tag "Perform a check against function")))))
+
+(defcustom org-remember-delete-empty-lines-at-end t
+  "Non-nil means clean up final empty lines in remember buffer."
+  :group 'org-remember
+  :type 'boolean)
+
+(defcustom org-remember-before-finalize-hook nil
+  "Hook that is run right before a remember process is finalized.
+The remember buffer is still current when this hook runs."
+  :group 'org-remember
+  :type 'hook)
+
+(defvar org-remember-mode-map (make-sparse-keymap)
+  "Keymap for `org-remember-mode', a minor mode.
+Use this map to set additional keybindings for when Org-mode is used
+for a Remember buffer.")
+(defvar org-remember-mode-hook nil
+  "Hook for the minor `org-remember-mode'.")
+
+(define-minor-mode org-remember-mode
+  "Minor mode for special key bindings in a remember buffer."
+  nil " Rem" org-remember-mode-map
+  (run-hooks 'org-remember-mode-hook))
+(define-key org-remember-mode-map "\C-c\C-c" 'org-remember-finalize)
+(define-key org-remember-mode-map "\C-c\C-k" 'org-remember-kill)
+
+(defcustom org-remember-clock-out-on-exit 'query
+  "Non-nil means stop the clock when exiting a clocking remember buffer.
+This only applies if the clock is running in the remember buffer.  If the
+clock is not stopped, it continues to run in the storage location.
+Instead of nil or t, this may also be the symbol `query' to prompt the
+user each time a remember buffer with a running clock is filed away."
+  :group 'org-remember
+  :type '(choice
+	  (const :tag "Never" nil)
+	  (const :tag "Always" t)
+	  (const :tag "Query user" query)))
+
+(defcustom org-remember-backup-directory nil
+  "Directory where to store all remember buffers, for backup purposes.
+After a remember buffer has been stored successfully, the backup file
+will be removed.  However, if you forget to finish the remember process,
+the file will remain there.
+See also `org-remember-auto-remove-backup-files'."
+  :group 'org-remember
+  :type '(choice
+	  (const :tag "No backups" nil)
+	  (directory :tag "Directory")))
+
+(defcustom org-remember-auto-remove-backup-files t
+  "Non-nil means remove remember backup files after successfully storage.
+When remember is finished successfully, with storing the note at the
+desired target, remove the backup files related to this remember process
+and show a message about remaining backup files, from previous, unfinished
+remember sessions.
+Backup files will only be made at all, when `org-remember-backup-directory'
+is set."
+  :group 'org-remember
+  :type 'boolean)
+
+(defcustom org-remember-warn-about-backups t
+  "Non-nil means warn about backup files in `org-remember-backup-directory'.
+
+Set this to nil if you find that you don't need the warning.
+
+If you cancel remember calls frequently and know when they
+contain useful information (because you know that you made an
+error or Emacs crashed, for example) nil is more useful.  In the
+opposite case, the default, t, is more useful."
+  :group 'org-remember
+  :type 'boolean)
+
+;;;###autoload
+(defun org-remember-insinuate ()
+  "Setup remember.el for use with Org-mode."
+  (org-require-remember)
+  (setq remember-annotation-functions '(org-remember-annotation))
+  (setq remember-handler-functions '(org-remember-handler))
+  (add-hook 'remember-mode-hook 'org-remember-apply-template))
+
+;;;###autoload
+(defun org-remember-annotation ()
+  "Return a link to the current location as an annotation for remember.el.
+If you are using Org-mode files as target for data storage with
+remember.el, then the annotations should include a link compatible with the
+conventions in Org-mode.  This function returns such a link."
+  (org-store-link nil))
+
+(defconst org-remember-help
+  "Select a destination location for the note.
+UP/DOWN=headline   TAB=cycle visibility  [Q]uit   RET/<left>/<right>=Store
+RET on headline   -> Store as sublevel entry to current headline
+RET at beg-of-buf -> Append to file as level 2 headline
+<left>/<right>    -> before/after current headline, same headings level")
+
+(defvar org-jump-to-target-location nil)
+(defvar org-remember-previous-location nil)
+(defvar org-remember-reference-date nil)
+(defvar org-force-remember-template-char) ;; dynamically scoped
+
+;; Save the major mode of the buffer we called remember from
+(defvar org-select-template-temp-major-mode nil)
+
+;; Temporary store the buffer where remember was called from
+(defvar org-select-template-original-buffer nil)
+
+(defun org-select-remember-template (&optional use-char)
+  (when org-remember-templates
+    (let* ((pre-selected-templates
+	    (mapcar
+	     (lambda (tpl)
+	       (let ((ctxt (nth 5 tpl))
+		     (mode org-select-template-temp-major-mode)
+		     (buf org-select-template-original-buffer))
+		 (and (or (not ctxt) (eq ctxt t)
+			  (and (listp ctxt) (memq mode ctxt))
+			  (and (functionp ctxt)
+			       (with-current-buffer buf
+				 ;; Protect the user-defined function from error
+				 (condition-case nil (funcall ctxt) (error nil)))))
+		      tpl)))
+	     org-remember-templates))
+	   ;; If no template at this point, add the default templates:
+	   (pre-selected-templates1
+	    (if (not (delq nil pre-selected-templates))
+		(mapcar (lambda(x) (if (not (nth 5 x)) x))
+			org-remember-templates)
+	      pre-selected-templates))
+	   ;; Then unconditionally add template for any contexts
+	   (pre-selected-templates2
+	    (append (mapcar (lambda(x) (if (eq (nth 5 x) t) x))
+			    org-remember-templates)
+		    (delq nil pre-selected-templates1)))
+	   (templates (mapcar (lambda (x)
+				(if (stringp (car x))
+				    (append (list (nth 1 x) (car x)) (cddr x))
+				  (append (list (car x) "") (cdr x))))
+			      (delq nil pre-selected-templates2)))
+	   msg
+	   (char (or use-char
+		     (cond
+		      ((= (length templates) 1)
+		       (caar templates))
+		      ((and (boundp 'org-force-remember-template-char)
+			    org-force-remember-template-char)
+		       (if (stringp org-force-remember-template-char)
+			   (string-to-char org-force-remember-template-char)
+			 org-force-remember-template-char))
+		      (t
+		       (setq msg (format
+				  "Select template: %s%s"
+				  (mapconcat
+				   (lambda (x)
+				     (cond
+				      ((not (string-match "\\S-" (nth 1 x)))
+				       (format "[%c]" (car x)))
+				      ((equal (downcase (car x))
+					      (downcase (aref (nth 1 x) 0)))
+				       (format "[%c]%s" (car x)
+					       (substring (nth 1 x) 1)))
+				      (t (format "[%c]%s" (car x) (nth 1 x)))))
+				   templates " ")
+				  (if (assoc ?C templates)
+				      ""
+				    " [C]customize templates")))
+		       (let ((inhibit-quit t) char0)
+			 (while (not char0)
+			   (message msg)
+			   (setq char0 (read-char-exclusive))
+			   (when (and (not (assoc char0 templates))
+				      (not (equal char0 ?\C-g))
+				      (not (equal char0 ?C)))
+			     (message "No such template \"%c\"" char0)
+			     (ding) (sit-for 1)
+			     (setq char0 nil)))
+			 (when (equal char0 ?\C-g)
+			   (jump-to-register remember-register)
+			   (kill-buffer remember-buffer)
+			   (error "Abort"))
+			 (when (not (assoc char0 templates))
+			   (jump-to-register remember-register)
+			   (kill-buffer remember-buffer)
+			   (customize-variable 'org-remember-templates)
+			   (error "Customize templates"))
+			 char0))))))
+      (cddr (assoc char templates)))))
+
+;;;###autoload
+(defun org-remember-apply-template (&optional use-char skip-interactive)
+  "Initialize *remember* buffer with template, invoke `org-mode'.
+This function should be placed into `remember-mode-hook' and in fact requires
+to be run from that hook to function properly."
+  (when (and (boundp 'initial) (stringp initial))
+    (setq initial (org-no-properties initial)))
+  (if org-remember-templates
+      (let* ((entry (org-select-remember-template use-char))
+	     (ct (or org-overriding-default-time (org-current-time)))
+	     (dct (decode-time ct))
+	     (ct1
+	      (if (< (nth 2 dct) org-extend-today-until)
+		  (encode-time 0 59 23 (1- (nth 3 dct)) (nth 4 dct) (nth 5 dct))
+		ct))
+	     (tpl (car entry))
+	     (plist-p (if org-store-link-plist t nil))
+	     (file (if (and (nth 1 entry)
+			    (or (and (stringp (nth 1 entry))
+				     (string-match "\\S-" (nth 1 entry)))
+				(functionp (nth 1 entry))))
+		       (nth 1 entry)
+		     org-default-notes-file))
+	     (headline (nth 2 entry))
+	     (v-c (and (> (length kill-ring) 0) (current-kill 0)))
+	     (v-x (or (org-get-x-clipboard 'PRIMARY)
+		      (org-get-x-clipboard 'CLIPBOARD)
+		      (org-get-x-clipboard 'SECONDARY)))
+	     (v-t (format-time-string (car org-time-stamp-formats) ct))
+	     (v-T (format-time-string (cdr org-time-stamp-formats) ct))
+	     (v-u (concat "[" (substring v-t 1 -1) "]"))
+	     (v-U (concat "[" (substring v-T 1 -1) "]"))
+	     ;; `initial' and `annotation' are bound in `remember'.
+	     ;; But if the property list has them, we prefer those values
+	     (v-i (or (plist-get org-store-link-plist :initial)
+		      (and (boundp 'initial) (symbol-value 'initial))
+		      ""))
+	     (v-a (or (plist-get org-store-link-plist :annotation)
+		      (and (boundp 'annotation) (symbol-value 'annotation))
+		      ""))
+	     ;; Is the link empty?  Then we do not want it...
+	     (v-a (if (equal v-a "[[]]") "" v-a))
+	     (clipboards (remove nil (list v-i
+					   (org-get-x-clipboard 'PRIMARY)
+					   (org-get-x-clipboard 'CLIPBOARD)
+					   (org-get-x-clipboard 'SECONDARY)
+					   v-c)))
+	     (v-A (if (and v-a
+			   (string-match "\\[\\(\\[.*?\\]\\)\\(\\[.*?\\]\\)?\\]" v-a))
+		      (replace-match "[\\1[%^{Link description}]]" nil nil v-a)
+		    v-a))
+	     (v-n user-full-name)
+	     (v-k (if (marker-buffer org-clock-marker)
+		      (org-no-properties org-clock-heading)))
+	     (v-K (if (marker-buffer org-clock-marker)
+		      (org-make-link-string
+		       (buffer-file-name (marker-buffer org-clock-marker))
+		       org-clock-heading)))
+	     v-I
+	     (org-startup-folded nil)
+	     (org-inhibit-startup t)
+	     org-time-was-given org-end-time-was-given x
+	     prompt completions char time pos default histvar)
+
+	(when (functionp file)
+	  (setq file (funcall file)))
+	(when (functionp headline)
+	  (setq headline (funcall headline)))
+	(when (and file (not (file-name-absolute-p file)))
+	  (setq file (expand-file-name file org-directory)))
+
+	(setq org-store-link-plist
+	      (plist-put org-store-link-plist :annotation v-a)
+	      org-store-link-plist
+	      (plist-put org-store-link-plist :initial v-i))
+
+	(unless tpl (setq tpl "") (message "No template") (ding) (sit-for 1))
+	(erase-buffer)
+	(insert (substitute-command-keys
+		 (format
+		  "## %s  \"%s\" -> \"* %s\"
+## C-u C-c C-c  like C-c C-c, and immediately visit note at target location
+## C-0 C-c C-c  \"%s\" -> \"* %s\"
+## %s  to select file and header location interactively.
+## C-2 C-c C-c  as child (C-3: as sibling) of the currently clocked item
+## To switch templates, use `\\[org-remember]'.  To abort use `C-c C-k'.\n\n"
+		  (if org-remember-store-without-prompt "    C-c C-c" "    C-1 C-c C-c")
+		  (abbreviate-file-name (or file org-default-notes-file))
+		  (or headline "")
+		  (or (car org-remember-previous-location) "???")
+		  (or (cdr org-remember-previous-location) "???")
+		  (if org-remember-store-without-prompt "C-1 C-c C-c" "        C-c C-c"))))
+	(insert tpl)
+
+	;; %[] Insert contents of a file.
+	(goto-char (point-min))
+	(while (re-search-forward "%\\[\\(.+\\)\\]" nil t)
+	  (unless (org-remember-escaped-%)
+	    (let ((start (match-beginning 0))
+		  (end (match-end 0))
+		  (filename (expand-file-name (match-string 1))))
+	      (goto-char start)
+	      (delete-region start end)
+	      (condition-case error
+		  (insert-file-contents filename)
+		(error (insert (format "%%![Couldn't insert %s: %s]"
+				       filename error)))))))
+	;; Simple %-escapes
+	(goto-char (point-min))
+	(let ((init (and (boundp 'initial)
+			 (symbol-value 'initial))))
+	  (while (re-search-forward "%\\([tTuUaiAcxkKI]\\)" nil t)
+	    (unless (org-remember-escaped-%)
+	      (when (and init (equal (match-string 0) "%i"))
+		(save-match-data
+		  (let* ((lead (buffer-substring
+				(point-at-bol) (match-beginning 0))))
+		    (setq v-i (mapconcat 'identity
+					 (org-split-string init "\n")
+					 (concat "\n" lead))))))
+	      (replace-match
+	       (or (eval (intern (concat "v-" (match-string 1)))) "")
+	       t t))))
+
+	;; %() embedded elisp
+	(goto-char (point-min))
+	(while (re-search-forward "%\\((.+)\\)" nil t)
+	  (unless (org-remember-escaped-%)
+	    (goto-char (match-beginning 0))
+	    (let ((template-start (point)))
+	      (forward-char 1)
+	      (let ((result
+		     (condition-case error
+			 (eval (read (current-buffer)))
+		       (error (format "%%![Error: %s]" error)))))
+		(delete-region template-start (point))
+		(insert result)))))
+
+	;; From the property list
+	(when plist-p
+	  (goto-char (point-min))
+	  (while (re-search-forward "%\\(:[-a-zA-Z]+\\)" nil t)
+	    (unless (org-remember-escaped-%)
+	      (and (setq x (or (plist-get org-store-link-plist
+					  (intern (match-string 1))) ""))
+		   (replace-match x t t)))))
+
+	;; Turn on org-mode in the remember buffer, set local variables
+	(let ((org-inhibit-startup t)) (org-mode) (org-remember-mode 1))
+	(if (and file (string-match "\\S-" file) (not (file-directory-p file)))
+	    (org-set-local 'org-default-notes-file file))
+	(if headline
+	    (org-set-local 'org-remember-default-headline headline))
+	(org-set-local 'org-remember-reference-date
+		       (list (nth 4 dct) (nth 3 dct) (nth 5 dct)))
+	;; Interactive template entries
+	(goto-char (point-min))
+	(while (re-search-forward "%^\\({\\([^}]*\\)}\\)?\\([gGtTuUCLp]\\)?" nil t)
+	  (unless (org-remember-escaped-%)
+	    (setq char (if (match-end 3) (match-string 3))
+		  prompt (if (match-end 2) (match-string 2)))
+	    (goto-char (match-beginning 0))
+	    (replace-match "")
+	    (setq completions nil default nil)
+	    (when prompt
+	      (setq completions (org-split-string prompt "|")
+		    prompt (pop completions)
+		    default (car completions)
+		    histvar (intern (concat
+				     "org-remember-template-prompt-history::"
+				     (or prompt "")))
+		    completions (mapcar 'list completions)))
+	    (cond
+	     ((member char '("G" "g"))
+	      (let* ((org-last-tags-completion-table
+		      (org-global-tags-completion-table
+		       (if (equal char "G") (org-agenda-files) (and file (list file)))))
+		     (org-add-colon-after-tag-completion t)
+		     (ins (org-icompleting-read
+			   (if prompt (concat prompt ": ") "Tags: ")
+			   'org-tags-completion-function nil nil nil
+			   'org-tags-history)))
+		(setq ins (mapconcat 'identity
+				     (org-split-string ins (org-re "[^[:alnum:]_@#%]+"))
+				     ":"))
+		(when (string-match "\\S-" ins)
+		  (or (equal (char-before) ?:) (insert ":"))
+		  (insert ins)
+		  (or (equal (char-after) ?:) (insert ":")))))
+	     ((equal char "C")
+	      (cond ((= (length clipboards) 1) (insert (car clipboards)))
+		    ((> (length clipboards) 1)
+		     (insert (read-string "Clipboard/kill value: "
+					  (car clipboards) '(clipboards . 1)
+					  (car clipboards))))))
+	     ((equal char "L")
+	      (cond ((= (length clipboards) 1)
+		     (org-insert-link 0 (car clipboards)))
+		    ((> (length clipboards) 1)
+		     (org-insert-link 0 (read-string "Clipboard/kill value: "
+						     (car clipboards)
+						     '(clipboards . 1)
+						     (car clipboards))))))
+	     ((equal char "p")
+	      (let*
+		  ((prop (org-no-properties prompt))
+		   (pall (concat prop "_ALL"))
+		   (allowed
+		    (with-current-buffer
+			(or (find-buffer-visiting file)
+			    (find-file-noselect file))
+		      (or (cdr (assoc pall org-file-properties))
+			  (cdr (assoc pall org-global-properties))
+			  (cdr (assoc pall org-global-properties-fixed)))))
+		   (existing (with-current-buffer
+				 (or (find-buffer-visiting file)
+				     (find-file-noselect file))
+			       (mapcar 'list (org-property-values prop))))
+		   (propprompt (concat "Value for " prop ": "))
+		   (val (if allowed
+			    (org-completing-read
+			     propprompt
+			     (mapcar 'list (org-split-string allowed "[ \t]+"))
+			     nil 'req-match)
+			  (org-completing-read-no-i propprompt existing nil nil
+						    "" nil ""))))
+		(org-set-property prop val)))
+	     (char
+	      ;; These are the date/time related ones
+	      (setq org-time-was-given (equal (upcase char) char))
+	      (setq time (org-read-date (equal (upcase char) "U") t nil
+					prompt))
+	      (org-insert-time-stamp time org-time-was-given
+				     (member char '("u" "U"))
+				     nil nil (list org-end-time-was-given)))
+	     (t
+	      (let (org-completion-use-ido)
+		(insert (org-without-partial-completion
+			 (org-completing-read-no-i
+			  (concat (if prompt prompt "Enter string")
+				  (if default (concat " [" default "]"))
+				  ": ")
+			  completions nil nil nil histvar default))))))))
+
+	(goto-char (point-min))
+	(if (re-search-forward "%\\?" nil t)
+	    (replace-match "")
+	  (and (re-search-forward "^[^#\n]" nil t) (backward-char 1))))
+    (let ((org-inhibit-startup t)) (org-mode) (org-remember-mode 1)))
+  (when (save-excursion
+	  (goto-char (point-min))
+	  (re-search-forward "%&" nil t))
+    (replace-match "")
+    (org-set-local 'org-jump-to-target-location t))
+  (when org-remember-backup-directory
+    (unless (file-directory-p org-remember-backup-directory)
+      (make-directory org-remember-backup-directory))
+    (org-set-local 'auto-save-file-name-transforms nil)
+    (setq buffer-file-name
+	  (expand-file-name
+	   (format-time-string "remember-%Y-%m-%d-%H-%M-%S")
+	   org-remember-backup-directory))
+    (save-buffer)
+    (org-set-local 'auto-save-visited-file-name t)
+    (auto-save-mode 1))
+  (when (save-excursion
+	  (goto-char (point-min))
+	  (re-search-forward "%!" nil t))
+    (replace-match "")
+    (add-hook 'post-command-hook 'org-remember-finish-immediately 'append)))
+
+(defun org-remember-escaped-% ()
+  (if (equal (char-before (match-beginning 0)) ?\\)
+      (progn
+	(delete-region (1- (match-beginning 0)) (match-beginning 0))
+	t)
+    nil))
+
+
+(defun org-remember-finish-immediately ()
+  "File remember note immediately.
+This should be run in `post-command-hook' and will remove itself
+from that hook."
+  (remove-hook 'post-command-hook 'org-remember-finish-immediately)
+  (org-remember-finalize))
+
+(defun org-remember-visit-immediately ()
+  "File remember note immediately.
+This should be run in `post-command-hook' and will remove itself
+from that hook."
+  (org-remember '(16))
+  (goto-char (or (text-property-any
+		  (point) (save-excursion (org-end-of-subtree t t))
+		  'org-position-cursor t)
+		 (point)))
+  (message "%s"
+	   (format
+	    (substitute-command-keys
+	     "Restore window configuration with \\[jump-to-register] %c")
+	    remember-register)))
+
+(defvar org-clock-marker) ; Defined in org.el
+(defun org-remember-finalize ()
+  "Finalize the remember process."
+  (interactive)
+  (unless org-remember-mode
+    (error "This does not seem to be a remember buffer for Org-mode"))
+  (run-hooks 'org-remember-before-finalize-hook)
+  (unless (fboundp 'remember-finalize)
+    (defalias 'remember-finalize 'remember-buffer))
+  (when (and org-clock-marker
+	     (equal (marker-buffer org-clock-marker) (current-buffer)))
+    ;; the clock is running in this buffer.
+    (when (and (equal (marker-buffer org-clock-marker) (current-buffer))
+	       (or (eq org-remember-clock-out-on-exit t)
+		   (and org-remember-clock-out-on-exit
+			(y-or-n-p "The clock is running in this buffer.  Clock out now? "))))
+      (let (org-log-note-clock-out) (org-clock-out))))
+  (when buffer-file-name
+    (do-auto-save))
+  (remember-finalize))
+
+(defun org-remember-kill ()
+  "Abort the current remember process."
+  (interactive)
+  (let ((org-note-abort t))
+    (org-remember-finalize)))
+
+;;;###autoload
+(defun org-remember (&optional goto org-force-remember-template-char)
+  "Call `remember'.  If this is already a remember buffer, re-apply template.
+If there is an active region, make sure remember uses it as initial content
+of the remember buffer.
+
+When called interactively with a \\[universal-argument] \
+prefix argument GOTO, don't remember
+anything, just go to the file/headline where the selected template usually
+stores its notes.  With a double prefix argument \
+\\[universal-argument] \\[universal-argument], go to the last
+note stored by remember.
+
+Lisp programs can set ORG-FORCE-REMEMBER-TEMPLATE-CHAR to a character
+associated with a template in `org-remember-templates'."
+  (interactive "P")
+  (org-require-remember)
+  (cond
+   ((equal goto '(4)) (org-go-to-remember-target))
+   ((equal goto '(16)) (org-remember-goto-last-stored))
+   (t
+    ;; set temporary variables that will be needed in
+    ;; `org-select-remember-template'
+    (setq org-select-template-temp-major-mode major-mode)
+    (setq org-select-template-original-buffer (current-buffer))
+    (if org-remember-mode
+	(progn
+	  (when (< (length org-remember-templates) 2)
+	    (error "No other template available"))
+	  (erase-buffer)
+	  (let ((annotation (plist-get org-store-link-plist :annotation))
+		(initial (plist-get org-store-link-plist :initial)))
+	    (org-remember-apply-template))
+	  (message "Press C-c C-c to remember data"))
+      (if (org-region-active-p)
+	  (org-do-remember (buffer-substring (point) (mark)))
+	(org-do-remember))))))
+
+(defvar org-remember-last-stored-marker (make-marker)
+  "Marker pointing to the entry most recently stored with `org-remember'.")
+
+(defun org-remember-goto-last-stored ()
+  "Go to the location where the last remember note was stored."
+  (interactive)
+  (org-goto-marker-or-bmk org-remember-last-stored-marker
+			  "org-remember-last-stored")
+  (message "This is the last note stored by remember"))
+
+(defun org-go-to-remember-target (&optional template-key)
+  "Go to the target location of a remember template.
+The user is queried for the template."
+  (interactive)
+  (let* (org-select-template-temp-major-mode
+	 (entry (org-select-remember-template template-key))
+	 (file (nth 1 entry))
+	 (heading (nth 2 entry))
+	 visiting)
+    (unless (and file (stringp file) (string-match "\\S-" file))
+      (setq file org-default-notes-file))
+    (when (and file (not (file-name-absolute-p file)))
+      (setq file (expand-file-name file org-directory)))
+    (unless (and heading (stringp heading) (string-match "\\S-" heading))
+      (setq heading org-remember-default-headline))
+    (setq visiting (org-find-base-buffer-visiting file))
+    (if (not visiting) (find-file-noselect file))
+    (org-pop-to-buffer-same-window (or visiting (get-file-buffer file)))
+    (widen)
+    (goto-char (point-min))
+    (if (re-search-forward
+	 (format org-complex-heading-regexp-format (regexp-quote heading))
+	 nil t)
+	(goto-char (match-beginning 0))
+      (error "Target headline not found: %s" heading))))
+
+;; FIXME (bzg): let's clean up of final empty lines happen only once
+;; (see the org-remember-delete-empty-lines-at-end option below)
+;;;###autoload
+(defun org-remember-handler ()
+  "Store stuff from remember.el into an org file.
+When the template has specified a file and a headline, the entry is filed
+there, or in the location defined by `org-default-notes-file' and
+`org-remember-default-headline'.
+\\<org-remember-mode-map>
+If no defaults have been defined, or if the current prefix argument
+is 1 (using C-1 \\[org-remember-finalize] to exit remember), an interactive
+process is used to select the target location.
+
+When the prefix is 0 (i.e. when remember is exited with \
+C-0 \\[org-remember-finalize]),
+the entry is filed to the same location as the previous note.
+
+When the prefix is 2 (i.e. when remember is exited with \
+C-2 \\[org-remember-finalize]),
+the entry is filed as a subentry of the entry where the clock is
+currently running.
+
+When \\[universal-argument] has been used as prefix argument, the
+note is stored and Emacs moves point to the new location of the
+note, so that editing can be continued there (similar to
+inserting \"%&\" into the template).
+
+Before storing the note, the function ensures that the text has an
+org-mode-style headline, i.e. a first line that starts with
+a \"*\".  If not, a headline is constructed from the current date and
+some additional data.
+
+If the variable `org-adapt-indentation' is non-nil, the entire text is
+also indented so that it starts in the same column as the headline
+\(i.e. after the stars).
+
+See also the variable `org-reverse-note-order'."
+  (when (and (equal current-prefix-arg 2)
+	     (not (marker-buffer org-clock-marker)))
+    (error "No running clock"))
+  (when (org-bound-and-true-p org-jump-to-target-location)
+    (let* ((end (min (point-max) (1+ (point))))
+	   (beg (point)))
+      (if (= end beg) (setq beg (1- beg)))
+      (put-text-property beg end 'org-position-cursor t)))
+  (goto-char (point-min))
+  (while (looking-at "^[ \t]*\n\\|^##.*\n")
+    (replace-match ""))
+  (when org-remember-delete-empty-lines-at-end
+    (goto-char (point-max))
+    (beginning-of-line 1)
+    (while (and (looking-at "[ \t]*$\\|##.*") (> (point) 1))
+      (delete-region (1- (point)) (point-max))
+      (beginning-of-line 1)))
+  (catch 'quit
+    (if org-note-abort (throw 'quit t))
+    (let* ((visitp (org-bound-and-true-p org-jump-to-target-location))
+	   (backup-file
+	    (and buffer-file-name
+		 (equal (file-name-directory buffer-file-name)
+			(file-name-as-directory
+			 (expand-file-name org-remember-backup-directory)))
+		 (string-match "^remember-[0-9]\\{4\\}"
+			       (file-name-nondirectory buffer-file-name))
+		 buffer-file-name))
+
+	   (dummy
+	    (unless (string-match "\\S-" (buffer-string))
+	      (message "Nothing to remember")
+	      (and backup-file
+		   (ignore-errors
+		     (delete-file backup-file)
+		     (delete-file (concat backup-file "~"))))
+	      (set-buffer-modified-p nil)
+	      (throw 'quit t)))
+	   (reference-date org-remember-reference-date)
+	   (previousp (and (member current-prefix-arg '((16) 0))
+			   org-remember-previous-location))
+	   (clockp (equal current-prefix-arg 2))
+	   (clocksp (equal current-prefix-arg 3))
+	   (fastp (org-xor (equal current-prefix-arg 1)
+			   org-remember-store-without-prompt))
+	   (file (cond
+		  (fastp org-default-notes-file)
+		  ((and (eq org-remember-interactive-interface 'refile)
+			org-refile-targets)
+		   org-default-notes-file)
+		  ((not previousp)
+		   (org-get-org-file))))
+	   (heading org-remember-default-headline)
+	   (visiting (and file (org-find-base-buffer-visiting file)))
+	   (org-startup-folded nil)
+	   (org-startup-align-all-tables nil)
+	   (org-goto-start-pos 1)
+	   spos exitcmd level reversed txt text-before-node-creation)
+      (when (equal current-prefix-arg '(4))
+	(setq visitp t))
+      (when previousp
+	(setq file (car org-remember-previous-location)
+	      visiting (and file (org-find-base-buffer-visiting file))
+	      heading (cdr org-remember-previous-location)
+	      fastp t))
+      (when (or clockp clocksp)
+	(setq file (buffer-file-name (marker-buffer org-clock-marker))
+	      visiting (and file (org-find-base-buffer-visiting file))
+	      heading org-clock-heading-for-remember
+	      fastp t))
+      (setq current-prefix-arg nil)
+      ;; Modify text so that it becomes a nice subtree which can be inserted
+      ;; into an org tree.
+      (when org-remember-delete-empty-lines-at-end
+      	(goto-char (point-min))
+      	(if (re-search-forward "[ \t\n]+\\'" nil t)
+      	    ;; remove empty lines at end
+      	    (replace-match "")))
+      (goto-char (point-min))
+      (setq text-before-node-creation (buffer-string))
+      (unless (looking-at org-outline-regexp)
+	;; add a headline
+	(insert (concat "* " (current-time-string)
+			" (" (remember-buffer-desc) ")\n"))
+	(backward-char 1)
+	(when org-adapt-indentation
+	  (while (re-search-forward "^" nil t)
+	    (insert "  "))))
+      ;; Delete final empty lines
+      (when org-remember-delete-empty-lines-at-end
+	(goto-char (point-min))
+	(if (re-search-forward "\n[ \t]*\n[ \t\n]*\\'" nil t)
+	    (replace-match "\n\n")
+	  (if (re-search-forward "[ \t\n]*\\'")
+	      (replace-match "\n"))))
+      (goto-char (point-min))
+      (setq txt (buffer-string))
+      (org-save-markers-in-region (point-min) (point-max))
+      (set-buffer-modified-p nil)
+      (when (and (eq org-remember-interactive-interface 'refile)
+		 (not fastp))
+	(org-refile nil (or visiting (find-file-noselect file)))
+	(and visitp (run-with-idle-timer 0.01 nil 'org-remember-visit-immediately))
+	(save-excursion
+	  (bookmark-jump "org-refile-last-stored")
+	  (bookmark-set "org-remember-last-stored")
+	  (move-marker org-remember-last-stored-marker (point)))
+	(throw 'quit t))
+      ;; Find the file
+      (with-current-buffer (or visiting (find-file-noselect file))
+	(unless (or (derived-mode-p 'org-mode) (member heading '(top bottom)))
+	  (error "Target files for notes must be in Org-mode if not filing to top/bottom"))
+	(save-excursion
+	  (save-restriction
+	    (widen)
+	    (setq reversed (org-notes-order-reversed-p))
+
+	    ;; Find the default location
+	    (when heading
+	      (cond
+	       ((not (derived-mode-p 'org-mode))
+		(if (eq heading 'top)
+		    (goto-char (point-min))
+		  (goto-char (point-max))
+		  (or (bolp) (newline)))
+		(insert text-before-node-creation)
+		(when remember-save-after-remembering
+		  (save-buffer)
+		  (if (not visiting) (kill-buffer (current-buffer))))
+		(throw 'quit t))
+	       ((eq heading 'top)
+		(goto-char (point-min))
+		(or (looking-at org-outline-regexp)
+		    (re-search-forward org-outline-regexp nil t))
+		(setq org-goto-start-pos (or (match-beginning 0) (point-min))))
+	       ((eq heading 'bottom)
+		(goto-char (point-max))
+		(or (bolp) (newline))
+		(setq org-goto-start-pos (point)))
+	       ((eq heading 'date-tree)
+		(org-datetree-find-date-create reference-date)
+		(setq reversed nil)
+		(setq org-goto-start-pos (point)))
+	       ((and (stringp heading) (string-match "\\S-" heading))
+		(goto-char (point-min))
+		(if (re-search-forward
+		     (format org-complex-heading-regexp-format
+			     (regexp-quote heading))
+		     nil t)
+		    (setq org-goto-start-pos (match-beginning 0))
+		  (when fastp
+		    (goto-char (point-max))
+		    (unless (bolp) (newline))
+		    (insert "* " heading "\n")
+		    (setq org-goto-start-pos (point-at-bol 0)))))
+	       (t (goto-char (point-min)) (setq org-goto-start-pos (point)
+						heading 'top))))
+
+	    ;; Ask the User for a location, using the appropriate interface
+	    (cond
+	     ((and fastp (memq heading '(top bottom)))
+	      (setq spos org-goto-start-pos
+		    exitcmd (if (eq heading 'top) 'left nil)))
+	     (fastp (setq spos org-goto-start-pos
+			  exitcmd 'return))
+	     ((eq org-remember-interactive-interface 'outline)
+	      (setq spos (org-get-location (current-buffer)
+					   org-remember-help)
+		    exitcmd (cdr spos)
+		    spos (car spos)))
+	     ((eq org-remember-interactive-interface 'outline-path-completion)
+	      (let ((org-refile-targets '((nil . (:maxlevel . 10))))
+		    (org-refile-use-outline-path t))
+		(setq spos (org-refile-get-location "Heading")
+		      exitcmd 'return
+		      spos (nth 3 spos))))
+	     (t (error "This should not happen")))
+	    (if (not spos) (throw 'quit nil)) ; return nil to show we did
+					; not handle this note
+	    (and visitp (run-with-idle-timer 0.01 nil 'org-remember-visit-immediately))
+	    (goto-char spos)
+	    (cond ((org-at-heading-p t)
+		   (org-back-to-heading t)
+		   (setq level (funcall outline-level))
+		   (cond
+		    ((eq exitcmd 'return)
+		     ;; sublevel of current
+		     (setq org-remember-previous-location
+			   (cons (abbreviate-file-name file)
+				 (org-get-heading 'notags)))
+		     (if reversed
+			 (outline-next-heading)
+		       (org-end-of-subtree t)
+		       (if (not (bolp))
+			   (if (looking-at "[ \t]*\n")
+			       (beginning-of-line 2)
+			     (end-of-line 1)
+			     (insert "\n"))))
+		     (org-paste-subtree (if clocksp
+					    level
+					  (org-get-valid-level level 1)) txt)
+		     (and org-auto-align-tags (org-set-tags nil t))
+		     (bookmark-set "org-remember-last-stored")
+		     (move-marker org-remember-last-stored-marker (point)))
+		    ((eq exitcmd 'left)
+		     ;; before current
+		     (org-paste-subtree level txt)
+		     (and org-auto-align-tags (org-set-tags nil t))
+		     (bookmark-set "org-remember-last-stored")
+		     (move-marker org-remember-last-stored-marker (point)))
+		    ((eq exitcmd 'right)
+		     ;; after current
+		     (org-end-of-subtree t)
+		     (org-paste-subtree level txt)
+		     (and org-auto-align-tags (org-set-tags nil t))
+		     (bookmark-set "org-remember-last-stored")
+		     (move-marker org-remember-last-stored-marker (point)))
+		    (t (error "This should not happen"))))
+
+		  ((eq heading 'bottom)
+		   (org-paste-subtree 1 txt)
+		   (and org-auto-align-tags (org-set-tags nil t))
+		   (bookmark-set "org-remember-last-stored")
+		   (move-marker org-remember-last-stored-marker (point)))
+
+		  ((and (bobp) (not reversed))
+		   ;; Put it at the end, one level below level 1
+		   (save-restriction
+		     (widen)
+		     (goto-char (point-max))
+		     (if (not (bolp)) (newline))
+		     (org-paste-subtree (org-get-valid-level 1 1) txt)
+		     (and org-auto-align-tags (org-set-tags nil t))
+		     (bookmark-set "org-remember-last-stored")
+		     (move-marker org-remember-last-stored-marker (point))))
+
+		  ((and (bobp) reversed)
+		   ;; Put it at the start, as level 1
+		   (save-restriction
+		     (widen)
+		     (goto-char (point-min))
+		     (re-search-forward org-outline-regexp-bol nil t)
+		     (beginning-of-line 1)
+		     (org-paste-subtree 1 txt)
+		     (and org-auto-align-tags (org-set-tags nil t))
+		     (bookmark-set "org-remember-last-stored")
+		     (move-marker org-remember-last-stored-marker (point))))
+		  (t
+		   ;; Put it right there, with automatic level determined by
+		   ;; org-paste-subtree or from prefix arg
+		   (org-paste-subtree
+		    (if (numberp current-prefix-arg) current-prefix-arg)
+		    txt)
+		   (and org-auto-align-tags (org-set-tags nil t))
+		   (bookmark-set "org-remember-last-stored")
+		   (move-marker org-remember-last-stored-marker (point))))
+
+	    (when remember-save-after-remembering
+	      (save-buffer)
+	      (if (and (not visiting)
+		       (not (equal (marker-buffer org-clock-marker)
+				   (current-buffer))))
+		  (kill-buffer (current-buffer))))
+	    (when org-remember-auto-remove-backup-files
+	      (when backup-file
+		(ignore-errors
+		  (delete-file backup-file)
+		  (delete-file (concat backup-file "~"))))
+	      (when org-remember-backup-directory
+		(let ((n (length
+			  (directory-files
+			   org-remember-backup-directory nil
+			   "^remember-.*[0-9]$"))))
+		  (when (and org-remember-warn-about-backups
+                             (> n 0))
+		    (message
+		     "%d backup files (unfinished remember calls) in %s"
+		     n org-remember-backup-directory))))))))))
+
+  t)    ;; return t to indicate that we took care of this note.
+
+(defun org-do-remember (&optional initial)
+  "Call remember."
+  (remember initial))
+
+(defun org-require-remember ()
+  "Make sure remember is loaded, or install our own emergency version of it."
+  (condition-case nil
+      (require 'remember)
+    (error
+     ;; Lets install our own micro version of remember
+     (defvar remember-register ?R)
+     (defvar remember-mode-hook nil)
+     (defvar remember-handler-functions nil)
+     (defvar remember-buffer "*Remember*")
+     (defvar remember-save-after-remembering t)
+     (defvar remember-annotation-functions '(buffer-file-name))
+     (defun remember-finalize ()
+       (run-hook-with-args-until-success 'remember-handler-functions)
+       (when (equal remember-buffer (buffer-name))
+	 (kill-buffer (current-buffer))
+	 (jump-to-register remember-register)))
+     (defun remember-mode ()
+       (fundamental-mode)
+       (setq mode-name "Remember")
+       (run-hooks 'remember-mode-hook))
+     (defun remember (&optional initial)
+       (window-configuration-to-register remember-register)
+       (let* ((annotation (run-hook-with-args-until-success
+			   'remember-annotation-functions)))
+	 (switch-to-buffer-other-window (get-buffer-create remember-buffer))
+	 (remember-mode)))
+     (defun remember-buffer-desc ()
+       (buffer-substring (point-min) (save-excursion (goto-char (point-min))
+						     (point-at-eol)))))))
+
+(provide 'org-remember)
+
+;;; org-remember.el ends here