Mercurial > emacs
comparison lisp/org/org-remember.el @ 94414:d86cb59eea9f
2008-04-27 Carsten Dominik <dominik@science.uva.nl>
* org/org.el (org-html-level-start): Always have id's in HTML
(org-export-as-html): Use `org-link-protocols' to
retrieve the export form of the link.
(org-add-link-type): Final parameter renamed from PUBLISH. Better
documentation of how it is to be used. Avoid double entries for
the same link type.
(org-add-link-props): New function.
(org-modules-loaded): New variable.
(org-load-modules-maybe, org-set-modules): New function.
(org-modules): New option.
(org-mode, org-cycle, orgstruct-mode, org-run-like-in-org-mode)
(orgtbl-mode, org-store-link, org-insert-link-global)
(org-open-at-point): Call `org-load-modules-maybe'.
(org-search-view): Add more text properties.
(org-agenda-schedule, org-agenda-deadline): Allow also in
search-type agendas.
(org-search-view): Order of arguments has been changed.
Interpret prefix-arg as TODO-ONLY.
(org-agenda, org-run-agenda-series, org-agenda-manipulate-query):
Take new argument order of `org-search-view' into account.
(org-todo-only): New variable.
(org-search-syntax-table): New variable and function.
(org-search-view): Do the search with the special syntax table.
(define-obsolete-function-alias): Make work with XEmacs.
(org-add-planning-info): Use old date as default when modifying an
existing deadline or scheduled item.
(org-agenda-compute-time-span): Make argument N optional.
(org-agenda-format-date-aligned): Require `cal-iso'.
(org-agenda-list): Include week into into agenda heading, don't
list it at each date (only on Mondays).
(org-read-date-analyze): Define local variable `iso-date'.
(org-agenda-format-date-aligned): Remove dependency on
`calendar-time-from-absolute'.
(org-remember-apply-template, org-go-to-remember-target):
Interpret filenames relative to `org-directory'.
(org-complete): Silently fail when trying to complete
keywords that don't have a default value.
(org-get-current-options): Added a #+DATE: option.
(org-additional-option-like-keywords): Removed "DATE:" from the
list of additional keywords.
(org-export-as-html): Removed (current-time) as unnecessary second
argument of `format-time-string'.
(org-clock-find-position): Handle special case at end of
buffer.
(org-agenda-day-view): New argument DAY-OF-YEAR, pass it on to
`org-agenda-change-time-span'.
(org-agenda-week-view): New argument ISO-WEEK, pass it on to
`org-agenda-change-time-span'.
(org-agenda-month-view): New argument MONTH, pass it on to
`org-agenda-change-time-span'.
(org-agenda-year-view): New argument YEAR, pass it on to
`org-agenda-change-time-span'.
(org-agenda-change-time-span): New optional argument N, pass it on
to `org-agenda-compute-time-span'.
(org-agenda-compute-time-span): New argument N, interpret it by
changing the starting day.
(org-small-year-to-year): New function.
(org-scheduled-past-days): Respect
`org-scheduled-past-days'.
(org-auto-repeat-maybe): Make sure that repeating
dates are pushed into the future, and that the shift is at least
one interval, never 0.
(org-update-checkbox-count): Fix bug with checkbox
counting.
(org-add-note): New command.
(org-add-log-setup): Renamed from `org-add-log-maybe'.
(org-log-note-headings): New entry for plain notes (i.e. notes not
related to state changes or clocking).
(org-get-org-file): Check for availability of
`remember-data-file'.
(org-cached-entry-get): Allow a regexp value for
`org-use-property-inheritance'.
(org-use-property-inheritance): Allow regexp value. Fix bug in
customization type.
(org-use-tag-inheritance): Allow a list and a regexp value for
this variable.
(org-scan-tags, org-get-tags-at): Implement selective tag
inheritance.
(org-entry-get): Respect value `selective' for the INHERIT
argument.
(org-tag-inherit-p, org-property-inherit-p): New functions.
(org-agenda-format-date-aligned): Allow 10 characters for
weekday, to acomodate German locale.
(org-add-archive-files): New function.
(org-agenda-files): New argument `ext', to
get archive files as well.
(org-tbl-menu): Protect the use of variables that
are only available when org-table.el gets loaded.
(org-read-agenda-file-list): Error if `org-agenda-files' is a
single directory.
(org-open-file): Allow a batch process to trigger
waiting after executing a system command.
(org-store-link): Link to headline when there is not
target and no region in an org-mode buffer when creating a link.
(org-link-types-re): New variable.
(org-make-link-regexps): Compute `org-link-types-re'.
(org-make-link-description-function): New option.
(org-agenda-date, org-agenda-date-weekend): New faces.
(org-archive-sibling-heading): New option.
(org-archive-to-archive-sibling): New function.
(org-iswitchb): New command.
(org-buffer-list): New function.
(org-agenda-columns): Also try the #+COLUMNS line in
the buffer associated with the entry at point (or with the first
entry in the agenda view).
(org-modules): Add entry for org-bibtex.el.
(org-completion-fallback-command): Moved into `org-completion'
group.
(org-clock-heading-function): Moved to `org-progress' group.
(org-auto-repeat-maybe): Make sure that a note can
be enforces if `org-log-repeat' is `note'.
(org-modules): Allow additional symbols for external
packages.
(org-ctrl-c-ctrl-c): Allow for `org-clock-overlays' to be
undefined.
(org-clock-goto): Hide drawers after showing an
entry with `org-clock-goto.'
(org-shiftup, org-shiftdown, org-shiftright, org-shiftleft): Try
also a clocktable block shift.
(org-clocktable-try-shift): New function.
(org-columns-hscoll-title): New function.
(org-columns-previous-hscroll): New variable.
(org-columns-full-header-line-format): New variable.
(org-columns-display-here-title, org-columns-remove-overlays):
Install `org-columns-hscoll-title' in post-command-hook.
* org/org.el: Split into many small files.
* org/org-agenda.el: New file, split off from org.el.
* org/org-archive.el: New file, split off from org.el.
* org/org-bbdb.el: New file.
* org/org-bibtex.el: New file, split off from org.el.
* org/org-clock.el: New file, split off from org.el.
* org/org-colview.el: New file, split off from org.el.
* org/org-compat.el: New file, split off from org.el.
* org/org-exp.el: New file, split off from org.el.
* org/org-faces.el: New file, split off from org.el.
* org/org-gnus.el: New file, split off from org.el.
* org/org-info.el: New file, split off from org.el.
* org/org-infojs.el: New file.
* org/org-irc.el: New file.
* org/org-macs.el: New file, split off from org.el.
* org/org-mew.el: New file.
* org/org-mhe.el: New file, split off from org.el.
* org/org-publish.el: New file, split off from org.el.
* org/org-remember.el: New file, split off from org.el.
* org/org-rmail.el: New file, split off from org.el.
* org/org-table.el: New file, split off from org.el.
* org/org-vm.el: New file, split off from org.el.
* org/org-wl.el: New file, split off from org.el.
2008-04-27 Jason Riedy <jason@acm.org>
* lisp/org-table.el (orgtbl-to-generic): Add a :remove-nil-lines
parameter that supresses lines that evaluate to NIL.
(orgtbl-get-fmt): New inline function for
picking apart formats that may be lists.
(orgtbl-apply-fmt): New inline function for applying formats that
may be functions.
(orgtbl-eval-str): New inline function for strings that may be
functions.
(orgtbl-format-line, orgtbl-to-generic): Use and document.
(orgtbl-to-latex, orgtbl-to-texinfo): Document.
(*orgtbl-llfmt*, *orgtbl-llstart*)
(*orgtbl-llend*): Dynamic variables for last-line formatting.
(orgtbl-format-section): Shift formatting to support detecting the
last line and formatting it specially.
(orgtbl-to-generic): Document :ll* formats. Set to the non-ll
formats unless overridden.
(orgtbl-to-latex): Suggest using :llend to suppress the final \\.
(*orgtbl-table*, *orgtbl-rtn*): Dynamically
bound variables to hold the input collection of lines and output
formatted text.
(*orgtbl-hline*, *orgtbl-sep*, *orgtbl-fmt*, *orgtbl-efmt*,
(*orgtbl-lfmt*, *orgtbl-lstart*, *orgtbl-lend*): Dynamically bound
format parameters.
(orgtbl-format-line): New function encapsulating formatting for a
single line.
(orgtbl-format-section): Similar for each section. Rebinding the
dynamic vars customizes the formatting for each section.
(orgtbl-to-generic): Use orgtbl-format-line and
orgtbl-format-section.
(org-get-param): Now unused, so delete.
(orgtbl-gather-send-defs): New function to
gather all the SEND definitions before a table.
(orgtbl-send-replace-tbl): New function to find the RECEIVE
corresponding to the current name.
(orgtbl-send-table): Use the previous two functions and implement
multiple destinations for each table.
* doc/org.texi (A LaTeX example): Note that fmt may be a
one-argument function, and efmt may be a two-argument function.
(Radio tables): Document multiple destinations.
2008-04-27 Carsten Dominik <dominik@science.uva.nl>
* org/org-agenda.el (org-add-to-diary-list): New function.
(org-prefix-has-effort): New variable.
(org-sort-agenda-noeffort-is-high): New option.
(org-agenda-columns-show-summaries)
(org-agenda-columns-compute-summary-properties): New options.
(org-format-agenda-item): Compute the duration of the item.
(org-agenda-weekend-days): New variable.
(org-agenda-list, org-timeline): Use the proper faces for dates in
the agenda and timeline buffers.
(org-agenda-archive-to-archive-sibling): New command.
(org-agenda-start-with-clockreport-mode): New option.
(org-agenda-clockreport-parameter-plist): New option.
(org-agenda-clocktable-mode): New variable.
(org-agenda-deadline-leaders): Allow a function value for the
deadline leader.
(org-agenda-get-deadlines): Deal with new function value.
* lisp/org-clock.el (org-clock): New customization group.
(org-clock-into-drawer, org-clock-out-when-done)
(org-clock-in-switch-to-state, org-clock-heading-function): Moved
into the new group.
(org-clock-out-remove-zero-time-clocks): New option.
(org-clock-out): Use `org-clock-out-remove-zero-time-clocks'.
(org-dblock-write:clocktable): Allow a Lisp form for the scope
parameter.
(org-dblock-write:clocktable): Fixed bug with total time
calculation.
(org-dblock-write:clocktable): Request the unrestricted list of
files.
(org-get-clocktable): New function.
(org-dblock-write:clocktable): Make sure :tstart and :tend can not
only be strings but also integers (an absolute day number) and
lists (m d y).
* org/org-colview.el (org-columns-next-allowed-value)
(org-columns-edit-value): Limit the effort for updatig in the
agenda to recomputing a single file.
(org-columns-compute): Only write property value if it has
changed. This avoids raising the buffer-change-flag
unnecessarily.
(org-agenda-colview-summarize)
(org-agenda-colview-compute): New functions.
(org-agenda-columns): Call `org-agenda-colview-summarize'.
* org/org-exp.el (org-export-run-in-background): New option.
(org-export-icalendar): Allow a batch process to trigger waiting
after executing a system command.
(org-export-preprocess-string): Renamed-from
`org-cleaned-string-for-export'.
(org-export-html-style): Made target class look like normal text.
(org-export-as-html): Make use of the better proprocessing in
`org-cleaned-string-for-export'.
(org-cleaned-string-for-export): Better treatment of heuristic
targets, many more internal links will now work in HTML export.
(org-get-current-options): Incorporate LINK_UP, LINK_HOME, and
INFOJS.
(org-export-inbuffer-options-extra): New variable.
(org-export-options-filters): New hook.
(org-infile-export-plist): Find also the settings keywords in
`org-export-inbuffer-options-extra'.
(org-infile-export-plist): Allow multiple #+OPTIONS lines and
multiple #+INFOJS_OPT lines.
(org-export-html-handle-js-options): New function.
(org-export-html-infojs-setup): New option.
(org-export-as-html): Call `org-export-html-handle-js-options'.
Add autoload to all entry points.
(org-skip-comments): Function removed.
* org/org-table.el (org-table-make-reference): Extra parenthesis
around single fields, to make sure that algebraic formulas get
correctly interpreted by calc.
(org-table-current-column): No longer interactive.
* org/org-export-latex.el (org-export-latex-preprocess): Renamed
from `org-export-latex-cleaned-string'.
2008-04-27 Bastien Guerry <bzg@altern.org>
* org/org-publish.el (org-publish-get-base-files-1): New function.
(org-publish-get-base-files): Use it.
(org-publish-temp-files): New variable.
Don't require 'dired-aux anymore.
(org-publish-initial-buffer): New variable.
(org-publish-org-to, org-publish): Use it.
(org-publish-get-base-files-1): Bug fix: get
the proper list of files when recursing thru a directory.
(org-publish-get-base-files): Use the :exclude property to skip
both files and directories.
| author | Carsten Dominik <dominik@science.uva.nl> |
|---|---|
| date | Sun, 27 Apr 2008 18:33:39 +0000 |
| parents | |
| children | da5141d2e8fc |
comparison
equal
deleted
inserted
replaced
| 94413:90289baecd6a | 94414:d86cb59eea9f |
|---|---|
| 1 ;;; org-remember.el --- Fast note taking in Org-mode | |
| 2 | |
| 3 ;; Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. | |
| 4 | |
| 5 ;; Author: Carsten Dominik <carsten at orgmode dot org> | |
| 6 ;; Keywords: outlines, hypermedia, calendar, wp | |
| 7 ;; Homepage: http://orgmode.org | |
| 8 ;; Version: 6.02b | |
| 9 ;; | |
| 10 ;; This file is part of GNU Emacs. | |
| 11 ;; | |
| 12 ;; GNU Emacs is free software; you can redistribute it and/or modify | |
| 13 ;; it under the terms of the GNU General Public License as published by | |
| 14 ;; the Free Software Foundation; either version 3, or (at your option) | |
| 15 ;; any later version. | |
| 16 | |
| 17 ;; GNU Emacs is distributed in the hope that it will be useful, | |
| 18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 20 ;; GNU General Public License for more details. | |
| 21 | |
| 22 ;; You should have received a copy of the GNU General Public License | |
| 23 ;; along with GNU Emacs; see the file COPYING. If not, write to the | |
| 24 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | |
| 25 ;; Boston, MA 02110-1301, USA. | |
| 26 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 27 ;; | |
| 28 ;;; Commentary: | |
| 29 | |
| 30 ;; This file contains the system to take fast notes with Org-mode. | |
| 31 ;; This system is used together with John Wiegleys `remember.el'. | |
| 32 | |
| 33 ;;; Code: | |
| 34 | |
| 35 (eval-when-compile | |
| 36 (require 'cl)) | |
| 37 (require 'org) | |
| 38 | |
| 39 (declare-function remember "remember" (&optional initial)) | |
| 40 (declare-function remember-buffer-desc "remember" ()) | |
| 41 (declare-function remember-finalize "remember" ()) | |
| 42 (defvar remember-save-after-remembering) | |
| 43 (defvar remember-data-file) | |
| 44 (defvar remember-register) | |
| 45 (defvar remember-buffer) | |
| 46 (defvar remember-handler-functions) | |
| 47 (defvar remember-annotation-functions) | |
| 48 | |
| 49 (defgroup org-remember nil | |
| 50 "Options concerning interaction with remember.el." | |
| 51 :tag "Org Remember" | |
| 52 :group 'org) | |
| 53 | |
| 54 (defcustom org-remember-store-without-prompt t | |
| 55 "Non-nil means, `C-c C-c' stores remember note without further promts. | |
| 56 In this case, you need `C-u C-c C-c' to get the prompts for | |
| 57 note file and headline. | |
| 58 When this variable is nil, `C-c C-c' give you the prompts, and | |
| 59 `C-u C-c C-c' trigger the fasttrack." | |
| 60 :group 'org-remember | |
| 61 :type 'boolean) | |
| 62 | |
| 63 (defcustom org-remember-interactive-interface 'refile | |
| 64 "The interface to be used for interactive filing of remember notes. | |
| 65 This is only used when the interactive mode for selecting a filing | |
| 66 location is used (see the variable `org-remember-store-without-prompt'). | |
| 67 Allowed vaues are: | |
| 68 outline The interface shows an outline of the relevant file | |
| 69 and the correct heading is found by moving through | |
| 70 the outline or by searching with incremental search. | |
| 71 outline-path-completion Headlines in the current buffer are offered via | |
| 72 completion. | |
| 73 refile Use the refile interface, and offer headlines, | |
| 74 possibly from different buffers." | |
| 75 :group 'org-remember | |
| 76 :type '(choice | |
| 77 (const :tag "Refile" refile) | |
| 78 (const :tag "Outline" outline) | |
| 79 (const :tag "Outline-path-completion" outline-path-completion))) | |
| 80 | |
| 81 (defcustom org-remember-default-headline "" | |
| 82 "The headline that should be the default location in the notes file. | |
| 83 When filing remember notes, the cursor will start at that position. | |
| 84 You can set this on a per-template basis with the variable | |
| 85 `org-remember-templates'." | |
| 86 :group 'org-remember | |
| 87 :type 'string) | |
| 88 | |
| 89 (defcustom org-remember-templates nil | |
| 90 "Templates for the creation of remember buffers. | |
| 91 When nil, just let remember make the buffer. | |
| 92 When not nil, this is a list of 5-element lists. In each entry, the first | |
| 93 element is the name of the template, which should be a single short word. | |
| 94 The second element is a character, a unique key to select this template. | |
| 95 The third element is the template. | |
| 96 | |
| 97 The fourth element is optional and can specify a destination file for | |
| 98 remember items created with this template. The default file is given | |
| 99 by `org-default-notes-file'. If the file name is not an absolute path, | |
| 100 it will be interpreted relative to `org-directory'. | |
| 101 | |
| 102 An optional fifth element can specify the headline in that file that should | |
| 103 be offered first when the user is asked to file the entry. The default | |
| 104 headline is given in the variable `org-remember-default-headline'. | |
| 105 | |
| 106 An optional sixth element specifies the contexts in which the user can | |
| 107 select the template. This element can be either a list of major modes | |
| 108 or a function. `org-remember' will first check whether the function | |
| 109 returns `t' or if we are in any of the listed major modes, and select | |
| 110 the template accordingly. | |
| 111 | |
| 112 The template specifies the structure of the remember buffer. It should have | |
| 113 a first line starting with a star, to act as the org-mode headline. | |
| 114 Furthermore, the following %-escapes will be replaced with content: | |
| 115 | |
| 116 %^{prompt} Prompt the user for a string and replace this sequence with it. | |
| 117 A default value and a completion table ca be specified like this: | |
| 118 %^{prompt|default|completion2|completion3|...} | |
| 119 %t time stamp, date only | |
| 120 %T time stamp with date and time | |
| 121 %u, %U like the above, but inactive time stamps | |
| 122 %^t like %t, but prompt for date. Similarly %^T, %^u, %^U | |
| 123 You may define a prompt like %^{Please specify birthday}t | |
| 124 %n user name (taken from `user-full-name') | |
| 125 %a annotation, normally the link created with org-store-link | |
| 126 %i initial content, the region active. If %i is indented, | |
| 127 the entire inserted text will be indented as well. | |
| 128 %c content of the clipboard, or current kill ring head | |
| 129 %^g prompt for tags, with completion on tags in target file | |
| 130 %^G prompt for tags, with completion all tags in all agenda files | |
| 131 %:keyword specific information for certain link types, see below | |
| 132 %[pathname] insert the contents of the file given by `pathname' | |
| 133 %(sexp) evaluate elisp `(sexp)' and replace with the result | |
| 134 %! Store this note immediately after filling the template | |
| 135 | |
| 136 %? After completing the template, position cursor here. | |
| 137 | |
| 138 Apart from these general escapes, you can access information specific to the | |
| 139 link type that is created. For example, calling `remember' in emails or gnus | |
| 140 will record the author and the subject of the message, which you can access | |
| 141 with %:author and %:subject, respectively. Here is a complete list of what | |
| 142 is recorded for each link type. | |
| 143 | |
| 144 Link type | Available information | |
| 145 -------------------+------------------------------------------------------ | |
| 146 bbdb | %:type %:name %:company | |
| 147 vm, wl, mh, rmail | %:type %:subject %:message-id | |
| 148 | %:from %:fromname %:fromaddress | |
| 149 | %:to %:toname %:toaddress | |
| 150 | %:fromto (either \"to NAME\" or \"from NAME\") | |
| 151 gnus | %:group, for messages also all email fields | |
| 152 w3, w3m | %:type %:url | |
| 153 info | %:type %:file %:node | |
| 154 calendar | %:type %:date" | |
| 155 :group 'org-remember | |
| 156 :get (lambda (var) ; Make sure all entries have at least 5 elements | |
| 157 (mapcar (lambda (x) | |
| 158 (if (not (stringp (car x))) (setq x (cons "" x))) | |
| 159 (cond ((= (length x) 4) (append x '(""))) | |
| 160 ((= (length x) 3) (append x '("" ""))) | |
| 161 (t x))) | |
| 162 (default-value var))) | |
| 163 :type '(repeat | |
| 164 :tag "enabled" | |
| 165 (list :value ("" ?a "\n" nil nil nil) | |
| 166 (string :tag "Name") | |
| 167 (character :tag "Selection Key") | |
| 168 (string :tag "Template") | |
| 169 (choice | |
| 170 (file :tag "Destination file") | |
| 171 (const :tag "Prompt for file" nil)) | |
| 172 (choice | |
| 173 (string :tag "Destination headline") | |
| 174 (const :tag "Selection interface for heading")) | |
| 175 (choice | |
| 176 (const :tag "Use by default" nil) | |
| 177 (const :tag "Use in all contexts" t) | |
| 178 (repeat :tag "Use only if in major mode" | |
| 179 (symbol :tag "Major mode")) | |
| 180 (function :tag "Perform a check against function"))))) | |
| 181 | |
| 182 (defvar annotation) ; from remember.el, dynamically scoped in `remember-mode' | |
| 183 (defvar initial) ; from remember.el, dynamically scoped in `remember-mode' | |
| 184 | |
| 185 ;;;###autoload | |
| 186 (defun org-remember-insinuate () | |
| 187 "Setup remember.el for use wiht Org-mode." | |
| 188 (require 'remember) | |
| 189 (setq remember-annotation-functions '(org-remember-annotation)) | |
| 190 (setq remember-handler-functions '(org-remember-handler)) | |
| 191 (add-hook 'remember-mode-hook 'org-remember-apply-template)) | |
| 192 | |
| 193 ;;;###autoload | |
| 194 (defun org-remember-annotation () | |
| 195 "Return a link to the current location as an annotation for remember.el. | |
| 196 If you are using Org-mode files as target for data storage with | |
| 197 remember.el, then the annotations should include a link compatible with the | |
| 198 conventions in Org-mode. This function returns such a link." | |
| 199 (org-store-link nil)) | |
| 200 | |
| 201 (defconst org-remember-help | |
| 202 "Select a destination location for the note. | |
| 203 UP/DOWN=headline TAB=cycle visibility [Q]uit RET/<left>/<right>=Store | |
| 204 RET on headline -> Store as sublevel entry to current headline | |
| 205 RET at beg-of-buf -> Append to file as level 2 headline | |
| 206 <left>/<right> -> before/after current headline, same headings level") | |
| 207 | |
| 208 (defvar org-remember-previous-location nil) | |
| 209 (defvar org-force-remember-template-char) ;; dynamically scoped | |
| 210 | |
| 211 ;; Save the major mode of the buffer we called remember from | |
| 212 (defvar org-select-template-temp-major-mode nil) | |
| 213 | |
| 214 ;; Temporary store the buffer where remember was called from | |
| 215 (defvar org-select-template-original-buffer nil) | |
| 216 | |
| 217 (defun org-select-remember-template (&optional use-char) | |
| 218 (when org-remember-templates | |
| 219 (let* ((pre-selected-templates | |
| 220 (mapcar | |
| 221 (lambda (tpl) | |
| 222 (let ((ctxt (nth 5 tpl)) | |
| 223 (mode org-select-template-temp-major-mode) | |
| 224 (buf org-select-template-original-buffer)) | |
| 225 (and (or (not ctxt) (eq ctxt t) | |
| 226 (and (listp ctxt) (memq mode ctxt)) | |
| 227 (and (functionp ctxt) | |
| 228 (with-current-buffer buf | |
| 229 ;; Protect the user-defined function from error | |
| 230 (condition-case nil (funcall ctxt) (error nil))))) | |
| 231 tpl))) | |
| 232 org-remember-templates)) | |
| 233 ;; If no template at this point, add the default templates: | |
| 234 (pre-selected-templates1 | |
| 235 (if (not (delq nil pre-selected-templates)) | |
| 236 (mapcar (lambda(x) (if (not (nth 5 x)) x)) | |
| 237 org-remember-templates) | |
| 238 pre-selected-templates)) | |
| 239 ;; Then unconditionnally add template for any contexts | |
| 240 (pre-selected-templates2 | |
| 241 (append (mapcar (lambda(x) (if (eq (nth 5 x) t) x)) | |
| 242 org-remember-templates) | |
| 243 (delq nil pre-selected-templates1))) | |
| 244 (templates (mapcar (lambda (x) | |
| 245 (if (stringp (car x)) | |
| 246 (append (list (nth 1 x) (car x)) (cddr x)) | |
| 247 (append (list (car x) "") (cdr x)))) | |
| 248 (delq nil pre-selected-templates2))) | |
| 249 (char (or use-char | |
| 250 (cond | |
| 251 ((= (length templates) 1) | |
| 252 (caar templates)) | |
| 253 ((and (boundp 'org-force-remember-template-char) | |
| 254 org-force-remember-template-char) | |
| 255 (if (stringp org-force-remember-template-char) | |
| 256 (string-to-char org-force-remember-template-char) | |
| 257 org-force-remember-template-char)) | |
| 258 (t | |
| 259 (message "Select template: %s" | |
| 260 (mapconcat | |
| 261 (lambda (x) | |
| 262 (cond | |
| 263 ((not (string-match "\\S-" (nth 1 x))) | |
| 264 (format "[%c]" (car x))) | |
| 265 ((equal (downcase (car x)) | |
| 266 (downcase (aref (nth 1 x) 0))) | |
| 267 (format "[%c]%s" (car x) | |
| 268 (substring (nth 1 x) 1))) | |
| 269 (t (format "[%c]%s" (car x) (nth 1 x))))) | |
| 270 templates " ")) | |
| 271 (let ((inhibit-quit t) (char0 (read-char-exclusive))) | |
| 272 (when (equal char0 ?\C-g) | |
| 273 (jump-to-register remember-register) | |
| 274 (kill-buffer remember-buffer)) | |
| 275 char0)))))) | |
| 276 (cddr (assoc char templates))))) | |
| 277 | |
| 278 (defun org-get-x-clipboard (value) | |
| 279 "Get the value of the x clibboard, in a way that also works with XEmacs." | |
| 280 (if (eq window-system 'x) | |
| 281 (let ((x (if org-xemacs-p | |
| 282 (org-no-warnings (get-selection-no-error value)) | |
| 283 (and (fboundp 'x-selection-value) | |
| 284 (x-selection-value value))))) | |
| 285 (and (> (length x) 0) (set-text-properties 0 (length x) nil x) x)))) | |
| 286 | |
| 287 ;;;###autoload | |
| 288 (defun org-remember-apply-template (&optional use-char skip-interactive) | |
| 289 "Initialize *remember* buffer with template, invoke `org-mode'. | |
| 290 This function should be placed into `remember-mode-hook' and in fact requires | |
| 291 to be run from that hook to function properly." | |
| 292 (if org-remember-templates | |
| 293 (let* ((entry (org-select-remember-template use-char)) | |
| 294 (tpl (car entry)) | |
| 295 (plist-p (if org-store-link-plist t nil)) | |
| 296 (file (if (and (nth 1 entry) (stringp (nth 1 entry)) | |
| 297 (string-match "\\S-" (nth 1 entry))) | |
| 298 (nth 1 entry) | |
| 299 org-default-notes-file)) | |
| 300 (headline (nth 2 entry)) | |
| 301 (v-c (and (> (length kill-ring) 0) (current-kill 0))) | |
| 302 (v-x (or (org-get-x-clipboard 'PRIMARY) | |
| 303 (org-get-x-clipboard 'CLIPBOARD) | |
| 304 (org-get-x-clipboard 'SECONDARY))) | |
| 305 (v-t (format-time-string (car org-time-stamp-formats) (org-current-time))) | |
| 306 (v-T (format-time-string (cdr org-time-stamp-formats) (org-current-time))) | |
| 307 (v-u (concat "[" (substring v-t 1 -1) "]")) | |
| 308 (v-U (concat "[" (substring v-T 1 -1) "]")) | |
| 309 ;; `initial' and `annotation' are bound in `remember' | |
| 310 (v-i (if (boundp 'initial) initial)) | |
| 311 (v-a (if (and (boundp 'annotation) annotation) | |
| 312 (if (equal annotation "[[]]") "" annotation) | |
| 313 "")) | |
| 314 (clipboards (remove nil (list v-i | |
| 315 (org-get-x-clipboard 'PRIMARY) | |
| 316 (org-get-x-clipboard 'CLIPBOARD) | |
| 317 (org-get-x-clipboard 'SECONDARY) | |
| 318 v-c))) | |
| 319 (v-A (if (and v-a | |
| 320 (string-match "\\[\\(\\[.*?\\]\\)\\(\\[.*?\\]\\)?\\]" v-a)) | |
| 321 (replace-match "[\\1[%^{Link description}]]" nil nil v-a) | |
| 322 v-a)) | |
| 323 (v-n user-full-name) | |
| 324 (org-startup-folded nil) | |
| 325 org-time-was-given org-end-time-was-given x | |
| 326 prompt completions char time pos default histvar) | |
| 327 (when (and file (not (file-name-absolute-p file))) | |
| 328 (setq file (expand-file-name file org-directory))) | |
| 329 (setq org-store-link-plist | |
| 330 (append (list :annotation v-a :initial v-i) | |
| 331 org-store-link-plist)) | |
| 332 (unless tpl (setq tpl "") (message "No template") (ding) (sit-for 1)) | |
| 333 (erase-buffer) | |
| 334 (insert (substitute-command-keys | |
| 335 (format | |
| 336 "## Filing location: Select interactively, default, or last used: | |
| 337 ## %s to select file and header location interactively. | |
| 338 ## %s \"%s\" -> \"* %s\" | |
| 339 ## C-u C-u C-c C-c \"%s\" -> \"* %s\" | |
| 340 ## To switch templates, use `\\[org-remember]'. To abort use `C-c C-k'.\n\n" | |
| 341 (if org-remember-store-without-prompt " C-u C-c C-c" " C-c C-c") | |
| 342 (if org-remember-store-without-prompt " C-c C-c" " C-u C-c C-c") | |
| 343 (abbreviate-file-name (or file org-default-notes-file)) | |
| 344 (or headline "") | |
| 345 (or (car org-remember-previous-location) "???") | |
| 346 (or (cdr org-remember-previous-location) "???")))) | |
| 347 (insert tpl) (goto-char (point-min)) | |
| 348 ;; Simple %-escapes | |
| 349 (while (re-search-forward "%\\([tTuUaiAcx]\\)" nil t) | |
| 350 (when (and initial (equal (match-string 0) "%i")) | |
| 351 (save-match-data | |
| 352 (let* ((lead (buffer-substring | |
| 353 (point-at-bol) (match-beginning 0)))) | |
| 354 (setq v-i (mapconcat 'identity | |
| 355 (org-split-string initial "\n") | |
| 356 (concat "\n" lead)))))) | |
| 357 (replace-match | |
| 358 (or (eval (intern (concat "v-" (match-string 1)))) "") | |
| 359 t t)) | |
| 360 | |
| 361 ;; %[] Insert contents of a file. | |
| 362 (goto-char (point-min)) | |
| 363 (while (re-search-forward "%\\[\\(.+\\)\\]" nil t) | |
| 364 (let ((start (match-beginning 0)) | |
| 365 (end (match-end 0)) | |
| 366 (filename (expand-file-name (match-string 1)))) | |
| 367 (goto-char start) | |
| 368 (delete-region start end) | |
| 369 (condition-case error | |
| 370 (insert-file-contents filename) | |
| 371 (error (insert (format "%%![Couldn't insert %s: %s]" | |
| 372 filename error)))))) | |
| 373 ;; %() embedded elisp | |
| 374 (goto-char (point-min)) | |
| 375 (while (re-search-forward "%\\((.+)\\)" nil t) | |
| 376 (goto-char (match-beginning 0)) | |
| 377 (let ((template-start (point))) | |
| 378 (forward-char 1) | |
| 379 (let ((result | |
| 380 (condition-case error | |
| 381 (eval (read (current-buffer))) | |
| 382 (error (format "%%![Error: %s]" error))))) | |
| 383 (delete-region template-start (point)) | |
| 384 (insert result)))) | |
| 385 | |
| 386 ;; From the property list | |
| 387 (when plist-p | |
| 388 (goto-char (point-min)) | |
| 389 (while (re-search-forward "%\\(:[-a-zA-Z]+\\)" nil t) | |
| 390 (and (setq x (or (plist-get org-store-link-plist | |
| 391 (intern (match-string 1))) "")) | |
| 392 (replace-match x t t)))) | |
| 393 | |
| 394 ;; Turn on org-mode in the remember buffer, set local variables | |
| 395 (org-mode) | |
| 396 (org-set-local 'org-finish-function 'org-remember-finalize) | |
| 397 (if (and file (string-match "\\S-" file) (not (file-directory-p file))) | |
| 398 (org-set-local 'org-default-notes-file file)) | |
| 399 (if (and headline (stringp headline) (string-match "\\S-" headline)) | |
| 400 (org-set-local 'org-remember-default-headline headline)) | |
| 401 ;; Interactive template entries | |
| 402 (goto-char (point-min)) | |
| 403 (while (re-search-forward "%^\\({\\([^}]*\\)}\\)?\\([gGuUtTCL]\\)?" nil t) | |
| 404 (setq char (if (match-end 3) (match-string 3)) | |
| 405 prompt (if (match-end 2) (match-string 2))) | |
| 406 (goto-char (match-beginning 0)) | |
| 407 (replace-match "") | |
| 408 (setq completions nil default nil) | |
| 409 (when prompt | |
| 410 (setq completions (org-split-string prompt "|") | |
| 411 prompt (pop completions) | |
| 412 default (car completions) | |
| 413 histvar (intern (concat | |
| 414 "org-remember-template-prompt-history::" | |
| 415 (or prompt ""))) | |
| 416 completions (mapcar 'list completions))) | |
| 417 (cond | |
| 418 ((member char '("G" "g")) | |
| 419 (let* ((org-last-tags-completion-table | |
| 420 (org-global-tags-completion-table | |
| 421 (if (equal char "G") (org-agenda-files) (and file (list file))))) | |
| 422 (org-add-colon-after-tag-completion t) | |
| 423 (ins (completing-read | |
| 424 (if prompt (concat prompt ": ") "Tags: ") | |
| 425 'org-tags-completion-function nil nil nil | |
| 426 'org-tags-history))) | |
| 427 (setq ins (mapconcat 'identity | |
| 428 (org-split-string ins (org-re "[^[:alnum:]_@]+")) | |
| 429 ":")) | |
| 430 (when (string-match "\\S-" ins) | |
| 431 (or (equal (char-before) ?:) (insert ":")) | |
| 432 (insert ins) | |
| 433 (or (equal (char-after) ?:) (insert ":"))))) | |
| 434 ((equal char "C") | |
| 435 (cond ((= (length clipboards) 1) (insert (car clipboards))) | |
| 436 ((> (length clipboards) 1) | |
| 437 (insert (read-string "Clipboard/kill value: " | |
| 438 (car clipboards) '(clipboards . 1) | |
| 439 (car clipboards)))))) | |
| 440 ((equal char "L") | |
| 441 (cond ((= (length clipboards) 1) | |
| 442 (org-insert-link 0 (car clipboards))) | |
| 443 ((> (length clipboards) 1) | |
| 444 (org-insert-link 0 (read-string "Clipboard/kill value: " | |
| 445 (car clipboards) | |
| 446 '(clipboards . 1) | |
| 447 (car clipboards)))))) | |
| 448 (char | |
| 449 (setq org-time-was-given (equal (upcase char) char)) | |
| 450 (setq time (org-read-date (equal (upcase char) "U") t nil | |
| 451 prompt)) | |
| 452 (org-insert-time-stamp time org-time-was-given | |
| 453 (member char '("u" "U")) | |
| 454 nil nil (list org-end-time-was-given))) | |
| 455 (t | |
| 456 (insert (org-completing-read | |
| 457 (concat (if prompt prompt "Enter string") | |
| 458 (if default (concat " [" default "]")) | |
| 459 ": ") | |
| 460 completions nil nil nil histvar default))))) | |
| 461 (goto-char (point-min)) | |
| 462 (if (re-search-forward "%\\?" nil t) | |
| 463 (replace-match "") | |
| 464 (and (re-search-forward "^[^#\n]" nil t) (backward-char 1)))) | |
| 465 (org-mode) | |
| 466 (org-set-local 'org-finish-function 'org-remember-finalize)) | |
| 467 (when (save-excursion | |
| 468 (goto-char (point-min)) | |
| 469 (re-search-forward "%!" nil t)) | |
| 470 (replace-match "") | |
| 471 (add-hook 'post-command-hook 'org-remember-finish-immediately 'append))) | |
| 472 | |
| 473 (defun org-remember-finish-immediately () | |
| 474 "File remember note immediately. | |
| 475 This should be run in `post-command-hook' and will remove itself | |
| 476 from that hook." | |
| 477 (remove-hook 'post-command-hook 'org-remember-finish-immediately) | |
| 478 (when org-finish-function | |
| 479 (funcall org-finish-function))) | |
| 480 | |
| 481 (defvar org-clock-marker) ; Defined below | |
| 482 (defun org-remember-finalize () | |
| 483 "Finalize the remember process." | |
| 484 (unless (fboundp 'remember-finalize) | |
| 485 (defalias 'remember-finalize 'remember-buffer)) | |
| 486 (when (and org-clock-marker | |
| 487 (equal (marker-buffer org-clock-marker) (current-buffer))) | |
| 488 ;; FIXME: test this, this is w/o notetaking! | |
| 489 (let (org-log-note-clock-out) (org-clock-out))) | |
| 490 (when buffer-file-name | |
| 491 (save-buffer) | |
| 492 (setq buffer-file-name nil)) | |
| 493 (remember-finalize)) | |
| 494 | |
| 495 ;;;###autoload | |
| 496 (defun org-remember (&optional goto org-force-remember-template-char) | |
| 497 "Call `remember'. If this is already a remember buffer, re-apply template. | |
| 498 If there is an active region, make sure remember uses it as initial content | |
| 499 of the remember buffer. | |
| 500 | |
| 501 When called interactively with a `C-u' prefix argument GOTO, don't remember | |
| 502 anything, just go to the file/headline where the selected template usually | |
| 503 stores its notes. With a double prefix arg `C-u C-u', go to the last | |
| 504 note stored by remember. | |
| 505 | |
| 506 Lisp programs can set ORG-FORCE-REMEMBER-TEMPLATE-CHAR to a character | |
| 507 associated with a template in `org-remember-templates'." | |
| 508 (interactive "P") | |
| 509 (cond | |
| 510 ((equal goto '(4)) (org-go-to-remember-target)) | |
| 511 ((equal goto '(16)) (org-remember-goto-last-stored)) | |
| 512 (t | |
| 513 ;; set temporary variables that will be needed in | |
| 514 ;; `org-select-remember-template' | |
| 515 (setq org-select-template-temp-major-mode major-mode) | |
| 516 (setq org-select-template-original-buffer (current-buffer)) | |
| 517 (if (eq org-finish-function 'org-remember-finalize) | |
| 518 (progn | |
| 519 (when (< (length org-remember-templates) 2) | |
| 520 (error "No other template available")) | |
| 521 (erase-buffer) | |
| 522 (let ((annotation (plist-get org-store-link-plist :annotation)) | |
| 523 (initial (plist-get org-store-link-plist :initial))) | |
| 524 (org-remember-apply-template)) | |
| 525 (message "Press C-c C-c to remember data")) | |
| 526 (if (org-region-active-p) | |
| 527 (org-do-remember (buffer-substring (point) (mark))) | |
| 528 (org-do-remember)))))) | |
| 529 | |
| 530 (defun org-remember-goto-last-stored () | |
| 531 "Go to the location where the last remember note was stored." | |
| 532 (interactive) | |
| 533 (bookmark-jump "org-remember-last-stored") | |
| 534 (message "This is the last note stored by remember")) | |
| 535 | |
| 536 (defun org-go-to-remember-target (&optional template-key) | |
| 537 "Go to the target location of a remember template. | |
| 538 The user is queried for the template." | |
| 539 (interactive) | |
| 540 (let* (org-select-template-temp-major-mode | |
| 541 (entry (org-select-remember-template template-key)) | |
| 542 (file (nth 1 entry)) | |
| 543 (heading (nth 2 entry)) | |
| 544 visiting) | |
| 545 (unless (and file (stringp file) (string-match "\\S-" file)) | |
| 546 (setq file org-default-notes-file)) | |
| 547 (when (and file (not (file-name-absolute-p file))) | |
| 548 (setq file (expand-file-name file org-directory))) | |
| 549 (unless (and heading (stringp heading) (string-match "\\S-" heading)) | |
| 550 (setq heading org-remember-default-headline)) | |
| 551 (setq visiting (org-find-base-buffer-visiting file)) | |
| 552 (if (not visiting) (find-file-noselect file)) | |
| 553 (switch-to-buffer (or visiting (get-file-buffer file))) | |
| 554 (widen) | |
| 555 (goto-char (point-min)) | |
| 556 (if (re-search-forward | |
| 557 (concat "^\\*+[ \t]+" (regexp-quote heading) | |
| 558 (org-re "\\([ \t]+:[[:alnum:]@_:]*\\)?[ \t]*$")) | |
| 559 nil t) | |
| 560 (goto-char (match-beginning 0)) | |
| 561 (error "Target headline not found: %s" heading)))) | |
| 562 | |
| 563 ;;;###autoload | |
| 564 (defun org-remember-handler () | |
| 565 "Store stuff from remember.el into an org file. | |
| 566 First prompts for an org file. If the user just presses return, the value | |
| 567 of `org-default-notes-file' is used. | |
| 568 Then the command offers the headings tree of the selected file in order to | |
| 569 file the text at a specific location. | |
| 570 You can either immediately press RET to get the note appended to the | |
| 571 file, or you can use vertical cursor motion and visibility cycling (TAB) to | |
| 572 find a better place. Then press RET or <left> or <right> in insert the note. | |
| 573 | |
| 574 Key Cursor position Note gets inserted | |
| 575 ----------------------------------------------------------------------------- | |
| 576 RET buffer-start as level 1 heading at end of file | |
| 577 RET on headline as sublevel of the heading at cursor | |
| 578 RET no heading at cursor position, level taken from context. | |
| 579 Or use prefix arg to specify level manually. | |
| 580 <left> on headline as same level, before current heading | |
| 581 <right> on headline as same level, after current heading | |
| 582 | |
| 583 So the fastest way to store the note is to press RET RET to append it to | |
| 584 the default file. This way your current train of thought is not | |
| 585 interrupted, in accordance with the principles of remember.el. | |
| 586 You can also get the fast execution without prompting by using | |
| 587 C-u C-c C-c to exit the remember buffer. See also the variable | |
| 588 `org-remember-store-without-prompt'. | |
| 589 | |
| 590 Before being stored away, the function ensures that the text has a | |
| 591 headline, i.e. a first line that starts with a \"*\". If not, a headline | |
| 592 is constructed from the current date and some additional data. | |
| 593 | |
| 594 If the variable `org-adapt-indentation' is non-nil, the entire text is | |
| 595 also indented so that it starts in the same column as the headline | |
| 596 \(i.e. after the stars). | |
| 597 | |
| 598 See also the variable `org-reverse-note-order'." | |
| 599 (goto-char (point-min)) | |
| 600 (while (looking-at "^[ \t]*\n\\|^##.*\n") | |
| 601 (replace-match "")) | |
| 602 (goto-char (point-max)) | |
| 603 (beginning-of-line 1) | |
| 604 (while (looking-at "[ \t]*$\\|##.*") | |
| 605 (delete-region (1- (point)) (point-max)) | |
| 606 (beginning-of-line 1)) | |
| 607 (catch 'quit | |
| 608 (if org-note-abort (throw 'quit nil)) | |
| 609 (let* ((txt (buffer-substring (point-min) (point-max))) | |
| 610 (fastp (org-xor (equal current-prefix-arg '(4)) | |
| 611 org-remember-store-without-prompt)) | |
| 612 (file (cond | |
| 613 (fastp org-default-notes-file) | |
| 614 ((and (eq org-remember-interactive-interface 'refile) | |
| 615 org-refile-targets) | |
| 616 org-default-notes-file) | |
| 617 ((not (and (equal current-prefix-arg '(16)) | |
| 618 org-remember-previous-location)) | |
| 619 (org-get-org-file)))) | |
| 620 (heading org-remember-default-headline) | |
| 621 (visiting (and file (org-find-base-buffer-visiting file))) | |
| 622 (org-startup-folded nil) | |
| 623 (org-startup-align-all-tables nil) | |
| 624 (org-goto-start-pos 1) | |
| 625 spos exitcmd level indent reversed) | |
| 626 (if (and (equal current-prefix-arg '(16)) org-remember-previous-location) | |
| 627 (setq file (car org-remember-previous-location) | |
| 628 heading (cdr org-remember-previous-location) | |
| 629 fastp t)) | |
| 630 (setq current-prefix-arg nil) | |
| 631 (if (string-match "[ \t\n]+\\'" txt) | |
| 632 (setq txt (replace-match "" t t txt))) | |
| 633 ;; Modify text so that it becomes a nice subtree which can be inserted | |
| 634 ;; into an org tree. | |
| 635 (let* ((lines (split-string txt "\n")) | |
| 636 first) | |
| 637 (setq first (car lines) lines (cdr lines)) | |
| 638 (if (string-match "^\\*+ " first) | |
| 639 ;; Is already a headline | |
| 640 (setq indent nil) | |
| 641 ;; We need to add a headline: Use time and first buffer line | |
| 642 (setq lines (cons first lines) | |
| 643 first (concat "* " (current-time-string) | |
| 644 " (" (remember-buffer-desc) ")") | |
| 645 indent " ")) | |
| 646 (if (and org-adapt-indentation indent) | |
| 647 (setq lines (mapcar | |
| 648 (lambda (x) | |
| 649 (if (string-match "\\S-" x) | |
| 650 (concat indent x) x)) | |
| 651 lines))) | |
| 652 (setq txt (concat first "\n" | |
| 653 (mapconcat 'identity lines "\n")))) | |
| 654 (if (string-match "\n[ \t]*\n[ \t\n]*\\'" txt) | |
| 655 (setq txt (replace-match "\n\n" t t txt)) | |
| 656 (if (string-match "[ \t\n]*\\'" txt) | |
| 657 (setq txt (replace-match "\n" t t txt)))) | |
| 658 ;; Put the modified text back into the remember buffer, for refile. | |
| 659 (erase-buffer) | |
| 660 (insert txt) | |
| 661 (goto-char (point-min)) | |
| 662 (when (and (eq org-remember-interactive-interface 'refile) | |
| 663 (not fastp)) | |
| 664 (org-refile nil (or visiting (find-file-noselect file))) | |
| 665 (throw 'quit t)) | |
| 666 ;; Find the file | |
| 667 (if (not visiting) (find-file-noselect file)) | |
| 668 (with-current-buffer (or visiting (get-file-buffer file)) | |
| 669 (unless (org-mode-p) | |
| 670 (error "Target files for remember notes must be in Org-mode")) | |
| 671 (save-excursion | |
| 672 (save-restriction | |
| 673 (widen) | |
| 674 (and (goto-char (point-min)) | |
| 675 (not (re-search-forward "^\\* " nil t)) | |
| 676 (insert "\n* " (or heading "Notes") "\n")) | |
| 677 (setq reversed (org-notes-order-reversed-p)) | |
| 678 | |
| 679 ;; Find the default location | |
| 680 (when (and heading (stringp heading) (string-match "\\S-" heading)) | |
| 681 (goto-char (point-min)) | |
| 682 (if (re-search-forward | |
| 683 (concat "^\\*+[ \t]+" (regexp-quote heading) | |
| 684 (org-re "\\([ \t]+:[[:alnum:]@_:]*\\)?[ \t]*$")) | |
| 685 nil t) | |
| 686 (setq org-goto-start-pos (match-beginning 0)) | |
| 687 (when fastp | |
| 688 (goto-char (point-max)) | |
| 689 (unless (bolp) (newline)) | |
| 690 (insert "* " heading "\n") | |
| 691 (setq org-goto-start-pos (point-at-bol 0))))) | |
| 692 | |
| 693 ;; Ask the User for a location, using the appropriate interface | |
| 694 (cond | |
| 695 (fastp (setq spos org-goto-start-pos | |
| 696 exitcmd 'return)) | |
| 697 ((eq org-remember-interactive-interface 'outline) | |
| 698 (setq spos (org-get-location (current-buffer) | |
| 699 org-remember-help) | |
| 700 exitcmd (cdr spos) | |
| 701 spos (car spos))) | |
| 702 ((eq org-remember-interactive-interface 'outline-path-completion) | |
| 703 (let ((org-refile-targets '((nil . (:maxlevel . 10)))) | |
| 704 (org-refile-use-outline-path t)) | |
| 705 (setq spos (org-refile-get-location "Heading: ") | |
| 706 exitcmd 'return | |
| 707 spos (nth 3 spos)))) | |
| 708 (t (error "This should not happen"))) | |
| 709 (if (not spos) (throw 'quit nil)) ; return nil to show we did | |
| 710 ; not handle this note | |
| 711 (goto-char spos) | |
| 712 (cond ((org-on-heading-p t) | |
| 713 (org-back-to-heading t) | |
| 714 (setq level (funcall outline-level)) | |
| 715 (cond | |
| 716 ((eq exitcmd 'return) | |
| 717 ;; sublevel of current | |
| 718 (setq org-remember-previous-location | |
| 719 (cons (abbreviate-file-name file) | |
| 720 (org-get-heading 'notags))) | |
| 721 (if reversed | |
| 722 (outline-next-heading) | |
| 723 (org-end-of-subtree t) | |
| 724 (if (not (bolp)) | |
| 725 (if (looking-at "[ \t]*\n") | |
| 726 (beginning-of-line 2) | |
| 727 (end-of-line 1) | |
| 728 (insert "\n")))) | |
| 729 (bookmark-set "org-remember-last-stored") | |
| 730 (org-paste-subtree (org-get-valid-level level 1) txt)) | |
| 731 ((eq exitcmd 'left) | |
| 732 ;; before current | |
| 733 (bookmark-set "org-remember-last-stored") | |
| 734 (org-paste-subtree level txt)) | |
| 735 ((eq exitcmd 'right) | |
| 736 ;; after current | |
| 737 (org-end-of-subtree t) | |
| 738 (bookmark-set "org-remember-last-stored") | |
| 739 (org-paste-subtree level txt)) | |
| 740 (t (error "This should not happen")))) | |
| 741 | |
| 742 ((and (bobp) (not reversed)) | |
| 743 ;; Put it at the end, one level below level 1 | |
| 744 (save-restriction | |
| 745 (widen) | |
| 746 (goto-char (point-max)) | |
| 747 (if (not (bolp)) (newline)) | |
| 748 (bookmark-set "org-remember-last-stored") | |
| 749 (org-paste-subtree (org-get-valid-level 1 1) txt))) | |
| 750 | |
| 751 ((and (bobp) reversed) | |
| 752 ;; Put it at the start, as level 1 | |
| 753 (save-restriction | |
| 754 (widen) | |
| 755 (goto-char (point-min)) | |
| 756 (re-search-forward "^\\*+ " nil t) | |
| 757 (beginning-of-line 1) | |
| 758 (bookmark-set "org-remember-last-stored") | |
| 759 (org-paste-subtree 1 txt))) | |
| 760 (t | |
| 761 ;; Put it right there, with automatic level determined by | |
| 762 ;; org-paste-subtree or from prefix arg | |
| 763 (bookmark-set "org-remember-last-stored") | |
| 764 (org-paste-subtree | |
| 765 (if (numberp current-prefix-arg) current-prefix-arg) | |
| 766 txt))) | |
| 767 (when remember-save-after-remembering | |
| 768 (save-buffer) | |
| 769 (if (not visiting) (kill-buffer (current-buffer))))))))) | |
| 770 | |
| 771 t) ;; return t to indicate that we took care of this note. | |
| 772 | |
| 773 | |
| 774 (defun org-do-remember (&optional initial) | |
| 775 "Call remember." | |
| 776 (remember initial)) | |
| 777 | |
| 778 (provide 'org-remember) | |
| 779 | |
| 780 ;;; org-remember.el ends here | |
| 781 |