* Fix typos in comments and docstrings throughout Org-mode.
* org.el (org-get-outline-path): Fix bug if level is not given.
* org-agenda.el (org-finalize-agenda): Fix typo with variable
name.
+2008-12-17 Carsten Dominik <dominik@science.uva.nl>
+
+ * org.texi: Version number pushed to 6.15d.
+
2008-12-16 Carsten Dominik <dominik@science.uva.nl>
* org.texi: (Tables in LaTeX export): New section.
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
(defcustom org-agenda-exporter-settings nil
"Alist of variable/value pairs that should be active during agenda export.
-This is a good place to set uptions for ps-print and for htmlize."
+This is a good place to set options for ps-print and for htmlize."
:group 'org-agenda-export
:type '(repeat
(list
(const :format "" quote)
(list
(choice
- :tag "Skiping range"
+ :tag "Skipping range"
(const :tag "Skip entry" org-agenda-skip-entry-if)
(const :tag "Skip subtree" org-agenda-skip-subtree-if))
(repeat :inline t :tag "Conditions for skipping"
with the command `org-store-agenda-views'.
If a file name ends in \".html\", an HTML version of the buffer
is written out. If it ends in \".ps\", a postscript version is
- produced. Otherwide, only the plain text is written to the file.
+ produced. Otherwise, only the plain text is written to the file.
You can also define a set of commands, to create a composite agenda buffer.
In this case, an entry looks like this:
(defcustom org-agenda-query-register ?o
"The register holding the current query string.
-The prupose of this is that if you construct a query string interactively,
+The purpose of this is that if you construct a query string interactively,
you can then use it to define a custom command."
:group 'org-agenda-custom-commands
:type 'character)
(defcustom org-agenda-skip-comment-trees t
"Non-nil means, skip trees that start with the COMMENT keyword.
-When nil, these trees are also scand by agenda commands."
+When nil, these trees are also scanned by agenda commands."
:group 'org-agenda-skip
:type 'boolean)
:type 'boolean)
(defcustom org-agenda-skip-deadline-if-done nil
- "Non-nil means don't show deadines when the corresponding item is done.
+ "Non-nil means don't show deadlines when the corresponding item is done.
When nil, the deadline is still shown and should give you a happy feeling.
This is relevant for the daily/weekly agenda. And it applied only to the
-actualy date of the deadline. Warnings about approching and past-due
+actually date of the deadline. Warnings about approaching and past-due
deadlines are always turned off when the item is DONE."
:group 'org-agenda-skip
:type 'boolean)
:type 'boolean)
(defcustom org-agenda-repeating-timestamp-show-all t
- "Non-nil means, show all occurences of a repeating stamp in the agenda.
-When nil, only one occurence is shown, either today or the
+ "Non-nil means, show all occurrences of a repeating stamp in the agenda.
+When nil, only one occurrence is shown, either today or the
nearest into the future."
:group 'org-agenda-daily/weekly
:type 'boolean)
(defvar org-agenda-undo-has-started-in nil
"Buffers that have already seen `undo-start' in the current undo sequence.")
(defvar org-agenda-pending-undo-list nil
- "In a series of undo commands, this is the list of remaning undo items.")
+ "In a series of undo commands, this is the list of remaining undo items.")
(defun org-agenda-undo ()
(mapcar (lambda (x) (setcdr x (sort (copy-sequence (cdr x)) '<)) x)
tbl)))
-(defvar org-agenda-marker-table nil) ; dyamically scoped parameter
+(defvar org-agenda-marker-table nil) ; dynamically scoped parameter
(defun org-check-agenda-marker-table ()
"Check of the current entry is on the marker list."
(let ((file (buffer-file-name (or (buffer-base-buffer) (current-buffer))))
;;; Agenda prepare and finalize
-(defvar org-agenda-multi nil) ; dynammically scoped
+(defvar org-agenda-multi nil) ; dynamically scoped
(defvar org-agenda-buffer-name "*Org Agenda*")
(defvar org-pre-agenda-window-conf nil)
(defvar org-agenda-columns-active nil)
(org-agenda-align-tags)
(unless org-agenda-with-colors
(remove-text-properties (point-min) (point-max) '(face nil))))
- (if (and (boundp 'org-overriding-columns-format)
- org-overriding-columns-format)
- (org-set-local 'org-overriding-columns-format
- org-overriding-columns-format))
+ (if (and (boundp 'org-agenda-overriding-columns-format)
+ org-agenda-overriding-columns-format)
+ (org-set-local 'org-agenda-overriding-columns-format
+ org-agenda-overriding-columns-format))
(if (and (boundp 'org-agenda-view-columns-initially)
org-agenda-view-columns-initially)
(org-agenda-columns))
(defvar org-search-syntax-table nil
"Special syntax table for org-mode search.
In this table, we have single quotes not as word constituents, to
-that when \"+Ameli\" is searchd as a work, it will also match \"Ameli's\"")
+that when \"+Ameli\" is searched as a work, it will also match \"Ameli's\"")
(defun org-search-syntax-table ()
(unless org-search-syntax-table
(org-get-agenda-file-buffer file)
(error "No such file %s" file)))
(if (not buffer)
- ;; If file does not exist, merror message to agenda
+ ;; If file does not exist, error message to agenda
(setq rtn (list
(format "ORG-AGENDA-ERROR: No such org-file %s" file))
rtnall (append rtnall rtn))
'(if (boundp 'diary-modify-entry-list-string-function)
;; We can rely on the hook, nothing to do
nil
- ;; Hook not avaiable, must use advice to make this work
+ ;; Hook not available, must use advice to make this work
(defadvice add-to-diary-list (before org-mark-diary-entry activate)
"Make the position visible."
(if (and org-disable-agenda-to-diary ;; called from org-agenda
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.
-If FIXFACE is non-nil, the face of each item is modified acording to
+If FIXFACE is non-nil, the face of each item is modified according to
the new TODO state.
If JUST-THIS is non-nil, change just the current line, not all.
-If FORCE-TAGS is non nil, the car of it ar the new tags."
+If FORCE-TAGS is non nil, the car of it returns the new tags."
(let* ((inhibit-read-only t)
(line (org-current-line))
props m pl undone-face done-face finish new dotime cat tags)
(defun org-agenda-to-appt (&optional refresh filter)
"Activate appointments found in `org-agenda-files'.
With a \\[universal-argument] prefix, refresh the list of
-appointements.
+appointments.
If FILTER is t, interactively prompt the user for a regular
expression, and filter out entries that don't match it.
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;
;;; Commentary:
-;; This file contains the face definitons for Org.
+;; This file contains the face definitions for Org.
;;; Code:
When called with prefix argument FIND-DONE, find whole trees without any
open TODO items and archive them (after getting confirmation from the user).
-If the cursor is not at a headline when this comand is called, try all level
+If the cursor is not at a headline when this command is called, try all level
1 trees. If the cursor is on a headline, only try the direct children of
this heading."
(interactive "P")
;; Author: John Wiegley <johnw@newartisans.com>
;; Keywords: org data task
-;; Version: 6.15a
+;; Version: 6.15d
;; This file is part of GNU Emacs.
;;
If this is a relative path, it will be interpreted relative to the directory
where the Org file lives."
:group 'org-attach
- :type 'direcory)
+ :type 'directory)
(defcustom org-attach-auto-tag "ATTACH"
"Tag that will be triggered automatically when an entry has an attachment."
;; Thomas Baumann <thomas dot baumann at ch dot tum dot de>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; Author: Bastien Guerry <bzg at altern dot org>
;; Carsten Dominik <carsten dot dominik at gmail dot com>
;; Keywords: org, wp, remember
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; This file implements links to database entries in BibTeX files.
;; Instead of defining a special link prefix, it uses the normal file
;; links combined with a custom search mechanism to find entries
-;; by reference key. And it constucts a nice description tag for
+;; by reference key. And it constructs a nice description tag for
;; the link that contains the author name, the year and a short title.
;;
;; It also stores detailed information about the entry so that
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
(setq selected-task (copy-marker selected-task))
(error "Abort")))
(when interrupting
- ;; We are interrupting the clocking of a differnt task.
+ ;; We are interrupting the clocking of a different task.
;; Save a marker to this task, so that we can go back.
(move-marker org-clock-interrupted-task
(marker-position org-clock-marker)
dt (- te ts)
t1 (if (> dt 0) (+ t1 (floor (/ dt 60))) t1)))
((match-end 4)
- ;; A naket time
+ ;; A naked time
(setq t1 (+ t1 (string-to-number (match-string 5))
(* 60 (string-to-number (match-string 4))))))
(t ;; A headline
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;
;;; Commentary:
-;; This file contains the face definitons for Org.
+;; This file contains the column view for Org.
;;; Code:
org-columns-ellipses))))
(defvar org-columns-full-header-line-format nil
- "Fthe full header line format, will be shifted by horizontal scrolling." )
+ "The full header line format, will be shifted by horizontal scrolling." )
(defvar org-previous-header-line-format nil
"The header line format before column view was turned on.")
(defvar org-columns-inhibit-recalculation nil
(defvar org-agenda-columns-remove-prefix-from-item)
(defun org-agenda-columns-cleanup-item (item pl cphr fmt)
- "Cleanup the tiem property for agenda column view.
+ "Cleanup the time property for agenda column view.
See also the variable `org-agenda-columns-remove-prefix-from-item'."
(let* ((org-complex-heading-regexp cphr)
(prefix (substring item 0 pl))
(org-columns-redo)))
(defun org-columns-narrow (arg)
- "Make the column nrrower by ARG characters."
+ "Make the column narrower by ARG characters."
(interactive "p")
(org-columns-widen (- arg)))
(defun org-listtable-to-string (tbl)
"Convert a listtable TBL to a string that contains the Org-mode table.
-The table still need to be alligned. The resulting string has no leading
+The table still need to be aligned. The resulting string has no leading
and tailing newline characters."
(mapconcat
(lambda (x)
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
(defcustom org-export-exclude-tags '("noexport")
"Tags that exclude a tree from export.
All trees carrying any of these tags will be excluded from export.
-This is without contition, so even subtrees inside that carry one of the
+This is without condition, so even subtrees inside that carry one of the
`org-export-select-tags' will be removed."
:group 'org-export-general
:type '(repeat (string :tag "Tag")))
:type 'boolean)
(defcustom org-export-creator-info t
- "Non-nil means, the postamle should contain a creator sentence.
+ "Non-nil means, the postamble should contain a creator sentence.
This sentence is \"HTML generated by org-mode XX in emacs XXX\"."
:group 'org-export-general
:type 'boolean)
(defcustom org-export-html-style-include-default t
"Non-nil means, include the default style in exported HTML files.
-The actualy style is defined in `org-export-html-style-default' and should
+The actual style is defined in `org-export-html-style-default' and should
not be modified. Use the variables `org-export-html-style' to add
your own style information."
:group 'org-export-html
(defcustom org-icalendar-store-UID nil
"Non-nil means, store any created UIDs in properties.
-The iCalendar standard requires that all entries have a unique identifyer.
+The iCalendar standard requires that all entries have a unique identifier.
Org will create these identifiers as needed. When this variable is non-nil,
the created UIDs will be stored in the ID property of the entry. Then the
next time this entry is exported, it will be exported with the same UID,
-superceeding the previous form of it. This is essential for
+superceding the previous form of it. This is essential for
synchronization services.
This variable is not turned on by default because we want to avoid creating
a property drawer in every entry if people are only playing with this feature,
(defvar org-current-export-dir nil) ; dynamically scoped parameter
(defconst org-export-plist-vars
- '((:link-up nil org-export-html-link-up)
- (:link-home nil org-export-html-link-home)
- (:language nil org-export-default-language)
- (:customtime nil org-display-custom-times)
- (:headline-levels "H" org-export-headline-levels)
- (:section-numbers "num" org-export-with-section-numbers)
- (:section-number-format nil org-export-section-number-format)
- (:table-of-contents "toc" org-export-with-toc)
- (:preserve-breaks "\\n" org-export-preserve-breaks)
- (:archived-trees nil org-export-with-archived-trees)
- (:emphasize "*" org-export-with-emphasize)
- (:sub-superscript "^" org-export-with-sub-superscripts)
- (:special-strings "-" org-export-with-special-strings)
- (:footnotes "f" org-export-with-footnotes)
- (:drawers "d" org-export-with-drawers)
- (:tags "tags" org-export-with-tags)
- (:todo-keywords "todo" org-export-with-todo-keywords)
- (:priority "pri" org-export-with-priority)
- (:TeX-macros "TeX" org-export-with-TeX-macros)
- (:LaTeX-fragments "LaTeX" org-export-with-LaTeX-fragments)
- (:skip-before-1st-heading "skip" org-export-skip-text-before-1st-heading)
- (:fixed-width ":" org-export-with-fixed-width)
- (:timestamps "<" org-export-with-timestamps)
- (:author-info "author" org-export-author-info)
- (:creator-info "creator" org-export-creator-info)
- (:time-stamp-file "timestamp" org-export-time-stamp-file)
- (:tables "|" org-export-with-tables)
- (:table-auto-headline nil org-export-highlight-first-table-line)
- (:style-include-default nil org-export-html-style-include-default)
- (:style nil org-export-html-style)
- (:style-extra nil org-export-html-style-extra)
- (:agenda-style nil org-agenda-export-html-style)
- (:convert-org-links nil org-export-html-link-org-files-as-html)
- (:inline-images nil org-export-html-inline-images)
- (:html-extension nil org-export-html-extension)
- (:html-table-tag nil org-export-html-table-tag)
- (:expand-quoted-html "@" org-export-html-expand)
- (:timestamp nil org-export-html-with-timestamp)
- (:publishing-directory nil org-export-publishing-directory)
- (:preamble nil org-export-html-preamble)
- (:postamble nil org-export-html-postamble)
- (:auto-preamble nil org-export-html-auto-preamble)
- (:auto-postamble nil org-export-html-auto-postamble)
- (:author nil user-full-name)
- (:email nil user-mail-address)
- (:select-tags nil org-export-select-tags)
- (:exclude-tags nil org-export-exclude-tags))
+ '((:link-up nil org-export-html-link-up)
+ (:link-home nil org-export-html-link-home)
+ (:language nil org-export-default-language)
+ (:customtime nil org-display-custom-times)
+ (:headline-levels "H" org-export-headline-levels)
+ (:section-numbers "num" org-export-with-section-numbers)
+ (:section-number-format nil org-export-section-number-format)
+ (:table-of-contents "toc" org-export-with-toc)
+ (:preserve-breaks "\\n" org-export-preserve-breaks)
+ (:archived-trees nil org-export-with-archived-trees)
+ (:emphasize "*" org-export-with-emphasize)
+ (:sub-superscript "^" org-export-with-sub-superscripts)
+ (:special-strings "-" org-export-with-special-strings)
+ (:footnotes "f" org-export-with-footnotes)
+ (:drawers "d" org-export-with-drawers)
+ (:tags "tags" org-export-with-tags)
+ (:todo-keywords "todo" org-export-with-todo-keywords)
+ (:priority "pri" org-export-with-priority)
+ (:TeX-macros "TeX" org-export-with-TeX-macros)
+ (:LaTeX-fragments "LaTeX" org-export-with-LaTeX-fragments)
+ (:skip-before-1st-heading "skip" org-export-skip-text-before-1st-heading)
+ (:fixed-width ":" org-export-with-fixed-width)
+ (:timestamps "<" org-export-with-timestamps)
+ (:author-info "author" org-export-author-info)
+ (:creator-info "creator" org-export-creator-info)
+ (:time-stamp-file "timestamp" org-export-time-stamp-file)
+ (:tables "|" org-export-with-tables)
+ (:table-auto-headline nil org-export-highlight-first-table-line)
+ (:style-include-default nil org-export-html-style-include-default)
+ (:style nil org-export-html-style)
+ (:style-extra nil org-export-html-style-extra)
+ (:agenda-style nil org-agenda-export-html-style)
+ (:convert-org-links nil org-export-html-link-org-files-as-html)
+ (:inline-images nil org-export-html-inline-images)
+ (:html-extension nil org-export-html-extension)
+ (:html-table-tag nil org-export-html-table-tag)
+ (:expand-quoted-html "@" org-export-html-expand)
+ (:timestamp nil org-export-html-with-timestamp)
+ (:publishing-directory nil org-export-publishing-directory)
+ (:preamble nil org-export-html-preamble)
+ (:postamble nil org-export-html-postamble)
+ (:auto-preamble nil org-export-html-auto-preamble)
+ (:auto-postamble nil org-export-html-auto-postamble)
+ (:author nil user-full-name)
+ (:email nil user-mail-address)
+ (:select-tags nil org-export-select-tags)
+ (:exclude-tags nil org-export-exclude-tags))
"List of properties that represent export/publishing variables.
Each element is a list of 3 items:
1. The property that is used internally, and also for org-publish-project-alist
can then add a function to `org-export-options-filters' to process these
options.
Each element in this list must be a list, with the in-buffer keyword as car,
-and a property (a symbol) as the next element. All occurences of the
+and a property (a symbol) as the next element. All occurrences of the
keyword will be found, the values concatenated with a space character
in between, and the result stored in the export options property list.")
p))))
(defun org-export-add-options-to-plist (p options)
- "Parse an OPTONS line and set values in the property list P."
+ "Parse an OPTIONS line and set values in the property list P."
(let (o)
(when options
(let ((op org-export-plist-vars) a)
(run-hooks 'org-export-preprocess-hook)
;; Remove license-to-kill stuff
- ;; The caller markes some stuff fo killing, stuff that has been
+ ;; The caller marks some stuff for killing, stuff that has been
;; used to create the page title, for example.
(org-export-kill-licensed-text)
;; Handle source code snippets
(org-export-replace-src-segments)
-
+
;; Find all headings and compute the targets for them
(setq target-alist (org-export-define-heading-targets target-alist))
;; Blockquotes and verse
(org-export-mark-blockquote-and-verse)
- ;; Attach captions to the correct opject
+ ;; Attach captions to the correct object
(setq target-alist (org-export-attach-captions-and-attributes
backend target-alist))
(defun org-export-remove-comment-blocks-and-subtrees ()
"Remove the comment environment, and also commented subtrees."
(let ((re-commented (concat "^\\*+[ \t]+" org-comment-string "\\>"))
- (case-fold-search nil))
+ (case-fold-search nil))
;; Remove comment environment
(goto-char (point-min))
(while (re-search-forward
1 number
A A,B,....
a a,b,....
- I uppper case roman numeral
+ I upper case roman numeral
i lower case roman numeral"
(cond
((equal type "1") (number-to-string n))
(umax-toc nil)
(case-fold-search nil)
(bfname (buffer-file-name (or (buffer-base-buffer) (current-buffer))))
- (filename (concat (file-name-as-directory
+ (filename (concat (file-name-as-directory
(org-export-directory :ascii opt-plist))
(file-name-sans-extension
(or (and subtree-p
;;; HTML export
-(defvar org-archive-location) ;; gets loades with the org-archive require.
+(defvar org-archive-location) ;; gets loaded with the org-archive require.
(defun org-get-current-options ()
"Return a string with current options as keyword options.
Does include HTML export options as well as TODO and CATEGORY stuff."
;;;###autoload
(defun org-export-as-html-batch ()
"Call `org-export-as-html', may be used in batch processing as
-emacs --batch
- --load=$HOME/lib/emacs/org.el
- --eval \"(setq org-export-headline-levels 2)\"
- --visit=MyFile --funcall org-export-as-html-batch"
+emacs --batch
+ --load=$HOME/lib/emacs/org.el
+ --eval \"(setq org-export-headline-levels 2)\"
+ --visit=MyFile --funcall org-export-as-html-batch"
(org-export-as-html org-export-headline-levels 'hidden))
;;;###autoload
(defun org-export-as-html-to-buffer (arg)
- "Call `org-exort-as-html` with output to a temporary buffer.
+ "Call `org-export-as-html` with output to a temporary buffer.
No file is created. The prefix ARG is passed through to `org-export-as-html'."
(interactive "P")
(org-export-as-html arg nil nil "*Org HTML Export*")
(org-current-export-dir
(or pub-dir (org-export-directory :html opt-plist)))
(org-current-export-file buffer-file-name)
- (level 0) (line "") (origline "") txt todo
- (umax nil)
- (umax-toc nil)
- (filename (if to-buffer nil
+ (level 0) (line "") (origline "") txt todo
+ (umax nil)
+ (umax-toc nil)
+ (filename (if to-buffer nil
(expand-file-name
(concat
(file-name-sans-extension
((eq to-buffer 'string) (get-buffer-create "*Org HTML Export*"))
(t (get-buffer-create to-buffer)))
(find-file-noselect filename)))
- (org-levels-open (make-vector org-level-max nil))
+ (org-levels-open (make-vector org-level-max nil))
(date (plist-get opt-plist :date))
- (author (plist-get opt-plist :author))
+ (author (plist-get opt-plist :author))
(title (or (and subtree-p (org-export-get-title-from-subtree))
(plist-get opt-plist :title)
(and (not
(local-list-indent nil)
(llt org-plain-list-ordered-item-terminator)
(email (plist-get opt-plist :email))
- (language (plist-get opt-plist :language))
+ (language (plist-get opt-plist :language))
(lang-words nil)
(head-count 0) cnt
(start 0)
(fboundp 'coding-system-get)
(coding-system-get coding-system-for-write
'mime-charset)))
- (region
- (buffer-substring
- (if region-p (region-beginning) (point-min))
- (if region-p (region-end) (point-max))))
- (lines
- (org-split-string
+ (region
+ (buffer-substring
+ (if region-p (region-beginning) (point-min))
+ (if region-p (region-end) (point-max))))
+ (lines
+ (org-split-string
(org-export-preprocess-string
region
:emph-multiline t
;; Get the language-dependent settings
(setq lang-words (or (assoc language org-export-language-setup)
- (assoc "en" org-export-language-setup)))
+ (assoc "en" org-export-language-setup)))
;; Switch to the output buffer
(set-buffer buffer)
(plist-get opt-plist (car x))))
org-export-plist-vars)
(setq umax (if arg (prefix-numeric-value arg)
- org-export-headline-levels))
+ org-export-headline-levels))
(setq umax-toc (if (integerp org-export-with-toc)
(min org-export-with-toc umax)
umax))
(catch 'nextline
;; end of quote section?
- (when (and inquote (string-match "^\\*+ " line))
+ (when (and inquote (string-match "^\\*+ " line))
(insert "</pre>\n")
(setq inquote nil))
;; inside a quote section?
(if (and (string-match org-todo-line-regexp line)
(match-beginning 2))
- (setq line
- (concat (substring line 0 (match-beginning 2))
- "<span class=\""
- (if (member (match-string 2 line)
- org-done-keywords)
- "done" "todo")
- "\">" (match-string 2 line)
- "</span>" (substring line (match-end 2)))))
+ (setq line
+ (concat (substring line 0 (match-beginning 2))
+ "<span class=\""
+ (if (member (match-string 2 line)
+ org-done-keywords)
+ "done" "todo")
+ "\">" (match-string 2 line)
+ "</span>" (substring line (match-end 2)))))
;; Does this contain a reference to a footnote?
(when org-export-with-footnotes
(delq nil (mapcar
(lambda (x) (string-match "^[ \t]*|-" x))
(cdr lines)))))
-
+
(nlines 0) fnum i
tbopen line fields html gr colgropen)
(if splice (setq head nil))
(unless splice (push "</table>\n" html))
(setq html (nreverse html))
(unless splice
- ;; Put in col tags with the alignment (unfortuntely often ignored...)
+ ;; Put in col tags with the alignment (unfortunately often ignored...)
(push (mapconcat
(lambda (x)
(setq gr (pop org-table-colgroup-info))
s)
(defun org-export-cleanup-toc-line (s)
- "Remove tags and time staps from lines going into the toc."
+ "Remove tags and timestamps from lines going into the toc."
(when (memq org-export-with-tags '(not-in-toc nil))
(if (string-match (org-re " +:[[:alnum:]_@:]+: *$") s)
(setq s (replace-match "" t t s))))
(defvar org-after-save-iCalendar-file-hook nil
"Hook run after an iCalendar file has been saved.
The iCalendar buffer is still current when this hook is run.
-A good way to use this is to tell a desktop calenndar application to re-read
+A good way to use this is to tell a desktop calendar application to re-read
the iCalendar file.")
(defvar org-agenda-default-appointment-duration) ; defined in org-agenda.el
;; Kick off the output
(org-export-as-xoxo-insert-into out "<ol class='xoxo'>\n")
(while (re-search-forward "^\\(\\*+\\)[ \t]+\\(.+\\)" (point-max) 't)
- (let* ((hd (match-string-no-properties 1))
- (level (length hd))
- (text (concat
- (match-string-no-properties 2)
- (save-excursion
- (goto-char (match-end 0))
- (let ((str ""))
- (catch 'loop
- (while 't
- (forward-line)
- (if (looking-at "^[ \t]\\(.*\\)")
- (setq str (concat str (match-string-no-properties 1)))
- (throw 'loop str)))))))))
-
- ;; Handle level rendering
- (cond
- ((> level last-level)
-
(org-export-as-xoxo-insert-into out "\n<ol>\n"))
-
- ((< level last-level)
- (dotimes (- (- last-level level) 1)
- (if hanging-li
- (org-export-as-xoxo-insert-into out "</li>\n"))
- (org-export-as-xoxo-insert-into out "</ol>\n"))
- (when hanging-li
- (org-export-as-xoxo-insert-into out "</li>\n")
- (setq hanging-li nil)))
-
- ((equal level last-level)
- (if hanging-li
- (org-export-as-xoxo-insert-into out "</li>\n")))
- )
-
- (setq last-level level)
-
- ;; And output the new li
- (setq hanging-li 't)
- (if (equal ?+ (elt text 0))
- (org-export-as-xoxo-insert-into out "<li class='" (substring text 1) "'>")
- (org-export-as-xoxo-insert-into out "<li>" text))))
+ (let* ((hd (match-string-no-properties 1))
+ (level (length hd))
+ (text (concat
+ (match-string-no-properties 2)
+ (save-excursion
+ (goto-char (match-end 0))
+ (let ((str ""))
+ (catch 'loop
+ (while 't
+ (forward-line)
+ (if (looking-at "^[ \t]\\(.*\\)")
+ (setq str (concat str (match-string-no-properties 1)))
+ (throw 'loop str)))))))))
+
+ ;; Handle level rendering
+ (cond
+ ((> level last-level)
+ (org-export-as-xoxo-insert-into out "\n<ol>\n"))
+
+ ((< level last-level)
+ (dotimes (- (- last-level level) 1)
+ (if hanging-li
+ (org-export-as-xoxo-insert-into out "</li>\n"))
+ (org-export-as-xoxo-insert-into out "</ol>\n"))
+ (when hanging-li
+ (org-export-as-xoxo-insert-into out "</li>\n")
+ (setq hanging-li nil)))
+
+ ((equal level last-level)
+ (if hanging-li
+ (org-export-as-xoxo-insert-into out "</li>\n")))
+ )
+
+ (setq last-level level)
+
+ ;; And output the new li
+ (setq hanging-li 't)
+ (if (equal ?+ (elt text 0))
+ (org-export-as-xoxo-insert-into out "<li class='" (substring text 1) "'>")
+ (org-export-as-xoxo-insert-into out "<li>" text))))
;; Finally finish off the ol
(dotimes (- last-level 1)
- (if hanging-li
- (org-export-as-xoxo-insert-into out "</li>\n"))
- (org-export-as-xoxo-insert-into out "</ol>\n"))
+ (if hanging-li
+ (org-export-as-xoxo-insert-into out "</li>\n"))
+ (org-export-as-xoxo-insert-into out "</ol>\n"))
(goto-char pos)
;; Finish the buffer off and clean it up.
;;
;; Emacs Lisp Archive Entry
;; Filename: org-export-latex.el
-;; Version: 6.15a
+;; Version: 6.15d
;; Author: Bastien Guerry <bzg AT altern DOT org>
;; Maintainer: Bastien Guerry <bzg AT altern DOT org>
;; Keywords: org, wp, tex
"Call `org-export-as-latex', may be used in batch processing.
For example:
-emacs --batch
- --load=$HOME/lib/emacs/org.el
- --eval \"(setq org-export-headline-levels 2)\"
- --visit=MyFile --funcall org-export-as-latex-batch"
+emacs --batch
+ --load=$HOME/lib/emacs/org.el
+ --eval \"(setq org-export-headline-levels 2)\"
+ --visit=MyFile --funcall org-export-as-latex-batch"
(org-export-as-latex org-export-headline-levels 'hidden))
;;;###autoload
(defun org-export-as-latex-to-buffer (arg)
- "Call `org-exort-as-latex` with output to a temporary buffer.
+ "Call `org-export-as-latex` with output to a temporary buffer.
No file is created. The prefix ARG is passed through to `org-export-as-latex'."
(interactive "P")
(org-export-as-latex arg nil nil "*Org LaTeX Export*")
coding-system))
(save-buffer-coding-system (or org-export-latex-coding-system
coding-system))
- (region (buffer-substring
+ (region (buffer-substring
(if region-p (region-beginning) (point-min))
(if region-p (region-end) (point-max))))
(string-for-export
(replace-match
(org-export-latex-protect-string
(format "\\texttt{%s}"
- (save-match-data
- (replace-regexp-in-string
- "_" "\\\\_" (match-string 0)))))
- t t)))))
+ (save-match-data
+ (replace-regexp-in-string
+ "_" "\\\\_" (match-string 0)))))
+ t t)))))
(defun org-export-latex-fontify-headline (string)
"Fontify special words in STRING."
(match-string 1)
(match-string 3))) "") t t)))))))
'("^\\([^\n$]*?\\|^\\)\\(\\\\?\\$\\)\\([^\n$]*\\)$"
- "\\([a-za-z0-9]+\\|[ \t\n]\\|\\b\\|\\\\\\)\\(_\\|\\^\\)\\([a-za-z0-9]+\\|[ \t\n]\\|[:punct:]\\|{[a-za-z0-9]+}\\|([a-za-z0-9]+)\\)"
+ "\\([a-za-z0-9]+\\|[ \t\n]\\|\\b\\|\\\\\\)\\(_\\|\\^\\)\\([a-za-z0-9]+\\|[ \t\n]\\|[:punct:]\\|{[a-za-z0-9]+}\\|([a-za-z0-9]+)\\)"
"\\(.\\|^\\)\\(\\\\\\)\\([ \t\n]\\|[a-zA-Z&#%{}\"]+\\)"
"\\(.\\|^\\)\\(&\\)"
- "\\(.\\|^\\)\\(#\\)"
- "\\(.\\|^\\)\\(%\\)"
- "\\(.\\|^\\)\\({\\)"
+ "\\(.\\|^\\)\\(#\\)"
+ "\\(.\\|^\\)\\(%\\)"
+ "\\(.\\|^\\)\\({\\)"
"\\(.\\|^\\)\\(}\\)"
"\\(.\\|^\\)\\(~\\)"
"\\(.\\|^\\)\\(\\.\\.\\.\\)"
floatp (or caption label))
(setq lines (split-string raw-table "\n" t))
(apply 'delete-region (list beg end))
- (when org-export-table-remove-special-lines
- (setq lines (org-table-clean-before-export lines)))
+ (when org-export-table-remove-special-lines
+ (setq lines (org-table-clean-before-export lines)))
;; make a formatting string to reflect aligment
(setq olines lines)
(while (and (not line-fmt) (setq line (pop olines)))
(or (and (string-match "[ \t]*|-+" elem) 'hline)
(split-string (org-trim elem) "|" t)))
lines))
- (when insert
+ (when insert
(insert (org-export-latex-protect-string
(concat
(if longtblp
(if longtblp "\\\\\n" "\n")
(if (not longtblp) "\\begin{center}\n")
(if (not longtblp) (concat "\\begin{tabular}{" align "}\n"))
- (orgtbl-to-latex
+ (orgtbl-to-latex
lines
`(:tstart nil :tend nil
:hlend ,(if longtblp
((member type '("http" "https" "ftp"))
(concat type ":" raw-path))
((and re-radio (string-match re-radio raw-path))
- (setq radiop t))
+ (setq radiop t))
((equal type "mailto")
(concat type ":" raw-path))
((equal type "file")
(while (re-search-forward "^----+.$" nil t)
(replace-match (org-export-latex-protect-string "\\hrule") t t))
- ;; Protect LaTeX commands like \commad[...]{...} or \command{...}
+ ;; Protect LaTeX commands like \command[...]{...} or \command{...}
(goto-char (point-min))
(while (re-search-forward "\\\\[a-zA-Z]+\\(?:\\[.*\\]\\)?{.*}" nil t)
(add-text-properties (match-beginning 0) (match-end 0)
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;
;;; Commentary:
-;; This file contains the face definitons for Org.
+;; This file contains the face definitions for Org.
;;; Code:
;; Tassilo Horn <tassilo at member dot fsf dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; time of the ID, with microsecond accuracy. This virtually
;; guarantees globally unique identifiers, even if several people are
;; creating IDs at the same time in files that will eventually be used
-;; together. As an exernal method `uuidgen' is supported, if installed
+;; together. As an external method `uuidgen' is supported, if installed
;; on the system.
;;
;; This file defines the following API:
:group 'org)
-(defcustom org-id-method
+(defcustom org-id-method
(condition-case nil
(if (string-match "\\`[-0-9a-fA-F]\\{36\\}\\'"
(org-trim (shell-command-to-string "uuidgen")))
"The method that should be used to create new IDs.
If `uuidgen' is available on the system, it will be used as the default method.
-if not. the methd `org' is used.
+if not, the method `org' is used.
An ID will consist of the optional prefix specified in `org-id-prefix',
and a unique part created by the method this variable specifies.
:type 'boolean)
(defcustom org-id-track-globally t
- "Non-nil means, track IDs trhough files, so that links work globally.
+ "Non-nil means, track IDs through files, so that links work globally.
This work by maintaining a hash table for IDs and writing this table
to disk when exiting Emacs. Because of this, it works best if you use
a single Emacs process, not many.
(defcustom org-id-search-archives t
"Non-nil means, search also the archive files of agenda files for entries.
-This is a possibility to reduce overhead, but it measn that entries moved
+This is a possibility to reduce overhead, but it means that entries moved
to the archives can no longer be found by ID.
This variable is only relevant when `org-id-track-globally' is set."
:group 'org-id
This will scan all agenda files, all associated archives, and all
files currently mentioned in `org-id-locations'.
When FILES is given, scan these files instead.
-When CHECK is given, prepare detailed iinformation about duplicate IDs."
+When CHECK is given, prepare detailed information about duplicate IDs."
(interactive)
(if (not org-id-track-globally)
(error "Please turn on `org-id-track-globally' if you want to track IDs.")
(setq org-id-locations (org-id-alist-to-hash org-id-locations))))
(defun org-id-add-location (id file)
- "Add the ID with location FILE to the database of ID loations."
+ "Add the ID with location FILE to the database of ID locations."
;; Only if global tracking is on, and when the buffer has a file
- (when (and org-id-track-globally id file)
+ (when (and org-id-track-globally id file)
(unless org-id-locations (org-id-locations-load))
(puthash id (abbreviate-file-name file) org-id-locations)
(add-to-list 'org-id-files (abbreviate-file-name file))))
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;
;; Author: Philip Jackson <emacs@shellarchive.co.uk>
;; Keywords: erc, irc, link, org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; 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
+;; 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
(require 'org)
-;; Declare the function fomr ERC that we use.
+;; Declare the function form ERC that we use.
(declare-function erc-current-logfile "erc-log" (&optional buffer))
(declare-function erc-prompt "erc" ())
(declare-function erc-default-target "erc" ())
and user being optional) and return any of the port, channel or user
attributes that are found."
(let* ((parts (split-string link "/" t))
- (len (length parts)))
+ (len (length parts)))
(when (or (< len 1) (> len 3))
(error "Failed to parse link needed 1-3 parts, got %d" len))
(setcar parts (split-string (car parts) ":" t))
Strip starting and ending white space from STRING and replace any
chars that the value AFTER with '...'"
(let* ((after (number-to-string (or after 30)))
- (replace-map (list (cons "^[ \t]*" "")
- (cons "[ \t]*$" "")
- (cons (concat "^\\(.\\{" after
- "\\}\\).*") "\\1..."))))
+ (replace-map (list (cons "^[ \t]*" "")
+ (cons "[ \t]*$" "")
+ (cons (concat "^\\(.\\{" after
+ "\\}\\).*") "\\1..."))))
(mapc (lambda (x)
- (when (string-match (car x) string)
- (setq string (replace-match (cdr x) nil nil string))))
- replace-map)
+ (when (string-match (car x) string)
+ (setq string (replace-match (cdr x) nil nil string))))
+ replace-map)
string))
;; ERC specific functions
(abbreviate-file-name buffer-file-name)
;; can we get a '::' part?
(if (string= erc-line (erc-prompt))
- (progn
- (goto-char (point-at-bol))
- (when (search-backward-regexp "^[^ ]" nil t)
- (buffer-substring-no-properties (point-at-bol)
- (point-at-eol))))
- (when (search-backward erc-line nil t)
- (buffer-substring-no-properties (point-at-bol)
- (point-at-eol)))))))
+ (progn
+ (goto-char (point-at-bol))
+ (when (search-backward-regexp "^[^ ]" nil t)
+ (buffer-substring-no-properties (point-at-bol)
+ (point-at-eol))))
+ (when (search-backward erc-line nil t)
+ (buffer-substring-no-properties (point-at-bol)
+ (point-at-eol)))))))
(defun org-irc-erc-store-link ()
"Store a link to the IRC log file or the session itself.
(require 'erc-log)
(if org-irc-link-to-logs
(let* ((erc-line (buffer-substring-no-properties
- (point-at-bol) (point-at-eol)))
- (parsed-line (org-irc-erc-get-line-from-log erc-line)))
- (if (erc-logging-enabled nil)
- (progn
- (org-store-link-props
- :type "file"
- :description (concat "'" (org-irc-elipsify-description
- (cadr parsed-line) 20)
- "' from an IRC conversation")
- :link (concat "file:" (car parsed-line) "::"
- (cadr parsed-line)))
- t)
- (error "This ERC session is not being logged")))
+ (point-at-bol) (point-at-eol)))
+ (parsed-line (org-irc-erc-get-line-from-log erc-line)))
+ (if (erc-logging-enabled nil)
+ (progn
+ (org-store-link-props
+ :type "file"
+ :description (concat "'" (org-irc-elipsify-description
+ (cadr parsed-line) 20)
+ "' from an IRC conversation")
+ :link (concat "file:" (car parsed-line) "::"
+ (cadr parsed-line)))
+ t)
+ (error "This ERC session is not being logged")))
(let* ((link-text (org-irc-get-erc-link))
- (link (org-irc-parse-link link-text)))
- (if link-text
- (progn
- (org-store-link-props
- :type "irc"
- :link (org-make-link "irc:/" link-text)
- :description (concat "irc session '" link-text "'")
- :server (car (car link))
- :port (or (string-to-number (cadr (pop link))) erc-default-port)
- :nick (pop link))
- t)
- (error "Failed to create ('irc:/' style) ERC link")))))
+ (link (org-irc-parse-link link-text)))
+ (if link-text
+ (progn
+ (org-store-link-props
+ :type "irc"
+ :link (org-make-link "irc:/" link-text)
+ :description (concat "irc session '" link-text "'")
+ :server (car (car link))
+ :port (or (string-to-number (cadr (pop link))) erc-default-port)
+ :nick (pop link))
+ t)
+ (error "Failed to create ('irc:/' style) ERC link")))))
(defun org-irc-get-erc-link ()
"Return an org compatible irc:/ link from an ERC buffer."
(let* ((session-port (if (numberp erc-session-port)
- (number-to-string erc-session-port)
- erc-session-port))
- (link (concat erc-session-server ":" session-port)))
+ (number-to-string erc-session-port)
+ erc-session-port))
+ (link (concat erc-session-server ":" session-port)))
(concat link "/"
- (if (and (erc-default-target)
- (erc-channel-p (erc-default-target))
- (car (get-text-property (point) 'erc-data)))
- ;; we can get a nick
- (let ((nick (car (get-text-property (point) 'erc-data))))
- (concat (erc-default-target) "/" nick))
- (erc-default-target)))))
+ (if (and (erc-default-target)
+ (erc-channel-p (erc-default-target))
+ (car (get-text-property (point) 'erc-data)))
+ ;; we can get a nick
+ (let ((nick (car (get-text-property (point) 'erc-data))))
+ (concat (erc-default-target) "/" nick))
+ (erc-default-target)))))
(defun org-irc-get-current-erc-port ()
"Return the current port as a number.
(require 'erc)
(require 'erc-log)
(let* ((server (car (car link)))
- (port (or (string-to-number (cadr (pop link))) erc-default-port))
- (server-buffer)
- (buffer-list
- (erc-buffer-filter
- (lambda nil
- (let ((tmp-server-buf (erc-server-buffer)))
- (and tmp-server-buf
- (with-current-buffer tmp-server-buf
- (and
- (eq (org-irc-get-current-erc-port) port)
- (string= erc-session-server server)
- (setq server-buffer tmp-server-buf)))))))))
+ (port (or (string-to-number (cadr (pop link))) erc-default-port))
+ (server-buffer)
+ (buffer-list
+ (erc-buffer-filter
+ (lambda nil
+ (let ((tmp-server-buf (erc-server-buffer)))
+ (and tmp-server-buf
+ (with-current-buffer tmp-server-buf
+ (and
+ (eq (org-irc-get-current-erc-port) port)
+ (string= erc-session-server server)
+ (setq server-buffer tmp-server-buf)))))))))
(if buffer-list
- (let ((chan-name (pop link)))
- ;; if we got a channel name then switch to it or join it
- (if chan-name
- (let ((chan-buf (catch 'found
- (dolist (x buffer-list)
- (if (string= (buffer-name x) chan-name)
- (throw 'found x))))))
- (if chan-buf
- (progn
- (switch-to-buffer chan-buf)
- ;; if we got a nick, and they're in the chan,
- ;; then start a chat with them
- (let ((nick (pop link)))
- (when nick
- (if (member nick (erc-get-server-nickname-list))
- (progn
- (goto-char (point-max))
- (insert (concat nick ": ")))
- (error "%s not found in %s" nick chan-name)))))
- (progn
- (switch-to-buffer server-buffer)
- (erc-cmd-JOIN chan-name))))
- (switch-to-buffer server-buffer)))
- ;; no server match, make new connection
- (erc-select :server server :port port))))
+ (let ((chan-name (pop link)))
+ ;; if we got a channel name then switch to it or join it
+ (if chan-name
+ (let ((chan-buf (catch 'found
+ (dolist (x buffer-list)
+ (if (string= (buffer-name x) chan-name)
+ (throw 'found x))))))
+ (if chan-buf
+ (progn
+ (switch-to-buffer chan-buf)
+ ;; if we got a nick, and they're in the chan,
+ ;; then start a chat with them
+ (let ((nick (pop link)))
+ (when nick
+ (if (member nick (erc-get-server-nickname-list))
+ (progn
+ (goto-char (point-max))
+ (insert (concat nick ": ")))
+ (error "%s not found in %s" nick chan-name)))))
+ (progn
+ (switch-to-buffer server-buffer)
+ (erc-cmd-JOIN chan-name))))
+ (switch-to-buffer server-buffer)))
+ ;; no server match, make new connection
+ (erc-select :server server :port port))))
(provide 'org-irc)
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
:group 'org-export-html)
(defcustom org-export-html-use-infojs 'when-configured
- "Should Sebasian Rose's Java Script org-info.js be linked into HTML files?
+ "Should Sebastian Rose's Java Script org-info.js be linked into HTML files?
This option can be nil or t to never or always use the script. It can
also be the symbol `when-configured', meaning that the script will be
linked into the export file if and only if there is a \"#+INFOJS_OPT:\"
<script type=\"text/javascript\" >
<!--/*--><![CDATA[/*><!--*/
%MANAGER_OPTIONS
-org_html_manager.setup(); // activate after the parameterd are set
+org_html_manager.setup(); // activate after the parameters are set
/*]]>*/-->
</script>"
"The template for the export style additions when org-info.js is used.
;; Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
;;
;; Author: Carsten Dominik <carsten at orgmode dot org>
-;; Bastien Guerry <bzg AT altern DOT org>
+;; Bastien Guerry <bzg AT altern DOT org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; 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
+;; 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
This means that during cycling, plain list items will *temporarily* be
interpreted as outline headlines with a level given by 1000+i where i is the
indentation of the bullet. In all other operations, plain list items are
-not seen as headlines. For example, you cannot assign a TODO keyword to
+not seen as headlines. For example, you cannot assign a TODO keyword to
such an item."
:group 'org-plain-lists
:type 'boolean)
(defcustom org-list-two-spaces-after-bullet-regexp nil
"A regular expression matching bullets that should have 2 spaces after them.
When nil, no bullet will have two spaces after them.
-When a string, it will be used as a regular expression. When the bullet
+When a string, it will be used as a regular expression. When the bullet
type of a list is changed, the new bullet type will be matched against this
-regexp. If it matches, there will be two spaces instead of one after
+regexp. If it matches, there will be two spaces instead of one after
the bullet in each item of he list."
:group 'org-plain-list
:type '(choice
(re-box "^[ \t]*\\([-+*]\\|[0-9]+[.)]\\) +\\(\\[[- X]\\]\\)")
(re-find (concat re "\\|" re-box))
beg-cookie end-cookie is-percent c-on c-off lim
- eline curr-ind next-ind continue-from startsearch
- (cstat 0)
- )
+ eline curr-ind next-ind continue-from startsearch
+ (cstat 0)
+ )
(when all
(goto-char (point-min))
(outline-next-heading)
;; find each statistic cookie
(while (re-search-backward re-find beg t)
(setq beg-cookie (match-beginning 1)
- end-cookie (match-end 1)
+ end-cookie (match-end 1)
cstat (+ cstat (if end-cookie 1 0))
startsearch (point-at-eol)
continue-from (point-at-bol)
- is-percent (match-beginning 2)
+ is-percent (match-beginning 2)
lim (cond
((org-on-heading-p) (outline-next-heading) (point))
((org-at-item-p) (org-end-of-item) (point))
(t nil))
- c-on 0
- c-off 0)
+ c-on 0
+ c-off 0)
(when lim
- ;; find first checkbox for this cookie and gather
- ;; statistics from all that are at this indentation level
- (goto-char startsearch)
- (if (re-search-forward re-box lim t)
- (progn
- (org-beginning-of-item)
- (setq curr-ind (org-get-indentation))
- (setq next-ind curr-ind)
- (while (and (bolp) (org-at-item-p) (= curr-ind next-ind))
- (save-excursion (end-of-line) (setq eline (point)))
- (if (re-search-forward re-box eline t)
+ ;; find first checkbox for this cookie and gather
+ ;; statistics from all that are at this indentation level
+ (goto-char startsearch)
+ (if (re-search-forward re-box lim t)
+ (progn
+ (org-beginning-of-item)
+ (setq curr-ind (org-get-indentation))
+ (setq next-ind curr-ind)
+ (while (and (bolp) (org-at-item-p) (= curr-ind next-ind))
+ (save-excursion (end-of-line) (setq eline (point)))
+ (if (re-search-forward re-box eline t)
(if (member (match-string 2) '("[ ]" "[-]"))
(setq c-off (1+ c-off))
- (setq c-on (1+ c-on))
- )
- )
- (org-end-of-item)
- (setq next-ind (org-get-indentation))
- )))
+ (setq c-on (1+ c-on))
+ )
+ )
+ (org-end-of-item)
+ (setq next-ind (org-get-indentation))
+ )))
(goto-char continue-from)
- ;; update cookie
+ ;; update cookie
(when end-cookie
(delete-region beg-cookie end-cookie)
(goto-char beg-cookie)
(if is-percent
(format "[%d%%]" (/ (* 100 c-on) (max 1 (+ c-on c-off))))
(format "[%d/%d]" c-on (+ c-on c-off)))))
- ;; update items checkbox if it has one
- (when (org-at-item-p)
- (org-beginning-of-item)
- (when (and (> (+ c-on c-off) 0)
+ ;; update items checkbox if it has one
+ (when (org-at-item-p)
+ (org-beginning-of-item)
+ (when (and (> (+ c-on c-off) 0)
(re-search-forward re-box (point-at-eol) t))
- (setq beg-cookie (match-beginning 2)
- end-cookie (match-end 2))
- (delete-region beg-cookie end-cookie)
- (goto-char beg-cookie)
- (cond ((= c-off 0) (insert "[X]"))
- ((= c-on 0) (insert "[ ]"))
- (t (insert "[-]")))
- )))
+ (setq beg-cookie (match-beginning 2)
+ end-cookie (match-end 2))
+ (delete-region beg-cookie end-cookie)
+ (goto-char beg-cookie)
+ (cond ((= c-off 0) (insert "[X]"))
+ ((= c-on 0) (insert "[ ]"))
+ (t (insert "[-]")))
+ )))
(goto-char continue-from))
(when (interactive-p)
- (message "Checkbox satistics updated %s (%d places)"
+ (message "Checkbox statistics updated %s (%d places)"
(if all "in entire file" "in current outline entry") cstat)))))
(defun org-get-checkbox-statistics-face ()
"Cycle through the different itemize/enumerate bullets.
This cycle the entire list level through the sequence:
- `-' -> `+' -> `*' -> `1.' -> `1)'
+ `-' -> `+' -> `*' -> `1.' -> `1)'
If WHICH is a string, use that as the new bullet. If WHICH is an integer,
-0 meand `-', 1 means `+' etc."
+0 means `-', 1 means `+' etc."
(interactive "P")
(org-preserve-lc
(org-beginning-of-item-list)
(interactive)
(org-beginning-of-item)
(let ((pos (point-at-bol))
- (ind (org-get-indentation))
+ (ind (org-get-indentation))
ind1)
;; find where this list begins
(catch 'exit
(interactive)
(org-beginning-of-item)
(let ((pos (point-at-bol))
- (ind (org-get-indentation))
+ (ind (org-get-indentation))
ind1)
;; find where this list begins
(catch 'exit
(defun org-item-indent-positions ()
"Return indentation for plain list items.
-This returns a list with three values: The current indentation, the
-parent indentation and the indentation a child should habe.
+This returns a list with three values: The current indentation, the
+parent indentation and the indentation a child should have.
Assumes cursor in item line."
(let* ((bolpos (point-at-bol))
(ind (org-get-indentation))
Return a list containing first level items as strings and
sublevels as a list of strings."
(let* ((item-beginning (org-list-item-beginning))
- (start (car item-beginning))
- (end (org-list-end (cdr item-beginning)))
- output itemsep ltype)
+ (start (car item-beginning))
+ (end (org-list-end (cdr item-beginning)))
+ output itemsep ltype)
(while (re-search-forward org-list-beginning-re end t)
(goto-char (match-beginning 3))
(save-match-data
- (cond ((string-match "[0-9]" (match-string 2))
- (setq itemsep "[0-9]+\\(?:\\.\\|)\\)"
- ltype 'ordered))
- ((string-match "^.*::" (match-string 0))
- (setq itemsep "[-+]" ltype 'descriptive))
- (t (setq itemsep "[-+]" ltype 'unordered))))
+ (cond ((string-match "[0-9]" (match-string 2))
+ (setq itemsep "[0-9]+\\(?:\\.\\|)\\)"
+ ltype 'ordered))
+ ((string-match "^.*::" (match-string 0))
+ (setq itemsep "[-+]" ltype 'descriptive))
+ (t (setq itemsep "[-+]" ltype 'unordered))))
(let* ((indent1 (match-string 1))
(nextitem (save-excursion
(save-match-data
(throw 'exit nil)
(error "Don't know how to transform this list"))))
(let* ((name (match-string 1))
- (item-beginning (org-list-item-beginning))
+ (item-beginning (org-list-item-beginning))
(transform (intern (match-string 2)))
(txt (buffer-substring-no-properties
- (car item-beginning)
+ (car item-beginning)
(org-list-end (cdr item-beginning))))
(list (org-list-parse-list))
- beg)
+ beg)
(unless (fboundp transform)
(error "No such transformation function %s" transform))
(setq txt (funcall transform list))
Valid parameters PARAMS are
-:ustart String to start an unordered list
-:uend String to end an unordered list
+:ustart String to start an unordered list
+:uend String to end an unordered list
-:ostart String to start an ordered list
-:oend String to end an ordered list
+:ostart String to start an ordered list
+:oend String to end an ordered list
-:dstart String to start a descriptive list
-:dend String to end a descriptive list
+:dstart String to start a descriptive list
+:dend String to end a descriptive list
:dtstart String to start a descriptive term
-:dtend String to end a descriptive term
+:dtend String to end a descriptive term
:ddstart String to start a description
-:ddend String to end a description
+:ddend String to end a description
-:splice When set to t, return only list body lines, don't wrap
- them into :[u/o]start and :[u/o]end. Default is nil.
+:splice When set to t, return only list body lines, don't wrap
+ them into :[u/o]start and :[u/o]end. Default is nil.
-:istart String to start a list item
-:iend String to end a list item
-:isep String to separate items
-:lsep String to separate sublists"
+:istart String to start a list item
+:iend String to end a list item
+:isep String to separate items
+:lsep String to separate sublists"
(interactive)
(let* ((p params) sublist
(splicep (plist-get p :splice))
(ostart (plist-get p :ostart))
- (oend (plist-get p :oend))
+ (oend (plist-get p :oend))
(ustart (plist-get p :ustart))
- (uend (plist-get p :uend))
+ (uend (plist-get p :uend))
(dstart (plist-get p :dstart))
- (dend (plist-get p :dend))
+ (dend (plist-get p :dend))
(dtstart (plist-get p :dtstart))
- (dtend (plist-get p :dtend))
+ (dtend (plist-get p :dtend))
(ddstart (plist-get p :ddstart))
- (ddend (plist-get p :ddend))
+ (ddend (plist-get p :ddend))
(istart (plist-get p :istart))
- (iend (plist-get p :iend))
- (isep (plist-get p :isep))
- (lsep (plist-get p :lsep)))
+ (iend (plist-get p :iend))
+ (isep (plist-get p :isep))
+ (lsep (plist-get p :lsep)))
(let ((wrapper
(cond ((eq (car list) 'ordered)
(concat ostart "\n%s" oend "\n"))
(while (setq sublist (pop list))
(cond ((symbolp sublist) nil)
((stringp sublist)
- (when (string-match "^\\(.*\\) ::" sublist)
- (setq term (org-trim (format (concat dtstart "%s" dtend)
- (match-string 1 sublist))))
- (setq sublist (substring sublist (1+ (length term)))))
- (setq rtn (concat rtn istart term ddstart
- sublist ddend iend isep)))
- (t (setq rtn (concat rtn ;; previous list
- lsep ;; list separator
- (org-list-to-generic sublist p)
- lsep ;; list separator
- )))))
+ (when (string-match "^\\(.*\\) ::" sublist)
+ (setq term (org-trim (format (concat dtstart "%s" dtend)
+ (match-string 1 sublist))))
+ (setq sublist (substring sublist (1+ (length term)))))
+ (setq rtn (concat rtn istart term ddstart
+ sublist ddend iend isep)))
+ (t (setq rtn (concat rtn ;; previous list
+ lsep ;; list separator
+ (org-list-to-generic sublist p)
+ lsep ;; list separator
+ )))))
(format wrapper rtn))))
(defun org-list-to-latex (list)
"Convert LIST into a LaTeX list."
(org-list-to-generic
list '(:splicep nil :ostart "\\begin{enumerate}" :oend "\\end{enumerate}"
- :ustart "\\begin{itemize}" :uend "\\end{itemize}"
- :dstart "\\begin{description}" :dend "\\end{description}"
- :dtstart "[" :dtend "]"
- :ddstart "" :ddend ""
- :istart "\\item " :iend ""
- :isep "\n" :lsep "\n")))
+ :ustart "\\begin{itemize}" :uend "\\end{itemize}"
+ :dstart "\\begin{description}" :dend "\\end{description}"
+ :dtstart "[" :dtend "]"
+ :ddstart "" :ddend ""
+ :istart "\\item " :iend ""
+ :isep "\n" :lsep "\n")))
(defun org-list-to-html (list)
"Convert LIST into a HTML list."
(org-list-to-generic
list '(:splicep nil :ostart "<ol>" :oend "</ol>"
-
:ustart "<ul>" :uend "</ul>"
-
:dstart "<dl>" :dend "</dl>"
- :dtstart "<dt>" :dtend "</dt>"
- :ddstart "<dd>" :ddend "</dd>"
- :istart "<li>" :iend "</li>"
- :isep "\n" :lsep "\n")))
+ :ustart "<ul>" :uend "</ul>"
+ :dstart "<dl>" :dend "</dl>"
+ :dtstart "<dt>" :dtend "</dt>"
+ :ddstart "<dd>" :ddend "</dd>"
+ :istart "<li>" :iend "</li>"
+ :isep "\n" :lsep "\n")))
(defun org-list-to-texinfo (list)
"Convert LIST into a Texinfo list."
(org-list-to-generic
list '(:splicep nil :ostart "@itemize @minus" :oend "@end itemize"
- :ustart "@enumerate" :uend "@end enumerate"
- :dstart "@table" :dend "@end table"
- :dtstart "@item " :dtend "\n"
- :ddstart "" :ddend ""
- :istart "@item\n" :iend ""
- :isep "\n" :lsep "\n")))
+ :ustart "@enumerate" :uend "@end enumerate"
+ :dstart "@table" :dend "@end table"
+ :dtstart "@item " :dtend "\n"
+ :ddstart "" :ddend ""
+ :istart "@item\n" :iend ""
+ :isep "\n" :lsep "\n")))
(provide 'org-list)
;; Copyright (C) 2008 Free Software Foundation, Inc.
;; Author: John Wiegley <johnw@gnu.org>
-;; Version: 6.15a
+;; Version: 6.15d
;; Keywords: outlines, hypermedia, calendar, wp
;; This file is part of GNU Emacs.
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
(defmacro declare-function (fn file &optional arglist fileonly))))
(defmacro org-maybe-intangible (props)
- "Add '(intangigble t) to PROPS if Emacs version is earlier than Emacs 22.
+ "Add '(intangible t) to PROPS if Emacs version is earlier than Emacs 22.
In emacs 21, invisible text is not avoided by the command loop, so the
intangible property is needed to make sure point skips this text.
In Emacs 22, this is not necessary. The intangible text property has
;; Author: Tokuya Kameshima <kames at fa2 dot so-net dot ne dot jp>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;; This file is part of GNU Emacs.
;; Author: Thomas Baumann <thomas dot baumann at ch dot tum dot de>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
So if you use sequences, it will now work."
(save-excursion
(let* ((folder
- (if (equal major-mode 'mh-folder-mode)
- mh-current-folder
- ;; Refer to the show buffer
- mh-show-folder-buffer))
- (end-index
- (if (boundp 'mh-index-folder)
- (min (length mh-index-folder) (length folder))))
- )
+ (if (equal major-mode 'mh-folder-mode)
+ mh-current-folder
+ ;; Refer to the show buffer
+ mh-show-folder-buffer))
+ (end-index
+ (if (boundp 'mh-index-folder)
+ (min (length mh-index-folder) (length folder))))
+ )
;; a simple test on mh-index-data does not work, because
;; mh-index-data is always nil in a show buffer.
(if (and (boundp 'mh-index-folder)
- (string= mh-index-folder (substring folder 0 end-index)))
- (if (equal major-mode 'mh-show-mode)
- (save-window-excursion
+ (string= mh-index-folder (substring folder 0 end-index)))
+ (if (equal major-mode 'mh-show-mode)
+ (save-window-excursion
(let (pop-up-frames)
(when (buffer-live-p (get-buffer folder))
(progn
(org-mhe-get-message-folder-from-index)
)
)))
- (org-mhe-get-message-folder-from-index)
- )
- folder
- )
+ (org-mhe-get-message-folder-from-index)
+ )
+ folder
+ )
)))
(defun org-mhe-get-message-folder-from-index ()
Be careful if you use sequences."
(save-excursion
(if (equal major-mode 'mh-folder-mode)
- mh-current-folder
+ mh-current-folder
;; Refer to the show buffer
mh-show-folder-buffer)))
Be careful if you use sequences."
(save-excursion
(if (equal major-mode 'mh-folder-mode)
- (mh-get-msg-num nil)
+ (mh-get-msg-num nil)
;; Refer to the show buffer
(mh-show-buffer-message-number))))
This will create a show buffer for the corresponding message. If
you have a better idea of how to do this then please let us know."
(let* ((folder (org-mhe-get-message-folder))
- (num (org-mhe-get-message-num))
- (buffer (get-buffer-create (concat "show-" folder)))
- (header-field))
+ (num (org-mhe-get-message-num))
+ (buffer (get-buffer-create (concat "show-" folder)))
+ (header-field))
(with-current-buffer buffer
(mh-display-msg num folder)
(if (equal major-mode 'mh-folder-mode)
- (mh-header-display)
+ (mh-header-display)
(mh-show-header-display))
(set-buffer buffer)
(setq header-field (mh-get-header-field header))
(if (equal major-mode 'mh-folder-mode)
- (mh-show)
+ (mh-show)
(mh-show-show))
header-field)))
(mh-visit-folder (mh-normalize-folder-name folder))
(mh-search-choose)
(if (equal mh-searcher 'pick)
- (progn
+ (progn
(setq article (org-add-angle-brackets article))
- (mh-search folder (list "--message-id" article))
- (when (and org-mhe-search-all-folders
- (not (org-mhe-get-message-real-folder)))
- (kill-this-buffer)
- (mh-search "+" (list "--message-id" article))))
+ (mh-search folder (list "--message-id" article))
+ (when (and org-mhe-search-all-folders
+ (not (org-mhe-get-message-real-folder)))
+ (kill-this-buffer)
+ (mh-search "+" (list "--message-id" article))))
(if mh-search-regexp-builder
- (mh-search "+" (funcall mh-search-regexp-builder
+ (mh-search "+" (funcall mh-search-regexp-builder
(list (cons 'message-id article))))
- (mh-search "+" article)))
+ (mh-search "+" article)))
(if (org-mhe-get-message-real-folder)
- (mh-show-msg 1)
+ (mh-show-msg 1)
(kill-this-buffer)
(error "Message not found"))))
;;
;; Author: Piotr Zielinski <piotr dot zielinski at gmail dot com>
;; Maintainer: Carsten Dominik <carsten at orgmode dot org>
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; (require 'org-mouse)
;;
-;; Fixme:
+;; FIXME:
;; + deal with folding / unfolding issues
;; TODO (This list is only theoretical, if you'd like to have some
;; History:
;;
-;; SInce version 5.10: Changes are listed in the general org-mode docs.
+;; Since version 5.10: Changes are listed in the general org-mode docs.
;;
;; Version 5.09
;; + Version number synchronization with Org-mode.
(or (not mark-active)
(sit-for (/ double-click-time 1000.0))))
(progn
- (select-window (posn-window (event-start event)))
+ (select-window (posn-window (event-start event)))
(when (not (org-mouse-mark-active))
(goto-char (posn-point (event-start event)))
(when (not (eolp)) (save-excursion (run-hooks 'post-command-hook)))
is selected, group GROUP of the current match is replaced by the
keyword. The method ensures that both ends of the replacement
are separated from the rest of the text in the buffer by
-individual spaces (unless NOSURROND is non-nil).
+individual spaces (unless NOSURROUND is non-nil).
The final entry of the menu is always \"None\", which removes the
match.
(org-mouse-remove-match-and-spaces))))]
)))
((and (org-mouse-looking-at "\\b\\w+" "a-zA-Z0-9_")
- (member (match-string 0) (org-mouse-todo-keywords)))
+ (member (match-string 0) (org-mouse-todo-keywords)))
(popup-menu
`(nil
,@(org-mouse-keyword-replace-menu (org-mouse-todo-keywords))
;; (defun org-mouse-at-regexp (regexp)
;; (save-excursion
;; (let ((point (point))
-;; (bol (progn (beginning-of-line) (point)))
-;; (eol (progn (end-of-line) (point))))
-;; (goto-char point)
-;; (re-search-backward regexp bol 1)
-;; (and (not (eolp))
-;; (progn (forward-char)
-;; (re-search-forward regexp eol t))
-;; (<= (match-beginning 0) point)))))
+;; (bol (progn (beginning-of-line) (point)))
+;; (eol (progn (end-of-line) (point))))
+;; (goto-char point)
+;; (re-search-backward regexp bol 1)
+;; (and (not (eolp))
+;; (progn (forward-char)
+;; (re-search-forward regexp eol t))
+;; (<= (match-beginning 0) point)))))
(defun org-mouse-mark-active ()
(and mark-active transient-mark-mode))
`((,outline-regexp
0 `(face org-link mouse-face highlight keymap ,org-mouse-map)
'prepend))
- t))
+ t))
(when (memq 'activate-bullets org-mouse-features)
(font-lock-add-keywords
`(("^[ \t]*\\([-+*]\\|[0-9]+[.)]\\) +"
(1 `(face org-link keymap ,org-mouse-map mouse-face highlight)
'prepend)))
- t))
+ t))
(when (memq 'activate-checkboxes org-mouse-features)
(font-lock-add-keywords
nil
`(("^[ \t]*\\([-+*]\\|[0-9]+[.)]\\) +\\(\\[[ X]\\]\\)"
(2 `(face bold keymap ,org-mouse-map mouse-face highlight) t)))
- t))
+ t))
(defadvice org-open-at-point (around org-mouse-open-at-point activate)
(let ((context (org-context)))
;; Author: Eric Schulte <schulte dot eric at gmail dot com>
;; Keywords: tables, plotting
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
("file" . :file)
("labels" . :labels)
("map" . :map)
- ("timefmt" . :timefmt)))
+ ("timefmt" . :timefmt)))
(multiples '("set" "line"))
(regexp ":\\([\"][^\"]+?[\"]\\|[(][^)]+?[)]\\|[^ \t\n\r;,.]*\\)")
(start 0)
"Quote field S for export to gnuplot."
(if (string-match org-table-number-regexp s) s
(if (string-match org-ts-regexp3 s)
- (org-plot-quote-timestamp-field s)
+ (org-plot-quote-timestamp-field s)
(concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"") "\""))))
(defun org-plot/gnuplot-to-data (table data-file params)
data-file
(make-local-variable 'org-plot-timestamp-fmt)
(setq org-plot-timestamp-fmt (or
- (plist-get params :timefmt)
- "%Y-%m-%d-%H:%M:%S"))
+ (plist-get params :timefmt)
+ "%Y-%m-%d-%H:%M:%S"))
(insert (orgtbl-to-generic
- table
- (org-combine-plists
- '(:sep "\t" :fmt org-plot-quote-tsv-field)
- params))))
+ table
+ (org-combine-plists
+ '(:sep "\t" :fmt org-plot-quote-tsv-field)
+ params))))
nil)
(defun org-plot/gnuplot-to-grid-data (table data-file params)
"Export the data in TABLE to DATA-FILE for gnuplot.
This means, in a format appropriate for grid plotting by gnuplot.
-PARAMS specifies which columns of TABLE should be plotted as independant
+PARAMS specifies which columns of TABLE should be plotted as independent
and dependant variables."
(interactive)
(let* ((ind (- (plist-get params :ind) 1))
(title (plist-get params :title))
(file (plist-get params :file))
(ind (plist-get params :ind))
- (time-ind (plist-get params :timeind))
- (timefmt (plist-get params :timefmt))
+ (time-ind (plist-get params :timeind))
+ (timefmt (plist-get params :timefmt))
(text-ind (plist-get params :textind))
(deps (if (plist-member params :deps) (plist-get params :deps)))
(col-labels (plist-get params :labels))
(format "\"%s\" %d" (cdr pair) (car pair)))
y-labels ", "))))
(when time-ind ;; timestamp index
- (add-to-script "set xdata time")
- (add-to-script (concat "set timefmt \""
- (or timefmt ;; timefmt passed to gnuplot
- "%Y-%m-%d-%H:%M:%S") "\"")))
+ (add-to-script "set xdata time")
+ (add-to-script (concat "set timefmt \""
+ (or timefmt ;; timefmt passed to gnuplot
+ "%Y-%m-%d-%H:%M:%S") "\"")))
(case type ;; plot command
('2d (dotimes (col num-cols)
(unless (and (equal type '2d)
(when y-labels (plist-put params :ylabels y-labels)))))
;; check for timestamp ind column
(let ((ind (- (plist-get params :ind) 1)))
- (when (and (>= ind 0) (equal '2d (plist-get params :plot-type)))
- (if (= (length
- (delq 0 (mapcar
+ (when (and (>= ind 0) (equal '2d (plist-get params :plot-type)))
+ (if (= (length
+ (delq 0 (mapcar
(lambda (el)
(if (string-match org-ts-regexp3 el)
0 1))
(mapcar (lambda (row) (nth ind row)) table)))) 0)
(plist-put params :timeind t)
- ;; check for text ind column
- (if (> (length
- (delq 0 (mapcar
- (lambda (el)
- (if (string-match org-table-number-regexp el)
- 0 1))
- (mapcar (lambda (row) (nth ind row)) table)))) 0)
- (plist-put params :textind t)))))
+ ;; check for text ind column
+ (if (> (length
+ (delq 0 (mapcar
+ (lambda (el)
+ (if (string-match org-table-number-regexp el)
+ 0 1))
+ (mapcar (lambda (row) (nth ind row)) table)))) 0)
+ (plist-put params :textind t)))))
;; write script
(with-temp-buffer
(if (plist-get params :script) ;; user script
;; Author: David O'Toole <dto@gnu.org>
;; Maintainer: Bastien Guerry <bzg AT altern DOT org>
;; Keywords: hypermedia, outlines, wp
-;; Version: 6.15a
+;; Version: 6.15d
;; This file is part of GNU Emacs.
;;
;; (setq org-publish-project-alist
;; (list
;; '("org" . (:base-directory "~/org/"
-;; :base-extension "org"
-;; :publishing-directory "~/public_html"
-;; :with-section-numbers nil
-;; :table-of-contents nil
-;; :recursive t
-;; :style "<link rel="stylesheet" href=\"../other/mystyle.css\" type=\"text/css\">")))
+;; :base-extension "org"
+;; :publishing-directory "~/public_html"
+;; :with-section-numbers nil
+;; :table-of-contents nil
+;; :recursive t
+;; :style "<link rel="stylesheet" href=\"../other/mystyle.css\" type=\"text/css\">")))
;;;; More complex example configuration:
;; (setq org-publish-project-alist
;; (list
;; '("orgfiles" :base-directory "~/org/"
-;; :base-extension "org"
-;; :publishing-directory "/ssh:user@host:~/html/notebook/"
-;; :publishing-function org-publish-org-to-html
-;; :exclude "PrivatePage.org" ;; regexp
-;; :headline-levels 3
-;; :with-section-numbers nil
-;; :table-of-contents nil
-;; :style "<link rel="stylesheet" href=\"../other/mystyle.css\" type=\"text/css\">"
-;; :auto-preamble t
-;; :auto-postamble nil)
-;; ("images" :base-directory "~/images/"
-;; :base-extension "jpg\\|gif\\|png"
-;; :publishing-directory "/ssh:user@host:~/html/images/"
-;; :publishing-function org-publish-attachment)
-;; ("other" :base-directory "~/other/"
-;; :base-extension "css"
-;; :publishing-directory "/ssh:user@host:~/html/other/"
-;; :publishing-function org-publish-attachment)
+;; :base-extension "org"
+;; :publishing-directory "/ssh:user@host:~/html/notebook/"
+;; :publishing-function org-publish-org-to-html
+;; :exclude "PrivatePage.org" ;; regexp
+;; :headline-levels 3
+;; :with-section-numbers nil
+;; :table-of-contents nil
+;; :style "<link rel="stylesheet" href=\"../other/mystyle.css\" type=\"text/css\">"
+;; :auto-preamble t
+;; :auto-postamble nil)
+;; ("images" :base-directory "~/images/"
+;; :base-extension "jpg\\|gif\\|png"
+;; :publishing-directory "/ssh:user@host:~/html/images/"
+;; :publishing-function org-publish-attachment)
+;; ("other" :base-directory "~/other/"
+;; :base-extension "css"
+;; :publishing-directory "/ssh:user@host:~/html/other/"
+;; :publishing-function org-publish-attachment)
;; ("website" :components ("orgfiles" "images" "other"))))
;; For more information, see the documentation for the variable
(defun org-publish-timestamp-filename (filename)
"Return path to timestamp file for filename FILENAME."
(concat (file-name-as-directory org-publish-timestamp-directory)
- "X" (if (fboundp 'sha1) (sha1 filename) (md5 filename))))
+ "X" (if (fboundp 'sha1) (sha1 filename) (md5 filename))))
(defun org-publish-needed-p (filename)
"Return `t' if FILENAME should be published."
;; Emacs 21 doesn't have `set-file-times'
(if (and (fboundp 'set-file-times)
(not newly-created-timestamp))
- (set-file-times timestamp-file)
+ (set-file-times timestamp-file)
(call-process "touch" nil 0 nil timestamp-file))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
non-nil, restrict this list to the files matching the regexp
MATCH. If SKIP-FILE is non-nil, skip file matching the regexp
SKIP-FILE. If SKIP-DIR is non-nil, don't check directories
-matching the regexp SKIP-DIR when recursiing through BASE-DIR."
+matching the regexp SKIP-DIR when recursing through BASE-DIR."
(mapc (lambda (f)
(let ((fd-p (file-directory-p f))
(fnd (file-name-nondirectory f)))
(let* ((project-plist (cdr project))
(base-dir (file-name-as-directory
(plist-get project-plist :base-directory)))
- (include-list (plist-get project-plist :include))
- (recurse (plist-get project-plist :recursive))
- (extension (or (plist-get project-plist :base-extension) "org"))
- (match (concat "^[^\\.].*\\.\\(" extension "\\)$")))
+ (include-list (plist-get project-plist :include))
+ (recurse (plist-get project-plist :recursive))
+ (extension (or (plist-get project-plist :base-extension) "org"))
+ (match (concat "^[^\\.].*\\.\\(" extension "\\)$")))
(setq org-publish-temp-files nil)
(org-publish-get-base-files-1 base-dir recurse match
;; FIXME distinguish exclude regexp
(defun org-publish-get-project-from-filename (filename)
"Return the project FILENAME belongs."
(let* ((project-name (cdr (assoc (expand-file-name filename)
- org-publish-files-alist))))
+ org-publish-files-alist))))
(dolist (prj org-publish-project-alist)
(if (member project-name (plist-get (cdr prj) :components))
- (setq project-name (car prj))))
+ (setq project-name (car prj))))
(assoc project-name org-publish-project-alist)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;; Commentary:
;; This file contains the system to take fast notes with Org-mode.
-;; This system is used together with John Wiegleys `remember.el'.
+;; This system is used together with John Wiegley's `remember.el'.
;;; Code:
"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 vaues are:
+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.
(mapcar (lambda(x) (if (not (nth 5 x)) x))
org-remember-templates)
pre-selected-templates))
- ;; Then unconditionnally add template for any contexts
+ ;; Then unconditionally add template for any contexts
(pre-selected-templates2
(append (mapcar (lambda(x) (if (eq (nth 5 x) t) x))
org-remember-templates)
(cddr (assoc char templates)))))
(defun org-get-x-clipboard (value)
- "Get the value of the x clibboard, compatible with XEmacs, and GNU Emacs 21."
+ "Get the value of the x clipboard, compatible with XEmacs, and GNU Emacs 21."
(if (eq window-system 'x)
(let ((x (org-get-x-clipboard-compat value)))
(if x (org-no-properties x)))))
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 C-c C-c'),
-the entry is fild as a subentry of the entry where the clock is
+the entry is filed as a subentry of the entry where the clock is
currently running.
When `C-u' 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 (smilar to inserting \"%&\" into the tempate).
+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
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;
;;; Commentary:
-;; This file contains the table editor and spreadsheed for Org-mode.
+;; This file contains the table editor and spreadsheet for Org-mode.
;; Watch out: Here we are talking about two different kind of tables.
;; Most of the code is for the tables created with the Org-mode table editor.
:group 'org-table)
(defcustom org-table-use-standard-references t
- "Should org-mode work with table refrences like B3 instead of @3$2?
+ "Should org-mode work with table references like B3 instead of @3$2?
Possible values are:
nil never use them
from accept as input, do not present for editing
nil When nil, the command tries to be smart and figure out the
separator in the following way:
- when each line contains a TAB, assume TAB-separated material
- - when each line contains a comme, assume CSV material
+ - when each line contains a comma, assume CSV material
- else, assume one or more SPACE characters as separator."
(interactive "rP")
(let* ((beg (min beg0 end0))
(defun org-table-current-dline ()
"Find out what table data line we are in.
-Only datalins count for this."
+Only datalines count for this."
(interactive)
(if (interactive-p) (org-table-check-inside-data-field))
(save-excursion
(cond
((and (string-match "0" s)
(string-match "\\`[-+ \t0.edED]+\\'" s)) 0)
- ((string-match "\\`[ \t]+\\'" s) nil)
+ ((string-match "\\`[ \t]+\\'" s) nil)
((string-match "\\`\\([0-9]+\\):\\([0-9]+\\)\\(:\\([0-9]+\\)\\)?\\'" s)
(let ((h (string-to-number (or (match-string 1 s) "0")))
(m (string-to-number (or (match-string 2 s) "0")))
(s (string-to-number (or (match-string 4 s) "0"))))
(if (boundp 'org-timecnt) (setq org-timecnt (1+ org-timecnt)))
(* 1.0 (+ h (/ m 60.0) (/ s 3600.0)))))
- ((equal n 0) nil)
+ ((equal n 0) nil)
(t n))))
(defun org-table-current-field-formula (&optional key noerror)
eq (match-string 3 string)
eq-alist (cons (cons scol eq) eq-alist))
(if (member scol seen)
- (if noerror
- (progn
- (message "Double definition `$%s=' in TBLFM line, please fix by hand" scol)
- (ding)
- (sit-for 2))
- (error "Double definition `$%s=' in TBLFM line, please fix by hand" scol))
+ (if noerror
+ (progn
+ (message "Double definition `$%s=' in TBLFM line, please fix by hand" scol)
+ (ding)
+ (sit-for 2))
+ (error "Double definition `$%s=' in TBLFM line, please fix by hand" scol))
(push scol seen))))))
(nreverse eq-alist)))
prop value)))
(defun org-table-get-range (desc &optional tbeg col highlight)
- "Get a calc vector from a column, accorting to descriptor DESC.
+ "Get a calc vector from a column, according to descriptor DESC.
Optional arguments TBEG and COL can give the beginning of the table and
the current column, to avoid unnecessary parsing.
HIGHLIGHT means, just highlight the range."
(org-defkey map "\C-c\C-s" 'org-table-fedit-finish)
(org-defkey map "\C-c\C-c" 'org-table-fedit-finish)
(org-defkey map "\C-c\C-q" 'org-table-fedit-abort)
- (org-defkey map "\C-c?" 'org-table-show-reference)
+ (org-defkey map "\C-c?" 'org-table-show-reference)
(org-defkey map [(meta shift up)] 'org-table-fedit-line-up)
(org-defkey map [(meta shift down)] 'org-table-fedit-line-down)
(org-defkey map [(shift up)] 'org-table-fedit-ref-up)
(org-defkey map [(meta down)] 'org-table-fedit-scroll)
(org-defkey map [(meta tab)] 'lisp-complete-symbol)
(org-defkey map "\M-\C-i" 'lisp-complete-symbol)
- (org-defkey map [(tab)] 'org-table-fedit-lisp-indent)
- (org-defkey map "\C-i" 'org-table-fedit-lisp-indent)
+ (org-defkey map [(tab)] 'org-table-fedit-lisp-indent)
+ (org-defkey map "\C-i" 'org-table-fedit-lisp-indent)
(org-defkey map "\C-c\C-r" 'org-table-fedit-toggle-ref-type)
(org-defkey map "\C-c}" 'org-table-fedit-toggle-coordinates)
map))
(org-table-get-specials)
(let ((key (org-table-current-field-formula 'key 'noerror))
(eql (sort (org-table-get-stored-formulas 'noerror)
- 'org-table-formula-less-p))
+ 'org-table-formula-less-p))
(pos (move-marker (make-marker) (point)))
(startline 1)
(wc (current-window-configuration))
s))
(defun org-table-fedit-convert-buffer (function)
- "Convert all references in this buffer, using FUNTION."
+ "Convert all references in this buffer, using FUNCTION."
(let ((line (org-current-line)))
(goto-char (point-min))
(while (not (eobp))
(t (error "Cannot shift reference"))))))
(defun org-table-fedit-toggle-coordinates ()
- "Toggle the display of coordinates in the refrenced table."
+ "Toggle the display of coordinates in the referenced table."
(interactive)
(let ((pos (marker-position org-pos)))
(with-current-buffer (marker-buffer org-pos)
(org-table-remove-rectangle-highlight)
(catch 'exit
(let ((pos (if local (point) org-pos))
- (face2 'highlight)
- (org-inhibit-highlight-removal t)
+ (face2 'highlight)
+ (org-inhibit-highlight-removal t)
(win (selected-window))
(org-show-positions nil)
var name e what match dest)
(t (error "Undefined name $%s" var)))))
(goto-char pos)
(when (and org-show-positions
- (not (memq this-command '(org-table-fedit-scroll
- org-table-fedit-scroll-down))))
+ (not (memq this-command '(org-table-fedit-scroll
+ org-table-fedit-scroll-down))))
(push pos org-show-positions)
(push org-table-current-begin-pos org-show-positions)
(let ((min (apply 'min org-show-positions))
(max (apply 'max org-show-positions)))
- (goto-char min) (recenter 0)
- (goto-char max)
- (or (pos-visible-in-window-p max) (recenter -1))))
+ (goto-char min) (recenter 0)
+ (goto-char max)
+ (or (pos-visible-in-window-p max) (recenter -1))))
(select-window win))))
(defun org-table-force-dataline ()
(org-table-fedit-move 'next-line))
(defun org-table-fedit-move (command)
- "Move the cursor in the window shoinw the table.
+ "Move the cursor in the window showing the table.
Use COMMAND to do the motion, repeat if necessary to end up in a data line."
(let ((org-table-allow-automatic-line-recalculation nil)
(pos org-pos) (win (selected-window)) p)
(setq org-table-rectangle-overlays nil)))
(defvar org-table-coordinate-overlays nil
- "Collects the cooordinate grid overlays, so that they can be removed.")
+ "Collects the coordinate grid overlays, so that they can be removed.")
(make-variable-buffer-local 'org-table-coordinate-overlays)
(defun org-table-overlay-coordinates ()
(bindings
(list
'([(meta shift left)] org-table-delete-column)
- '([(meta left)] org-table-move-column-left)
+ '([(meta left)] org-table-move-column-left)
'([(meta right)] org-table-move-column-right)
'([(meta shift right)] org-table-insert-column)
'([(meta shift up)] org-table-kill-row)
'([(meta shift down)] org-table-insert-row)
- '([(meta up)] org-table-move-row-up)
- '([(meta down)] org-table-move-row-down)
- '("\C-c\C-w" org-table-cut-region)
- '("\C-c\M-w" org-table-copy-region)
- '("\C-c\C-y" org-table-paste-rectangle)
- '("\C-c-" org-table-insert-hline)
- '("\C-c}" org-table-toggle-coordinate-overlays)
- '("\C-c{" org-table-toggle-formula-debugger)
- '("\C-m" org-table-next-row)
- '([(shift return)] org-table-copy-down)
- '("\C-c?" org-table-field-info)
- '("\C-c " org-table-blank-field)
- '("\C-c+" org-table-sum)
- '("\C-c=" org-table-eval-formula)
- '("\C-c'" org-table-edit-formulas)
- '("\C-c`" org-table-edit-field)
- '("\C-c*" org-table-recalculate)
- '("\C-c^" org-table-sort-lines)
+ '([(meta up)] org-table-move-row-up)
+ '([(meta down)] org-table-move-row-down)
+ '("\C-c\C-w" org-table-cut-region)
+ '("\C-c\M-w" org-table-copy-region)
+ '("\C-c\C-y" org-table-paste-rectangle)
+ '("\C-c-" org-table-insert-hline)
+ '("\C-c}" org-table-toggle-coordinate-overlays)
+ '("\C-c{" org-table-toggle-formula-debugger)
+ '("\C-m" org-table-next-row)
+ '([(shift return)] org-table-copy-down)
+ '("\C-c?" org-table-field-info)
+ '("\C-c " org-table-blank-field)
+ '("\C-c+" org-table-sum)
+ '("\C-c=" org-table-eval-formula)
+ '("\C-c'" org-table-edit-formulas)
+ '("\C-c`" org-table-edit-field)
+ '("\C-c*" org-table-recalculate)
+ '("\C-c^" org-table-sort-lines)
'([(control ?#)] org-table-rotate-recalc-marks)))
elt key fun cmd)
(while (setq elt (pop bindings))
lines)))
(defun orgtbl-send-table (&optional maybe)
- "Send a tranformed version of this table to the receiver position.
+ "Send a transformed version of this table to the receiver position.
With argument MAYBE, fail quietly if no transformation is defined for
this table."
(interactive)
(orgtbl-apply-fmt efmt (match-string 1 f)
(match-string 2 f))
f)))
- (orgtbl-apply-fmt (or (orgtbl-get-fmt *orgtbl-fmt* i)
- *orgtbl-default-fmt*)
- f)))
+ (orgtbl-apply-fmt (or (orgtbl-get-fmt *orgtbl-fmt* i)
+ *orgtbl-default-fmt*)
+ f)))
line)))
(push (if *orgtbl-lfmt*
(orgtbl-apply-fmt *orgtbl-lfmt* line)
(unless splicep
(when (plist-member params :tend)
- (let ((tend (orgtbl-eval-str (plist-get params :tend))))
- (if tend (push tend *orgtbl-rtn*)))))
+ (let ((tend (orgtbl-eval-str (plist-get params :tend))))
+ (if tend (push tend *orgtbl-rtn*)))))
(mapconcat 'identity (nreverse (if remove-nil-linesp
(remq nil *orgtbl-rtn*)
provide ORGTBL directives for the generated table."
(let* ((params2
(list
- :tstart nil :tend nil
- :hline "|---"
- :sep " | "
- :lstart "| "
- :lend " |"))
+ :tstart nil :tend nil
+ :hline "|---"
+ :sep " | "
+ :lstart "| "
+ :lend " |"))
(params (org-combine-plists params2 params)))
(orgtbl-to-generic table params)))
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;;###autoload
(defun org-timer-item (&optional arg)
- "Insert a description-type item with the curren timer value."
+ "Insert a description-type item with the current timer value."
(interactive "P")
(let ((ind 0))
(save-excursion
(if (match-end 2) (string-to-number (match-string 2 hms)) 0)
(string-to-number (match-string 3 hms)))
t t hms)
- (error "Canot parse HMS string \"%s\"" hms)))
+ (error "Cannot parse HMS string \"%s\"" hms)))
(defun org-timer-hms-to-secs (hms)
"Convert h:mm:ss string to an integer time.
(defun org-timer-secs-to-hms (s)
"Convert integer S into h:mm:ss.
-If the integer is negative, the strig will start with \"-\"."
+If the integer is negative, the string will start with \"-\"."
(let (sign m h)
(setq sign (if (< s 0) "-" "")
s (abs s)
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; Author: Andy Stewart <lazycat dot manatee at gmail dot com>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
-;;; Acknowledgments:
+;;; Acknowledgements:
;; Richard Riley <rileyrgdev at googlemail dot com>
;;
-;; The idea that transfomring the HTML content with org-mode style is
-;; proposed by Richard, i'm just code it.
+;; The idea of transforming the HTML content with org-mode style is
+;; proposed by Richard, I'm just coding it.
;;
(require 'org)
(org-make-link-string
link-location link-title))))
(goto-char temp-position) ; reset point before jump next anchor
- (setq out-bound t) ; for break out `while' loop
+ (setq out-bound t) ; for break out `while' loop
))
- ;; add the rest until en end of the region to be copied
+ ;; add the rest until end of the region to be copied
(if (< (point) transform-end)
(setq return-content
(concat return-content
(equal (point) (org-w3m-get-next-link-start))))
(defun org-w3m-no-prev-link-p ()
- "Return t if no prevoius link after cursor.
+ "Return t if no previous link after cursor.
Otherwise, return nil."
(save-excursion
(equal (point) (org-w3m-get-prev-link-start))))
;; Author: Tokuya Kameshima <kames at fa2 dot so-net dot ne dot jp>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;; Author: Carsten Dominik <carsten at orgmode dot org>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
-;; Version: 6.15a
+;; Version: 6.15d
;;
;; This file is part of GNU Emacs.
;;
;;; Version
-(defconst org-version "6.15a"
+(defconst org-version "6.15d"
"The version number of the file org.el.")
(defun org-version (&optional here)
(const :tag " mouse: Additional mouse support" org-mouse)
(const :tag "C annotate-file: Annotate a file with org syntax" org-annotate-file)
- (const :tag "C annotation-helper: Call Remeber directly from Browser" org-annotation-helper)
+ (const :tag "C annotation-helper: Call Remember directly from Browser" org-annotation-helper)
(const :tag "C bookmark: Org links to bookmarks" org-bookmark)
(const :tag "C browser-url: Store link, directly from Browser" org-browser-url)
(const :tag "C depend: TODO dependencies for Org-mode" org-depend)
(defcustom org-ellipsis nil
"The ellipsis to use in the Org-mode outline.
When nil, just use the standard three dots. When a string, use that instead,
-When a face, use the standart 3 dots, but with the specified face.
+When a face, use the standard 3 dots, but with the specified face.
The change affects only Org-mode (which will then use its own display table).
Changing this requires executing `M-x org-mode' in a buffer to become
effective."
(defcustom org-descriptive-links t
"Non-nil means, hide link part and only show description of bracket links.
-Bracket links are like [[link][descritpion]]. This variable sets the initial
+Bracket links are like [[link][description]]. This variable sets the initial
state in new org-mode buffers. The setting can then be toggled on a
per-buffer basis from the Org->Hyperlinks menu."
:group 'org-link
be a small gain when turning off unused link types. The types are:
bracket The recommended [[link][description]] or [[link]] links with hiding.
-angular Links in angular brackes that may contain whitespace like
+angular Links in angular brackets that may contain whitespace like
<bbdb:Carsten Dominik>.
plain Plain links in normal text, no whitespace, like http://google.com.
radio Text that is matched by a radio target, see manual for details.
(defcustom org-email-link-description-format "Email %c: %.30s"
"Format of the description part of a link to an email or usenet message.
-The following %-excapes will be replaced by corresponding information:
+The following %-escapes will be replaced by corresponding information:
%F full \"From\" field
%f name, taken from \"From\" field, address if no name
%T full \"To\" field
%t first name in \"To\" field, address if no name
-%c correspondent. Unually \"from NAME\", but if you sent it yourself, it
+%c correspondent. Usually \"from NAME\", but if you sent it yourself, it
will be \"to NAME\". See also the variable `org-from-is-user-regexp'.
%s subject
%m message-id.
(when (and user-full-name (not (string= user-full-name "")))
(setq r2 (concat "\\<" (regexp-quote user-full-name) "\\>")))
(if (and r1 r2) (concat r1 "\\|" r2) (or r1 r2)))
- "Regexp mached against the \"From:\" header of an email or usenet message.
+ "Regexp matched against the \"From:\" header of an email or usenet message.
It should match if the message is from the user him/herself."
:group 'org-link-store
:type 'regexp)
The function must accept two parameters, a TYPE containing the link
protocol name like \"rmail\" or \"gnus\" as a string, and the linked path,
which is everything after the link protocol. It should return a cons
-with possibly modifed values of type and path.
+with possibly modified values of type and path.
Org contains a function for this, so if you set this variable to
`org-translate-link-from-planner', you should be able follow many
links created by planner."
"Number of different positions to be recorded in the ring
Changing this requires a restart of Emacs to work correctly."
:group 'org-link-follow
- :type 'interger)
+ :type 'integer)
(defcustom org-link-frame-setup
'((vm . vm-visit-folder-other-frame)
`remote' Matches a remote file, accessible through tramp or efs.
Remote files most likely should be visited through Emacs
because external applications cannot handle such paths.
-`auto-mode' Matches files that are mached by any entry in `auto-mode-alist',
+`auto-mode' Matches files that are matched by any entry in `auto-mode-alist',
so all files Emacs knows how to handle. Using this with
command `emacs' will open most files in Emacs. Beware that this
- will also open html files insite Emacs, unless you add
+ will also open html files inside Emacs, unless you add
(\"html\" . default) to the list as well.
t Default for files not matched by any of the other options.
`system' The system command to open files, like `open' on Windows
`default' Use the default application for this file type, which is the
association for t in the list, most likely in the system-specific
part.
- This can be used to overrule an unwanted seting in the
+ This can be used to overrule an unwanted setting in the
system-specific variable.
`system' Use the system command for opening files, like \"open\".
This command is specified by the entry whose car is `system'.
(defcustom org-goto-interface 'outline
"The default interface to be used for `org-goto'.
-Allowed vaues are:
+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.
so WAIT(w@), WAIT(w/@) and WAIT(@/@) are all valid.
For backward compatibility, this variable may also be just a list
-of keywords - in this case the interptetation (sequence or type) will be
+of keywords - in this case the interpretation (sequence or type) will be
taken from the (otherwise obsolete) variable `org-todo-interpretation'."
:group 'org-todo
:group 'org-keywords
This variable is semi-obsolete and probably should always be true. It
is better to limit inheritance to certain tags using the variables
-`org-use-tag-inheritanc'e and `org-tags-exclude-from-inheritance'."
+`org-use-tag-inheritance' and `org-tags-exclude-from-inheritance'."
:group 'org-tags
:type 'boolean)
For example, it can be used to cut out a certain part from a time stamp.
The function must take 2 arguments:
-column-title The tite of the column (*not* the property name)
+column-title The title of the column (*not* the property name)
value The value that should be modified.
The function should return the value that should be displayed,
;;;; Define the Org-mode
(if (and (not (keymapp outline-mode-map)) (featurep 'allout))
- (error "Conflict with outdated version of allout.el. Load org.el before allout.el, or ugrade to newer allout, for example by switching to Emacs 22."))
+ (error "Conflict with outdated version of allout.el. Load org.el before allout.el, or upgrade to newer allout, for example by switching to Emacs 22."))
;; We use a before-change function to check if a table might need
(defvar org-l nil)
(defvar org-f nil)
(defun org-get-level-face (n)
- "Get the right face for match N in font-lock matching of healdines."
+ "Get the right face for match N in font-lock matching of headlines."
(setq org-l (- (match-end 2) (match-beginning 1) 1))
(if org-odd-levels-only (setq org-l (1+ (/ org-l 2))))
(setq org-f (nth (% (1- org-l) org-n-level-faces) org-level-faces))
(org-cycle-show-empty-lines 'all)))))
(defun org-overview ()
- "Switch to overview mode, shoing only top-level headlines.
+ "Switch to overview mode, showing only top-level headlines.
Really, this shows all headlines with level equal or greater than the level
of the first headline in the buffer. This is important, because if the
first headline is not level one, then (hide-sublevels 1) gives confusing
The region to be covered depends on STATE when called through
`org-cycle-hook'. Lisp program can use t for STATE to get the
entire buffer covered. Note that an empty line is only shown if there
-are at least `org-cycle-separator-lines' empty lines before the headeline."
+are at least `org-cycle-separator-lines' empty lines before the headline."
(when (> org-cycle-separator-lines 0)
(save-excursion
(let* ((n org-cycle-separator-lines)
(defun org-edit-fixed-width-region ()
"Edit the fixed-width ascii drawing at point.
-This must be a region where each line starts with ca colon followed by
+This must be a region where each line starts with a colon followed by
a space character.
An indirect buffer is created, and that buffer is then narrowed to the
example at point and switched to artist-mode. When done,
C-c - Cycle list bullet
TAB Cycle item visibility
M-RET Insert new heading/item
-S-M-RET Insert new TODO heading / Chekbox item
+S-M-RET Insert new TODO heading / Checkbox item
C-c C-c Set tags / toggle checkbox"
nil " OrgStruct" nil
(org-load-modules-maybe)
It should be a function accepting three arguments:
path the path of the link, the text after the prefix (like \"http:\")
- desc the description of the link, if any, nil if there was no descripton
+ desc the description of the link, if any, nil if there was no description
format the export format, a symbol like `html' or `latex'.
The function may use the FORMAT information to return different values
(setq link (condition-case nil
(org-id-store-link)
(error
- ;; probably before first headling, link to file only
+ ;; probably before first headline, link to file only
(concat "file:"
(abbreviate-file-name buffer-file-name))))))
(t
(defun org-get-outline-path (&optional fastp level heading)
"Return the outline path to the current entry, as a list."
- (if (> level 19) (error "Outline path failure, more than 19 levels."))
(if fastp
(progn
+ (if (> level 19)
+ (error "Outline path failure, more than 19 levels."))
(loop for i from level upto 19 do
(aset org-olpa i nil))
(prog1
"Matches the startline of a dynamic block, with parameters.")
(defconst org-dblock-end-re "^#\\+END\\([: \t\r\n]\\|$\\)"
- "Matches the end of a dyhamic block.")
+ "Matches the end of a dynamic block.")
(defun org-create-dblock (plist)
"Create a dynamic block section, with parameters taken from PLIST.
-PLIST must containe a :name entry which is used as name of the block."
+PLIST must contain a :name entry which is used as name of the block."
(unless (bolp) (newline))
(let ((name (plist-get plist :name)))
(insert "#+BEGIN: " name)
(defun org-beginning-of-dblock ()
"Find the beginning of the dynamic block at point.
-Error if there is no scuh block at point."
+Error if there is no such block at point."
(let ((pos (point))
beg)
(end-of-line 1)
This is a list of abbreviation keys and values. The value gets inserted
it you type @samp{.} followed by the key and then the completion key,
usually `M-TAB'. %file will be replaced by a file name after prompting
-for the file uning completion.
+for the file using completion.
There are two templates for each key, the first uses the original Org syntax,
the second uses Emacs Muse-like syntax tags. These Muse-like tags become
the default when the /org-mtags.el/ module has been loaded. See also the
If the last change removed the TODO tag or switched to DONE, then
this is nil.")
-(defvar org-setting-tags nil) ; dynamically skiped
+(defvar org-setting-tags nil) ; dynamically skipped
(defun org-parse-local-options (string var)
"Parse STRING for startup setting relevant for variable VAR."
(defun org-make-tags-matcher (match)
"Create the TAGS//TODO matcher form for the selection string MATCH."
;; todo-only is scoped dynamically into this function, and the function
- ;; may change it it the matcher asksk for it.
+ ;; may change it if the matcher asks for it.
(unless match
;; Get a new match request, with completion
(let ((org-last-tags-completion-table
(append '(0 0 0) (nthcdr 3 (decode-time))))))
(defun org-matcher-time (s)
- "Interprete a time comparison value."
+ "Interpret a time comparison value."
(save-match-data
(cond
((string= s "<now>") (float-time))
(setq list (mapcar (lambda (x) (string-match re x)) list))
(delq nil list))
-(defvar org-add-colon-after-tag-completion nil) ;; dynamically skoped param
+(defvar org-add-colon-after-tag-completion nil) ;; dynamically scoped param
(defvar org-tags-overlay (org-make-overlay 1 1))
(org-detach-overlay org-tags-overlay)
))
(defun org-fast-tag-insert (kwd tags face &optional end)
- "Insert KDW, and the TAGS, the latter with face FACE. Also inser END."
+ "Insert KDW, and the TAGS, the latter with face FACE. Also insert END."
(insert (format "%-12s" (concat kwd ":"))
(org-add-props (mapconcat 'identity tags " ") nil 'face face)
(or end "")))
s)
(defvar org-entry-property-inherited-from (make-marker)
- "Marker pointing to the entry from where a proerty was inherited.
+ "Marker pointing to the entry from where a property was inherited.
Each call to `org-entry-get-with-inheritance' will set this marker to the
-location of the entry where the inheriance search matched. If there was
+location of the entry where the inheritance search matched. If there was
no match, the marker will point nowhere.
Note that also `org-entry-get' calls this function, if the INHERIT flag
is set.")
(defun org-buffer-property-keys (&optional include-specials include-defaults include-columns)
"Get all property keys in the current buffer.
-With INCLUDE-SPECIALS, also list the special properties that relect things
+With INCLUDE-SPECIALS, also list the special properties that reflect things
like tags and TODO state.
With INCLUDE-DEFAULTS, also include properties that has special meaning
internally: ARCHIVE, CATEGORY, SUMMARY, DESCRIPTION, LOCATION, and LOGGING.
"In the current entry, set PROPERTY to VALUE.
When called interactively, this will prompt for a property name, offering
completion on existing and default properties. And then it will prompt
-for a value, offering competion either on allowed values (via an inherited
+for a value, offering completion either on allowed values (via an inherited
xxx_ALL property) or on existing values in other instances of this property
in the current file."
(interactive
(defun org-compute-property-at-point ()
"Compute the property at point.
This looks for an enclosing column format, extracts the operator and
-then applies it to the proerty in the column format's scope."
+then applies it to the property in the column format's scope."
(interactive)
(unless (org-at-property-p)
(error "Not at a property"))
(defvar defdecode)
(defvar with-time)
(defun org-read-date-display ()
- "Display the currrent date prompt interpretation in the minibuffer."
+ "Display the current date prompt interpretation in the minibuffer."
(when org-read-date-display-live
(when org-read-date-overlay
(org-delete-overlay org-read-date-overlay))
(org-overlay-display org-read-date-overlay txt 'secondary-selection))))
(defun org-read-date-analyze (ans def defdecode)
- "Analyze the combined answer of the date prompt."
+ "Analyse the combined answer of the date prompt."
;; FIXME: cleanup and comment
(let (delta deltan deltaw deltadef year month day
hour minute second wday pm h2 m2 tl wday1
deltadef (nth 2 delta)))
;; Check if there is an iso week date in there
- ;; If yes, sore the info and ostpone interpreting it until the rest
+ ;; If yes, sore the info and postpone interpreting it until the rest
;; of the parsing is done
(when (string-match "\\<\\(?:\\([0-9]+\\)-\\)?[wW]\\([0-9]\\{1,2\\}\\)\\(?:-\\([0-6]\\)\\)?\\([ \t]\\|$\\)" ans)
(setq iso-year (if (match-end 1) (org-small-year-to-year (string-to-number (match-string 1 ans))))
"Find the date closest to CURRENT that is consistent with START and CHANGE.
When PREFER is `past' return a date that is either CURRENT or past.
When PREFER is `future', return a date that is either CURRENT or future.
-When SHOW-ALL is nil, only return the current occurence of a time stamp."
+When SHOW-ALL is nil, only return the current occurrence of a time stamp."
;; Make the proper lists from the dates
(catch 'exit
(let ((a1 '(("d" . day) ("w" . week) ("m" . month) ("y" . year)))
(customize-variable 'org-agenda-files)))
(defun org-store-new-agenda-file-list (list)
- "Set new value for the agenda file list and save it correcly."
+ "Set new value for the agenda file list and save it correctly."
(if (stringp org-agenda-files)
(let ((f org-agenda-files) b)
(while (setq b (find-buffer-visiting f)) (kill-buffer b))
"Always return t in org-mode buffers.
This is because we want to insert math symbols without dollars even outside
the LaTeX math segments. If Orgmode thinks that point is actually inside
-en embedded LaTeX fragement, let texmathp do its job.
+an embedded LaTeX fragment, let texmathp do its job.
\\[org-cdlatex-mode-map]"
(interactive)
(let (p)
;; Make pabbrev-mode expand after org-mode commands
(put 'org-self-insert-command 'pabbrev-expand-after-command t)
-(put 'orgybl-self-insert-command 'pabbrev-expand-after-command t)
+(put 'orgtbl-self-insert-command 'pabbrev-expand-after-command t)
;; How to do this: Measure non-white length of current string
;; If equal to column width, we should realign.
(defun org-fix-indentation (line ind)
"Fix indentation in LINE.
IND is a cons cell with target and minimum indentation.
-If the current indenation in LINE is smaller than the minimum,
+If the current indentation in LINE is smaller than the minimum,
leave it alone. If it is larger than ind, set it to the target."
(let* ((l (org-remove-tabs line))
(i (org-get-indentation l))
list)
(defun org-back-over-empty-lines ()
- "Move backwards over witespace, to the beginning of the first empty line.
+ "Move backwards over whitespace, to the beginning of the first empty line.
Returns the number of empty lines passed."
(let ((pos (point)))
(skip-chars-backward " \t\n\r")
This command will look at the current kill and check if is a single
subtree, or a series of subtrees[1]. If it passes the test, and if the
cursor is at the beginning of a line or after the stars of a currently
-empty headline, then the yank is handeled specially. How exactly depends
+empty headline, then the yank is handled specially. How exactly depends
on the value of the following variables, both set by default.
org-yank-folded-subtrees
- When set, the subree(s) will be folded after insertion, but only
+ When set, the subtree(s) will be folded after insertion, but only
if doing so would now swallow text after the yanked text.
org-yank-adjusted-subtrees