"Are we using the new outline mode?")
(defgroup org nil
- "Outline-based notes management and organizer "
+ "Outline-based notes management and organizer."
:tag "Org"
:group 'outlines
:group 'hypermedia
:type 'string)
(defcustom org-closed-string "CLOSED:"
- "String ued as the prefix for timestamps logging closing a TODO entry."
+ "String used as the prefix for timestamps logging closing a TODO entry."
:group 'org-keywords
:type 'string)
Quoting applies only to the text in the entry following the headline, and does
not extend beyond the next headline, even if that is lower level.
An entry can be toggled between QUOTE and normal with
-\\[org-toggle-fixed-width-section]"
+\\[org-toggle-fixed-width-section]."
:group 'org-keywords
:type 'string)
(defcustom org-after-todo-state-change-hook nil
"Hook which is run after the state of a TODO item was changed.
-The new state (a string with a todo keyword, or nil) is available in the
+The new state (a string with a TODO keyword, or nil) is available in the
Lisp variable `state'."
:group 'org-keywords
:type 'hook)
(defcustom org-calendar-to-agenda-key [?c]
"The key to be installed in `calendar-mode-map' for switching to the agenda.
The command `org-calendar-goto-agenda' will be bound to this key. The
-default is the character `c' because then`c' can be used to switch back and
-force between agenda and calendar."
+default is the character `c' because then `c' can be used to switch back and
+forth between agenda and calendar."
:group 'org-agenda
:type 'sexp)
"Sorting structure for the agenda items of a single day.
This is a list of symbols which will be used in sequence to determine
if an entry should be listed before another entry. The following
-symbols are recognized.
+symbols are recognized:
time-up Put entries with time-of-day indications first, early first
time-down Put entries with time-of-day indications first, late first
(defcustom org-agenda-use-time-grid t
"Non-nil means, show a time grid in the agenda schedule.
A time grid is a set of lines for specific times (like every two hours between
-8:00 and 20:00. The items scheduled for a day at specific times are
+8:00 and 20:00). The items scheduled for a day at specific times are
sorted in between these lines.
For deails about when the grid will be shown, and what it will look like, see
the variable `org-agenda-time-grid'."
When doing an `org-occur' it is useful to show the headline which
follows the match, even if they do not match the regexp. This makes it
easier to edit directly inside the sparse tree. However, if you use
-org-occur mainly as an overview, the following headlines are
+`org-occur' mainly as an overview, the following headlines are
unnecessary clutter."
:group 'org-structure
:type 'boolean)
(defcustom org-level-color-stars-only nil
"Non-nil means fontify only the stars in each headline.
When nil, the entire headline is fontified.
-After changin this, requires restart of Emacs to become effective."
+Changing it requires a restart of Emacs to become effective."
:group 'org-structure
:type 'boolean)
(defcustom org-tags-column 48
"The column to which tags should be indented in a headline.
-If this number is positive, it specified the column. If it is negative,
+If this number is positive, it specifies the column. If it is negative,
it means that the tags should be flushright to that column. For example,
-79 works well for a normal 80 character screen."
:group 'org-tags
(defcustom org-use-tag-inheritance t
"Non-nil means, tags in levels apply also for sublevels.
-When nil, only the tags directly give in a specific line apply there.
+When nil, only the tags directly given in a specific line apply there.
If you turn off this option, you very likely want to turn on the
companion option `org-tags-match-list-sublevels'."
:group 'org-tags
When nil, it becomes possible to put several links into a line.
Note that in tables, a link never extends accross fields, so in a table
it is always possible to put several links into a line.
-Changing this varable requires a re-launch of Emacs of become effective."
+Changing this variable requires a restart of Emacs to become effective."
:group 'org-link
:type 'boolean)
(const find-file-other-frame)))))
(defcustom org-usenet-links-prefer-google nil
- "Non-nil means, `org-store-link' will create web links to google groups.
+ "Non-nil means, `org-store-link' will create web links to Google groups.
When nil, Gnus will be used for such links.
Using a prefix arg to the command \\[org-store-link] (`org-store-link')
negates this setting for the duration of the command."
(defconst org-file-apps-defaults-gnu
'((t . mailcap))
- "Default file applications on a UNIX/LINUX system.
+ "Default file applications on a UNIX or GNU/Linux system.
See `org-file-apps'.")
(defconst org-file-apps-defaults-macosx
When nil, such lines will be treated like ordinary lines.
When equal to the symbol `optimized', the table editor will be optimized to
-do the following
+do the following:
- Use automatic overwrite mode in front of whitespace in table fields.
This make the structure of the table stay in tact as long as the edited
field does not exceed the column width.
calc-display-working-message t
)
"List with Calc mode settings for use in calc-eval for table formulas.
-The list must contain alternating symbols (calc modes variables and values.
+The list must contain alternating symbols (Calc modes variables and values).
Don't remove any of the default settings, just change the values. Org-mode
relies on the variables to be present in the list."
:group 'org-table-calculation
:type 'boolean)
(defcustom org-table-allow-automatic-line-recalculation t
- "Non-nil means, lines makred with |#| or |*| will be recomputed automatically.
+ "Non-nil means, lines marked with |#| or |*| will be recomputed automatically.
Automatically means, when TAB or RET or C-c C-c are pressed in the line."
:group 'org-table-calculation
:type 'boolean)
:group 'org-export
:type 'string)
-(defcustom org-export-html-style
+(defcustom org-export-html-style
"<style type=\"text/css\">
html {
font-family: Times, serif;
"The default style specification for exported HTML files.
Since there are different ways of setting style information, this variable
needs to contain the full HTML structure to provide a style, including the
-surrounding HTML tags. The style specifications should include definiitons
+surrounding HTML tags. The style specifications should include definitions
for new classes todo, done, title, and deadline. For example, legal values
-would be.
+would be:
<style type=\"text/css\">
- p {font-weight: normal; color: gray; }
- h1 {color: black; }
+ p { font-weight: normal; color: gray; }
+ h1 { color: black; }
.title { text-align: center; }
.todo, .deadline { color: red; }
.done { color: green; }
(defcustom org-export-with-fixed-width t
"Non-nil means, lines starting with \":\" will be in fixed width font.
This can be used to have pre-formatted text, fragments of code etc. For
-example
+example:
: ;; Some Lisp examples
: (while (defc cnt)
: (ding))
needed. For example, the following things will be parsed as single
sub- or superscripts.
- 10^24 or 10^tau several digits will be considered 1 item
+ 10^24 or 10^tau several digits will be considered 1 item.
10^-12 or 10^-tau a leading sign with digits or a word
x^2-y^3 will be read as x^2 - y^3, because items are
terminated by almost any nonword/nondigit char.
(((class color) (background light)) (:foreground "RosyBrown"))
(((class color) (background dark)) (:foreground "LightSalmon"))
(t (:italic t)))
- "Face used for level 8 headlines."
+ "Face used for special keywords."
:group 'org-faces)
(defface org-warning ;; font-lock-warning-face
(((class color) (background light)) (:foreground "Firebrick"))
(((class color) (background dark)) (:foreground "chocolate1"))
(t (:bold t :italic t)))
- "Face for items scheduled previously, and not yet done."
+ "Face for formulas."
:group 'org-faces)
(defface org-link
(((class color) (background light)) (:foreground "DarkGoldenrod"))
(((class color) (background dark)) (:foreground "LightGoldenrod"))
(t (:bold t :italic t)))
- "Face used for level 2 headlines."
+ "Face used for time grids."
:group 'org-faces)
(defvar org-level-faces
(defvar org-selected-point)
(defvar calendar-mode-map)
(defvar remember-save-after-remembering)
- (defvar remember-data-file))
+ (defvar remember-data-file)
+ (defvar last-arg))
;;; Define the mode
;; We use a before-change function to check if a table might need
;; an update.
(defvar org-table-may-need-update t
- "Indicates of a table might need an update.
+ "Indicates that a table might need an update.
This variable is set by `org-before-change-function'. `org-table-align'
sets it back to nil.")
(defvar org-mode-hook nil)
;;;###autoload
(define-derived-mode org-mode outline-mode "Org"
"Outline-based notes management and organizer, alias
-\"Carstens outline-mode for keeping track of everything.\"
+\"Carsten's outline-mode for keeping track of everything.\"
Org-mode develops organizational tasks around a NOTES file which
contains information about projects as plain text. Org-mode is
- When point is at the beginning of a headline, rotate the subtree started
by this line through 3 different states (local cycling)
1. FOLDED: Only the main headline is shown.
- 2. CHILDREN: The main headline and the direct children are shown. From
- this state, you can move to one of the children and
- zoom in further.
+ 2. CHILDREN: The main headline and the direct children are shown.
+ From this state, you can move to one of the children
+ and zoom in further.
3. SUBTREE: Show the entire subtree, including body text.
- When there is a numeric prefix, go up to a heading with level ARG, do
;; FIXME: It may not be a good idea to temper with the prefix argument...
(defun org-goto-ret (&optional arg)
- "Finish org-goto by going to the new location."
+ "Finish `org-goto' by going to the new location."
(interactive "P")
(setq org-selected-point (point)
current-prefix-arg arg)
(throw 'exit nil))
(defun org-goto-left ()
- "Finish org-goto by going to the new location."
+ "Finish `org-goto' by going to the new location."
(interactive)
(if (org-on-heading-p)
(progn
(error "Not on a heading")))
(defun org-goto-right ()
- "Finish org-goto by going to the new location."
+ "Finish `org-goto' by going to the new location."
(interactive)
(if (org-on-heading-p)
(progn
(error "Not on a heading")))
(defun org-goto-quit ()
- "Finish org-goto without cursor motion."
+ "Finish `org-goto' without cursor motion."
(interactive)
(setq org-selected-point nil)
(throw 'exit nil))
"To temporarily disable the active region.")
(defun org-insert-heading (&optional force-heading)
- "Insert a new heading or item with same depth at point.
-If ARG is non-nil"
+ "Insert a new heading or item with same depth at point."
(interactive "P")
(when (or force-heading (not (org-insert-item)))
(let* ((head (save-excursion
(let ((llt org-plain-list-ordered-item-terminator))
(save-excursion
(goto-char (point-at-bol))
- (looking-at
+ (looking-at
(cond
((eq llt t) "\\([ \t]*\\([-+]\\|\\([0-9]+[.)]\\)\\)\\|[ \t]+\\*\\)\\( \\|$\\)")
((= llt ?.) "\\([ \t]*\\([-+]\\|\\([0-9]+\\.\\)\\)\\|[ \t]+\\*\\)\\( \\|$\\)")
(t (error "Invalid value of `org-plain-list-ordered-item-terminator'")))))))
(defun org-get-indentation ()
- "Get the indentation of the current line, ionterpreting tabs."
+ "Get the indentation of the current line, interpreting tabs."
(save-excursion
(beginning-of-line 1)
(skip-chars-forward " \t")
"Go to the beginning of the current hand-formatted item.
If the cursor is not in an item, throw an error."
(let ((pos (point))
- (limit (save-excursion (org-back-to-heading)
+ (limit (save-excursion (org-back-to-heading)
(beginning-of-line 2) (point)))
ind ind1)
(if (org-at-item-p)
(error "Not in an item")))))
(defun org-end-of-item ()
- "Go to the beginning of the current hand-formatted item.
+ "Go to the end of the current hand-formatted item.
If the cursor is not in an item, throw an error."
(let ((pos (point))
(limit (save-excursion (outline-next-heading) (point)))
(beginning-of-line 1)
(goto-char pos)
(error "Not in an item"))))
-
+
(defun org-move-item-down (arg)
"Move the plain list item at point down, i.e. swap with following item.
-Subitems (items with larger indentation are considered part of the item,
+Subitems (items with larger indentation) are considered part of the item,
so this really moves item trees."
(interactive "p")
(let (beg end ind ind1 (pos (point)) txt)
(org-maybe-renumber-ordered-list))
(goto-char pos)
(error "Cannot move this item further down"))))
-
+
(defun org-move-item-up (arg)
"Move the plain list item at point up, i.e. swap with previous item.
-Subitems (items with larger indentation are considered part of the item,
+Subitems (items with larger indentation) are considered part of the item,
so this really moves item trees."
(interactive "p")
(let (beg end ind ind1 (pos (point)) txt)
(org-maybe-renumber-ordered-list))
(goto-char pos)
(error "Cannot move this item further up"))))
-
+
(defun org-maybe-renumber-ordered-list ()
"Renumber the ordered list at point if setup allows it.
This tests the user option `org-auto-renumber-ordered-lists' before
(defun org-renumber-ordered-list (arg)
"Renumber an ordered plain list.
-Cursor neext to be in the first line of an item, the line that starts
+Cursor next to be in the first line of an item, the line that starts
with something like \"1.\" or \"2)\"."
(interactive "p")
(unless (and (org-at-item-p)
*** TODO Write paper
*** DONE Call mom
-The different keywords are specified in the variable `org-todo-keywords'. By
-default the available states are \"TODO\" and \"DONE\".
+The different keywords are specified in the variable `org-todo-keywords'.
+By default the available states are \"TODO\" and \"DONE\".
So for this example: when the item starts with TODO, it is changed to DONE.
When it starts with DONE, the DONE is removed. And when neither TODO nor
DONE are present, add TODO at the beginning of the heading.
-With prefix arg, use completion to determined the new state. With numeric
+With prefix arg, use completion to determine the new state. With numeric
prefix arg, switch to that state."
(interactive "P")
(save-excursion
(defun org-log-done (&optional undone)
"Add a time stamp logging that a TODO entry has been closed.
-When UNDONE is non-nil, remove such a time stamg again."
+When UNDONE is non-nil, remove such a time stamp again."
(interactive)
(let (beg end col)
(save-excursion
(setq end (point))
(goto-char beg)
(when (re-search-forward (concat
- "[\r\n]\\([ \t]*"
+ "[\r\n]\\([ \t]*"
(regexp-quote org-closed-string)
" *\\[.*?\\][^\n\r]*[\n\r]?\\)") end t)
(delete-region (match-beginning 1) (match-end 1)))
(when (not (member (char-before) '(?\r ?\n)))
(insert "\n"))
(indent-to col)
- (insert org-closed-string " "
- (format-time-string
+ (insert org-closed-string " "
+ (format-time-string
(concat "[" (substring (cdr org-time-stamp-formats) 1 -1) "]")
(current-time))
"\n")))))
-
+
(defun org-show-todo-tree (arg)
"Make a compact tree which shows all headlines marked with TODO.
The tree will show the lines where the regexp matches, and all higher
The tree will show the lines where the regexp matches, and all higher
headlines above the match. It will also show the heading after the match,
to make sure editing the matching entry is easy.
-if CALLBACK is non-nil, it is a function which is called to confirm
+If CALLBACK is non-nil, it is a function which is called to confirm
that the match should indeed be shown."
(interactive "sRegexp: ")
(org-remove-occur-highlights nil nil t)
(if org-xemacs-p (make-extent beg end buffer) (make-overlay beg end buffer)))
(defun org-delete-overlay (ovl)
(if org-xemacs-p (delete-extent ovl) (delete-overlay ovl)))
-(defun org-detatch-overlay (ovl)
+(defun org-detatch-overlay (ovl)
(if org-xemacs-p (detach-extent ovl) (delete-overlay ovl)))
(defun org-move-overlay (ovl beg end &optional buffer)
(if org-xemacs-p
(defun org-remove-occur-highlights (&optional beg end noremove)
"Remove the occur highlights from the buffer.
BEG and END are ignored. If NOREMOVE is nil, remove this function
-from the before-change-functions in the current buffer."
+from the `before-change-functions' in the current buffer."
(interactive)
(mapc 'org-delete-overlay org-occur-highlights)
(setq org-occur-highlights nil)
(unless noremove
(remove-hook 'before-change-functions
'org-remove-occur-highlights 'local)))
-
+
;;; Priorities
(defvar org-priority-regexp ".*?\\(\\[#\\([A-Z]\\)\\] ?\\)"
"Read a date and make things smooth for the user.
The prompt will suggest to enter an ISO date, but you can also enter anything
which will at least partially be understood by `parse-time-string'.
-Unrecognized parts of the date will default to the current day, month ,year,
+Unrecognized parts of the date will default to the current day, month, year,
hour and minute. For example,
3-2-5 --> 2003-02-05
feb 15 --> currentyear-02-15
While prompting, a calendar is popped up - you can also select the
date with the mouse (button 1). The calendar shows a period of three
-month. To scroll it to other months, use the keys `>' and `<'.
+months. To scroll it to other months, use the keys `>' and `<'.
If you don't like the calendar, turn it off with
- \(setq org-popup-calendar-for-date-prompt nil).
+ \(setq org-popup-calendar-for-date-prompt nil)
With optional argument TO-TIME, the date will immediately be converted
to an internal time.
(defun org-goto-calendar (&optional arg)
"Go to the Emacs calendar at the current date.
If there is a time stamp in the current line, go to that date.
-A prefix ARG can be used force the current date."
+A prefix ARG can be used to force the current date."
(interactive "P")
(let ((tsr org-ts-regexp) diff
(calendar-move-hook nil)
a Call `org-agenda' to display the agenda for the current day or week.
t Call `org-todo-list' to display the global todo list.
T Call `org-todo-list' to display the global todo list, select only
- entries with a specific TODO keyword (the user get a prompt).
+ entries with a specific TODO keyword (the user gets a prompt).
m Call `org-tags-view' to display headlines with tags matching
a condition (the user is prompted for the condition).
-M like `m', but select only TODO entries, no ordinary headlines.
+M Like `m', but select only TODO entries, no ordinary headlines.
More commands can be added by configuring the variable
`org-agenda-custom-commands'. In particular, specific tags and TODO keyword
--------------------------------
a Agenda for current week or day
t List of all TODO entries T Entries with special TODO kwd
-m Match a TAGS query M Like m, but only TODO entries.
+m Match a TAGS query M Like m, but only TODO entries
C Configure your own agenda commands")
(while (setq entry (pop custom))
(setq key (car entry) type (nth 1 entry) string (nth 2 entry))
(catch 'nextfile
(org-check-agenda-file file)
(if org-agenda-show-log
- (setq rtn (org-agenda-get-day-entries
+ (setq rtn (org-agenda-get-day-entries
file date
:deadline :scheduled :timestamp :closed))
- (setq rtn (org-agenda-get-day-entries
+ (setq rtn (org-agenda-get-day-entries
file date
:deadline :scheduled :timestamp)))
(setq rtnall (append rtnall rtn))))
(message "Switched to week view"))
(defun org-agenda-day-view ()
- "Switch to weekly view for agenda."
+ "Switch to daily view for agenda."
(interactive)
(org-agenda-check-type t 'agenda)
(setq org-agenda-ndays 1)
(goto-char (match-beginning 0)))
(defun org-agenda-previous-date-line (&optional arg)
- "Jump to the next line indicating a date in agenda buffer."
+ "Jump to the previous line indicating a date in agenda buffer."
(interactive "p")
(org-agenda-check-type t 'agenda 'timeline)
(beginning-of-line 1)
(if org-agenda-follow-mode "on" "off")))
(defun org-agenda-log-mode ()
- "Toggle follow mode in an agenda buffer."
+ "Toggle log mode in an agenda buffer."
(interactive)
(org-agenda-check-type t 'agenda 'timeline)
(setq org-agenda-show-log (not org-agenda-show-log))
(if org-agenda-show-log "on" "off")))
(defun org-agenda-toggle-diary ()
- "Toggle follow mode in an agenda buffer."
+ "Toggle diary inclusion in an agenda buffer."
(interactive)
(org-agenda-check-type t 'agenda)
(setq org-agenda-include-diary (not org-agenda-include-diary))
(if org-agenda-include-diary "on" "off")))
(defun org-agenda-toggle-time-grid ()
- "Toggle follow mode in an agenda buffer."
+ "Toggle time grid in an agenda buffer."
(interactive)
(org-agenda-check-type t 'agenda)
(setq org-agenda-use-time-grid (not org-agenda-use-time-grid))
entries)))))
(defun org-agenda-cleanup-fancy-diary ()
- "Remove unwanted stuff in buffer created by fancy-diary-display.
+ "Remove unwanted stuff in buffer created by `fancy-diary-display'.
This gets rid of the date, the underline under the date, and
the dummy entry installed by `org-mode' to ensure non-empty diary for each
-date. Itt also removes lines that contain only whitespace."
+date. It also removes lines that contain only whitespace."
(goto-char (point-min))
(if (looking-at ".*?:[ \t]*")
(progn
(find-file (car org-agenda-files)))))
(defun org-agenda-file-to-end (&optional file)
- "Move/add the current file to the end of the agenda fiole list.
-I the file is not present in the list, it is appended ot the list. If it is
+ "Move/add the current file to the end of the agenda file list.
+If the file is not present in the list, it is appended to the list. If it is
present, it is moved there."
(interactive)
(org-agenda-file-to-front 'to-end file))
'help-echo
(format "mouse-2 or RET jump to org file %s"
(abbreviate-file-name (buffer-file-name)))))
- (regexp (concat "[\n\r]\\*+ *\\("
+ (regexp (concat "[\n\r]\\*+ *\\("
(if org-select-this-todo-keyword
(concat "\\<\\(" org-select-this-todo-keyword
"\\)\\>")
(nreverse ee)))
(defconst org-agenda-no-heading-message
- "No heading for this item in buffer or region")
+ "No heading for this item in buffer or region.")
(defun org-agenda-get-timestamps ()
"Return the date stamp information for agenda display."
(nreverse ee)))
(defun org-agenda-get-closed ()
- "Return the loggedd TODO entries for agenda display."
+ "Return the logged TODO entries for agenda display."
(let* ((props (list 'mouse-face 'highlight
'keymap org-agenda-keymap
'help-echo
(if (string-match org-looking-at-done-regexp head)
(setq txt nil)
(setq txt (org-format-agenda-item
- (format "Sched.%2dx: " (- 1 diff)) head
+ (format "Sched.%2dx: " (- 1 diff)) head
category tags))))
(setq txt org-agenda-no-heading-message))
(when txt
"Format TXT to be inserted into the agenda buffer.
In particular, it adds the prefix and corresponding text properties. EXTRA
must be a string and replaces the `%s' specifier in the prefix format.
-CATEGORY (string, symbol or nil) may be used to overule the default
-category taken from local variable or file name. It will replace the `%c'
+CATEGORY (string, symbol or nil) may be used to overrule the default
+category taken from local variable or file name. It will replace the `%c'
specifier in the format. DOTIME, when non-nil, indicates that a
time-of-day should be extracted from TXT for sorting of this entry, and for
the `%t' specifier in the format. When DOTIME is a string, this string is
searched for a time before TXT is. NOPREFIX is a flag and indicates that
only the correctly processes TXT should be returned - this is used by
-`org-agenda-change-all-lines'. TAG can be the tag of the headline."
+`org-agenda-change-all-lines'. TAG can be the tag of the headline."
(save-match-data
;; Diary entries sometimes have extra whitespace at the beginning
(if (string-match "^ +" txt) (setq txt (replace-match "" nil nil txt)))
(mapconcat 'identity (sort list 'org-entries-lessp) "\n"))
(defsubst org-cmp-priority (a b)
- "Compare the priorities of string a and b."
+ "Compare the priorities of string A and B."
(let ((pa (or (get-text-property 1 'priority a) 0))
(pb (or (get-text-property 1 'priority b) 0)))
(cond ((> pa pb) +1)
(t nil))))
(defsubst org-cmp-category (a b)
- "Compare the string values of categories of strings a and b."
+ "Compare the string values of categories of strings A and B."
(let ((ca (or (get-text-property 1 'category a) ""))
(cb (or (get-text-property 1 'category b) "")))
(cond ((string-lessp ca cb) -1)
(t nil))))
(defsubst org-cmp-time (a b)
- "Compare the time-of-day values of strings a and b."
+ "Compare the time-of-day values of strings A and B."
(let* ((def (if org-sort-agenda-notime-is-late 2401 -1))
(ta (or (get-text-property 1 'time-of-day a) def))
(tb (or (get-text-property 1 'time-of-day b) def)))
(move-to-column col)))
(defun org-agenda-change-all-lines (newhead hdmarker &optional fixface)
- "Change all lines in the agenda buffer which match hdmarker.
+ "Change all lines in the agenda buffer which match HDMARKER.
The new content of the line will be NEWHEAD (as modified by
`org-format-agenda-item'). HDMARKER is checked with
`equal' against all `org-hd-marker' text properties in the file.
(defun org-agenda-diary-entry ()
"Make a diary entry, like the `i' command from the calendar.
-All the standard commands work: block, weekly etc"
+All the standard commands work: block, weekly etc."
(interactive)
(org-agenda-check-type t 'agenda 'timeline)
(require 'diary-lib)
"Scan headline tags with inheritance and produce output ACTION.
ACTION can be `sparse-tree' or `agenda'. MATCHER is a Lisp form to be
evaluated, testing if a given set of tags qualifies a headline for
-inclusion. When TODO-ONLY is non-nil, only lines with a TDOD keyword
-d are included in the output."
+inclusion. When TODO-ONLY is non-nil, only lines with a TODO keyword
+are included in the output."
(let* ((re (concat "[\n\r]" outline-regexp " *\\(\\<\\("
(mapconcat 'regexp-quote
(nreverse (cdr (reverse org-todo-keywords)))
;; add the nex tags
(when tags
(setq tags (mapcar 'downcase (org-split-string tags ":"))
- tags-alist
+ tags-alist
(cons (cons level tags) tags-alist)))
;; compile tags for current headline
(setq tags-list
(if (eq action 'sparse-tree)
(progn
(org-show-hierarchy-above))
- (setq txt (org-format-agenda-item
+ (setq txt (org-format-agenda-item
""
(concat
(if org-tags-match-list-sublevels
(goto-char lspos)
(setq marker (org-agenda-new-marker))
(add-text-properties
- 0 (length txt)
+ 0 (length txt)
(append (list 'org-marker marker 'org-hd-marker marker
'category category)
props)
;;;###autoload
(defun org-tags-view (&optional todo-only match keep-modes)
- "Show all headlines for all `org-agenda-files' matching a TAGS criterions.
+ "Show all headlines for all `org-agenda-files' matching a TAGS criterion.
The prefix arg TODO-ONLY limits the search to TODO entries."
(interactive "P")
(org-agenda-maybe-reset-markers 'force)
(org-agenda-mode) (setq buffer-read-only nil)
(set (make-local-variable 'org-agenda-type) 'tags)
(set (make-local-variable 'org-agenda-redo-command)
- (list 'org-tags-view (list 'quote todo-only)
+ (list 'org-tags-view (list 'quote todo-only)
(list 'if 'current-prefix-arg nil match) t))
(setq files (org-agenda-files)
rtnall nil)
(if (string-match "^\\(.*[-+:&|]\\)\\([^-+:&|]*\\)$" string)
(setq s1 (match-string 1 string)
s2 (match-string 2 string))
- (setq s1 "" s2 string))
+ (setq s1 "" s2 string))
(cond
((eq flag nil)
;; try completion
(setq rtn (try-completion s2 ctable))
- (if (stringp rtn)
+ (if (stringp rtn)
(concat s1 s2 (substring rtn (length s2))
(if (and org-add-colon-after-tag-completion
(assoc rtn ctable))
(setq path (concat "*" path))))
(throw 'match t))
(save-excursion
- (when (re-search-forward
+ (when (re-search-forward
org-link-regexp
(save-excursion
(condition-case nil
;; Remove any trailing spaces in path
(if (string-match " +\\'" path)
(setq path (replace-match "" t t path)))
-
+
(cond
-
+
((string= type "tags")
(org-tags-view in-emacs path))
((string= type "camel")
(cond ((equal in-emacs '(4)) 'occur)
((equal in-emacs '(16)) 'org-occur)
(t nil))))
-
+
((string= type "file")
(if (string-match "::?\\([0-9]+\\)\\'" path) ;; second : optional
(setq line (string-to-number (match-string 1 path))
(setq search (match-string 1 path)
path (substring path 0 (match-beginning 0)))))
(org-open-file path in-emacs line search))
-
+
((string= type "news")
(org-follow-gnus-link path))
-
+
((string= type "bbdb")
(org-follow-bbdb-link path))
-
+
((string= type "gnus")
(let (group article)
(if (not (string-match "\\`\\([^#]+\\)\\(#\\(.*\\)\\)?" path))
(setq group (match-string 1 path)
article (match-string 3 path))
(org-follow-gnus-link group article)))
-
+
((string= type "vm")
(let (folder article)
(if (not (string-match "\\`\\([^#]+\\)\\(#\\(.*\\)\\)?" path))
article (match-string 3 path))
;; in-emacs is the prefix arg, will be interpreted as read-only
(org-follow-vm-link folder article in-emacs)))
-
+
((string= type "wl")
(let (folder article)
(if (not (string-match "\\`\\([^#]+\\)\\(#\\(.*\\)\\)?" path))
(setq folder (match-string 1 path)
article (match-string 3 path))
(org-follow-wl-link folder article)))
-
+
((string= type "rmail")
(let (folder article)
(if (not (string-match "\\`\\([^#]+\\)\\(#\\(.*\\)\\)?" path))
(setq folder (match-string 1 path)
article (match-string 3 path))
(org-follow-rmail-link folder article)))
-
+
((string= type "shell")
(let ((cmd path))
(while (string-match "@{" cmd)
(yes-or-no-p (format "Execute \"%s\" in the shell? " cmd)))
(shell-command cmd)
(error "Abort"))))
-
+
(t
(browse-url-at-point))))))
When S is a CamelCaseWord, search for a target, or for a sentence containing
the words. If S is surrounded by forward slashes, it is interpreted as a
regular expression. In org-mode files, this will create an `org-occur'
-sparse tree. In ordinary files, `occur' will be used to list matched.
+sparse tree. In ordinary files, `occur' will be used to list matches.
If the current buffer is in `dired-mode', grep will be used to search
in all files."
(let ((case-fold-search t)
(setq pre "^\\*+[ \t]*\\(\\sw+\\)?[ \t]*"
post "[ \t]*$"
s (substring s 1)))
- (remove-text-properties
+ (remove-text-properties
0 (length s)
'(face nil mouse-face nil keymap nil fontified nil) s)
;; Make a series of regular expressions to find a match
(select-window cwin))))
(defun org-camel-to-words (s)
- "Split \"CamelCaseWords\" to (\"Camel \" \"Case\" \"Words\")."
+ "Split \"CamelCaseWords\" to (\"Camel\" \"Case\" \"Words\")."
(let ((case-fold-search nil)
words)
(while (string-match "[a-z][A-Z]" s)
With optional argument IN-EMACS, Emacs will visit the file.
Optional LINE specifies a line to go to, optional SEARCH a string to
search for. If LINE or SEARCH is given, the file will always be
-openen in emacs.
+opened in Emacs.
If the file does not exist, an error is thrown."
(setq in-emacs (or in-emacs line search))
- (let* ((file (if (equal path "")
+ (let* ((file (if (equal path "")
(buffer-file-name)
(convert-standard-filename (org-expand-file-name path))))
(dfile (downcase file))
(org-make-org-heading-camel
(cond
((org-on-heading-p) nil)
- ((org-region-active-p)
+ ((org-region-active-p)
(buffer-substring (region-beginning) (region-end)))
(t (buffer-substring (point-at-bol) (point-at-eol))))
)))))
;; Add a context string
(when (org-xor org-context-in-file-links arg)
(setq cpltxt
- (concat cpltxt "::"
+ (concat cpltxt "::"
(org-make-org-heading-camel
- (if (org-region-active-p)
+ (if (org-region-active-p)
(buffer-substring (region-beginning) (region-end))
(buffer-substring (point-at-bol) (point-at-eol)))))))
(setq link (org-make-link cpltxt)))
Then the command offers the headings tree of the selected file in order to
file the text at a specific location.
You can either immediately press RET to get the note appended to the
-file. Or you can use vertical cursor motion and visibility cycling (TAB) to
+file, or you can use vertical cursor motion and visibility cycling (TAB) to
find a better place. Then press RET or <left> or <right> in insert the note.
Key Cursor position Note gets inserted
The region goes from BEG0 to END0, but these borders will be moved
slightly, to make sure a beginning of line in the first line is included.
When NSPACE is non-nil, it indicates the minimum number of spaces that
-separate columns (default: just one space)"
+separate columns (default: just one space)."
(let* ((beg (min beg0 end0))
(end (max beg0 end0))
(tabsep t)
(org-table-modify-formulas 'swap col (if left (1- col) (1+ col)))))
(defun org-table-move-row-down ()
- "move table row down."
+ "Move table row down."
(interactive)
(org-table-move-row nil))
(defun org-table-move-row-up ()
- "move table row up."
+ "Move table row up."
(interactive)
(org-table-move-row 'up))
(defun org-table-copy-region (beg end &optional cut)
"Copy rectangular region in table to clipboard.
A special clipboard is used which can only be accessed
-with `org-table-paste-rectangle'"
+with `org-table-paste-rectangle'."
(interactive "rP")
(let* (l01 c01 l02 c02 l1 c1 l2 c2 ic1 ic2
region cols
the text in the column is wrapped to minimum width for the given number of
lines. Generally, this makes the table more compact. A prefix ARG may be
used to change the number of desired lines. For example, `C-2 \\[org-table-wrap]'
-formats the selected text to two lines. If the region was longer than 2
+formats the selected text to two lines. If the region was longer than two
lines, the remaining lines remain empty. A negative prefix argument reduces
the current number of lines by that amount. The wrapped text is pasted back
into the table. If you formatted it to more lines than it was before, fields
"Toggle the visibility of table vertical lines.
The effect is immediate and on all tables in the file.
With prefix ARG, make lines invisible when ARG is positive, make lines
-visible when ARG is not positive"
+visible when ARG is not positive."
(interactive "P")
(let ((action (cond
((and arg (> (prefix-numeric-value arg) 0)) 'on)
(t n))))
(defun org-table-get-vertical-vector (desc &optional tbeg col)
- "Get a calc vector from a column, accorting to desctiptor DESC.
+ "Get a calc vector from a column, accorting to descriptor DESC.
Optional arguments TBEG and COL can give the beginning of the table and
the current column, to avoid unnecessary parsing."
(save-excursion
(defun org-table-modify-formulas (action &rest columns)
"Modify the formulas stored below the current table.
ACTION can be `remove', `insert', `swap'. For `swap', two column numbers are
-expected, for the other action only a single column number is needed."
+expected, for the other actions only a single column number is needed."
(let ((list (org-table-get-stored-formulas))
(nmax (length (org-split-string
(buffer-substring (point-at-bol) (point-at-eol))
(setcdr elt s))))
(defun org-table-get-specials ()
- "Get the column nmaes and local parameters for this table."
+ "Get the column names and local parameters for this table."
(save-excursion
(let ((beg (org-table-begin)) (end (org-table-end))
names name fields fields1 field cnt c v line col)
(org-table-eval-formula (if named '(4) nil) eq))))))
(defvar org-recalc-commands nil
- "List of commands triggering the reccalculation of a line.
+ "List of commands triggering the recalculation of a line.
Will be filled automatically during use.")
(defvar org-recalc-marks
(defun org-table-rotate-recalc-marks (&optional newchar)
"Rotate the recalculation mark in the first column.
If in any row, the first field is not consistent with a mark,
-insert a new column for the makers.
+insert a new column for the markers.
When there is an active region, change all the lines in the region,
after prompting for the marking character.
-After each change, a message will be displayed indication the meaning
+After each change, a message will be displayed indicating the meaning
of the new mark."
(interactive)
(unless (org-at-table-p) (error "Not at a table"))
suppress-store)
"Replace the table field value at the cursor by the result of a calculation.
-This function makes use of Dave Gillespie's calc package, in my view the
-most exciting program ever written for GNU Emacs. So you need to have calc
+This function makes use of Dave Gillespie's Calc package, in my view the
+most exciting program ever written for GNU Emacs. So you need to have Calc
installed in order to use this function.
In a table, this command replaces the value in the current field with the
-result of a formula. It also installes the formula as the \"current\" column
+result of a formula. It also installs the formula as the \"current\" column
formula, by storing it in a special line below the table. When called
with a `C-u' prefix, the current field must ba a named field, and the
formula is installed as valid in only this specific field.
These stored formulas are adapted correctly when moving, inserting, or
deleting columns with the corresponding commands.
-The formula can be any algebraic expression understood by the calc package.
+The formula can be any algebraic expression understood by the Calc package.
For details, see the Org-mode manual.
This function can also be called from Lisp programs and offers
-additional Arguments: EQUATION can be the formula to apply. If this
+additional arguments: EQUATION can be the formula to apply. If this
argument is given, the user will not be prompted. SUPPRESS-ALIGN is
used to speed-up recursive calls by by-passing unnecessary aligns.
SUPPRESS-CONST suppresses the interpretation of constants in the
-formula, assuming that this has been done already outside the fuction.
+formula, assuming that this has been done already outside the function.
SUPPRESS-STORE means the formula should not be stored, either because
it is already stored, or because it is a modified equation that should
not overwrite the stored one."
(defun orgtbl-make-binding (fun n &rest keys)
"Create a function for binding in the table minor mode.
-FUN is the command to call inside a table. N is used to create a unique
-command name. KEYS are keys that should be checked in for a command
+FUN is the command to call inside a table. N is used to create a unique
+command name. KEYS are keys that should be checked in for a command
to execute outside of tables."
(eval
(list 'defun
start-is-num (match-beginning 4)
starter (if (match-beginning 2) (match-string 2 line))
line (substring line (match-beginning 5)))
- (unless (string-match "[^ \t]" line)
+ (unless (string-match "[^ \t]" line)
;; empty line. Pretend indentation is large.
(setq ind (1+ (or (car local-list-indent) 1))))
(while (and in-local-list
(delete arg buffer-invisibility-spec)))))
(defun org-in-invisibility-spec-p (arg)
- "Is ARG a member of `buffer-invisibility-spec'?."
+ "Is ARG a member of `buffer-invisibility-spec'?"
(if (consp buffer-invisibility-spec)
(member arg buffer-invisibility-spec)
nil))
;; arch-tag: e77da1a7-acc7-4336-b19e-efa25af3f9fd
;;; org.el ends here
-
+