+2012-10-26 Bastien Guerry <bzg@gnu.org>
+
+ * org.texi (Installation): Update the link to Org's ELPA. Also
+ don't mention org-install.el anymore as the replacement file
+ org-loaddefs.el is now loaded by org.el.
+
2012-10-25 Michael Albinus <michael.albinus@gmx.de>
* tramp.texi (Frequently Asked Questions): Mention
@b{Important:} @i{If you the version of Org that comes with Emacs or as a
XEmacs package, please skip this section and go directly to @ref{Activation}.
If you downloaded Org as an ELPA package, please read the instructions on the
-@uref{http://orgmode.org/elpa/, Org ELPA page}. To see what version of Org
+@uref{http://orgmode.org/elpa.html, Org ELPA page}. To see what version of Org
(if any) is part of your Emacs distribution, type @kbd{M-x org-version} (if
your Emacs distribution does not come with Org, this function will not be
defined).}
Installing Info files is system dependent, because of differences in the
@file{install-info} program. The Info documentation is installed together
with the rest of Org mode. If you don't install Org mode, it is possible to
-install the Info documentation separately (you need to have
+install the Info documentation seperately (you need to have
install-info@footnote{The output from install-info (if any) is system
dependent. In particular Debian and its derivatives use two different
versions of install-info and you may see the message:
make install-info
@end example
-Then add the following line to @file{.emacs}. It is needed so that
-Emacs can autoload functions that are located in files not immediately loaded
-when Org mode starts.
-@lisp
-(require 'org-install)
-@end lisp
-
Do not forget to activate Org as described in the following section.
@page
;; add latest org-mode to load path
(add-to-list 'load-path (expand-file-name "/path/to/org-mode/lisp"))
(add-to-list 'load-path (expand-file-name "/path/to/org-mode/contrib/lisp" t))
-
-;; activate org
-(require 'org-install)
@end example
If an error occurs, a backtrace can be very useful (see below on how to
extensions}). See also @ref{Conflicts}, for a discussion of the interaction
with @code{shift-selection-mode}. See also the variable
@code{org-treat-S-cursor-todo-selection-as-state-change}.
-@orgcmd{C-c / t,org-show-todo-key}
+@orgcmd{C-c / t,org-show-todo-tree}
@cindex sparse tree, for TODO
@vindex org-todo-keywords
View TODO items in a @emph{sparse tree} (@pxref{Sparse trees}). Folds the
@item C-c '
Edit the source code example at point in its native mode. This works by
switching to a temporary buffer with the source code. You need to exit by
-pressing @kbd{C-c '} again@footnote{Upon exit, lines starting with @samp{*}
-or @samp{#} will get a comma prepended, to keep them from being interpreted
-by Org as outline nodes or special comments. These commas will be stripped
-for editing with @kbd{C-c '}, and also for export.}. The edited version will
-then replace the old version in the Org buffer. Fixed-width regions
-(where each line starts with a colon followed by a space) will be edited
-using @code{artist-mode}@footnote{You may select a different-mode with the
-variable @code{org-edit-fixed-width-region-mode}.} to allow creating ASCII
-drawings easily. Using this command in an empty line will create a new
-fixed-width region.
+pressing @kbd{C-c '} again@footnote{Upon exit, lines starting with @samp{*},
+@samp{,*}, @samp{#+} and @samp{,#+} will get a comma prepended, to keep them
+from being interpreted by Org as outline nodes or special syntax. These
+commas will be stripped for editing with @kbd{C-c '}, and also for export.}.
+The edited version will then replace the old version in the Org buffer.
+Fixed-width regions (where each line starts with a colon followed by a space)
+will be edited using @code{artist-mode}@footnote{You may select
+a different-mode with the variable @code{org-edit-fixed-width-region-mode}.}
+to allow creating ASCII drawings easily. Using this command in an empty line
+will create a new fixed-width region.
@kindex C-c l
@item C-c l
Calling @code{org-store-link} while editing a source code example in a
#
DIR=`pwd`
FILES=""
-ORGINSTALL="~/src/org/lisp/org-install.el"
# wrap each argument in the code required to call tangle on it
for i in $@@; do
FILES="$FILES \"$i\""
done
-emacs -Q --batch -l $ORGINSTALL \
+emacs -Q --batch \
--eval "(progn
(add-to-list 'load-path (expand-file-name \"~/src/org/lisp/\"))
(add-to-list 'load-path (expand-file-name \"~/src/org/contrib/lisp/\" t))
opened the doors for many new ideas and features.
@item Jambunathan K
-Jambunathan contributed the ODT exporter, definitely a killer feature of
+Jambunathan contributed the ODT exporter, definitly a killer feature of
Org mode. He also contributed the new HTML exporter, which is another core
feature of Org. Here too, I knew I could rely on him to fix bugs in these
areas and to patiently explain the users what was the problems and solutions.
@item Achim Gratz
Achim rewrote the building process of Org, turning some @emph{ad hoc} tools
into a flexible and conceptually clean process. He patiently coped with the
-many hiccups that such a change can create for users.
+many hicups that such a change can create for users.
@item Nick Dokos
The Org mode mailing list would not be such a nice place without Nick, who
+2012-10-26 Nicolas Goaziou <n.goaziou@gmail.com>
+
+ * refcards/orgcard.tex: Fix keybindings about
+ `org-show-todo-tree'.
+
2012-10-23 Paul Eggert <eggert@cs.ucla.edu>
Fix outdated timestamp documentation in Elisp manual (bug#12706).
\metax{select next/previous state}{S-LEFT/RIGHT}
\metax{select next/previous set}{C-S-LEFT/RIGHT}
\key{toggle ORDERED property}{C-c C-x o}
-\key{view TODO items in a sparse tree}{C-c C-v}
-\key{view 3rd TODO keyword's sparse tree}{C-3 C-c C-v}
+\key{view TODO items in a sparse tree}{C-c / t}
+\key{view 3rd TODO keyword's sparse tree}{C-3 C-c / t}
\key{set the priority of the current item}{C-c , [ABC]}
\key{remove priority cookie from current item}{C-c , SPC}
\key{raise/lower priority of current item}{S-UP/DOWN\notetwo}
+2012-10-26 Achim Gratz <stromeko@stromeko.de>
+
+ * ob-ditaa.el: Needs to (require 'org-compat) for
+ org-find-library-dir.
+
+ * org.el: Remove utf-8 codepoints in docstrings, bytecode doesn't
+ work when loaded from compressed files.
+
+ * org-compat.el: Make sure that file-name-directory is getting a
+ stringp. This avoids a possible " (wrong-type-argument stringp
+ nil)" error when the library in question does not exist.
+
+ * org-odt.el: Replace arc-mode.el by arc-mode.
+
+ * org.el: Replace org-macs.el by org-macs.
+
+ * org-install.el: Provide an empty file that prints a warning
+ about an outdated configuration.
+
+2012-10-26 Bastien Guerry <bzg@gnu.org>
+
+ * org-latex.el (org-export-as-latex): Remove obsolete argument
+ `hidden'. Also fix the docstring: using 'string as the value
+ for `to-buffer' outputs a string with no LaTeX header.
+ (org-export-as-latex-batch)
+ (org-export-as-latex-to-buffer, org-export-region-as-latex)
+ (org-export-as-pdf): Don't use the obsoleted argument.
+
+ * ob-haskell.el (org-export-as-latex): Don't use the obsoleted
+ argument `hidden'.
+
+ * org.el (org-refile): Run within `with-demoted-errors' so
+ that a corrupted bookmark file does not stop the refile
+ process.
+
+ * org-capture.el (org-capture-bookmark-last-stored-position):
+ Ditto for the capture process.
+
+ * org-src.el (org-edit-src-exit): Fix bug when saving an empty
+ source buffer.
+
+ * org-lparse.el (org-lparse): Fix bug by returning the output
+ of `org-do-lparse'.
+
+ * org.el (org-refile-check-position): Throw an error when the
+ refile target is the current buffer and is not a file.
+ (org-agenda-file-to-front, org-remove-file): Throw an error
+ when the current buffer is not a file.
+ (org-check-agenda-file): Enhance the message.
+ (org-element-type): Autoload.
+ (org-element-context, org-element-paragraph-parser): Don't
+ declare as these two functions are not used in org.el.
+
+ * org-lparse.el (browse-url-file-url): Declare.
+
+ * org.el (org-refile-check-position): Fix typo in docstring.
+
+ * org-clock.el (org-clock-modeline-total): Make obsolete.
+ (org-clock-mode-line-total): Rename from
+ `org-clock-modeline-total'.
+ (org-clock-get-sum-start): Fix references to
+ `org-clock-modeline-total'.
+
+ * org-faces.el (org-agenda-filter-tags)
+ (org-agenda-filter-category, mode-line): Use the 'mode-line
+ face instead of the obsolete 'modeline.
+
+ * org-odt.el (org-odt-styles-dir): Try more directories.
+ Don't throw an error, just send a message.
+
+ * org-odt.el (org-odt-lib-dir, org-odt-data-dir)
+ (org-odt-schema-dir-list, org-odt-styles-dir-list): Delete.
+ (org-export-odt-schema-dir, org-odt-styles-dir): Infer the
+ correct directories without requiring other variables.
+
+ * org-fixup.el (org-make-org-version, org-make-autoloads):
+ Don't define `org-odt-data-dir' in org-version.el.
+
+ * org-loaddefs.el: New file.
+
+ * org.el ("org-loaddefs.el"): Don't throw an error if the file
+ cannot be fund.
+ (org-version): Use org-loaddefs.el instead of org-install.el.
+
+ * org.el: Don't dynamically autoload already autoloaded
+ functions.
+ (org-clock-update-time-maybe): Move to org-clock.el.
+
+ * org-exp.el (org-insert-export-options-template): Remove
+ autoload cookie.
+
+ * org-clock.el (org-resolve-clocks, org-clock-in)
+ (org-clock-out, org-clock-cancel, org-clock-goto)
+ (org-clock-sum, org-clock-display, org-clock-report)
+ (org-dblock-write:clocktable): Add autoload cookie.
+ (org-clock-update-time-maybe): Moved from org.el.
+
+ * org-beamer.el (org-beamer-sectioning, org-beamer-mode): Ditto.
+
+ * org-ascii.el (org-export-ascii-preprocess): Ditto.
+
+ * org-archive.el (org-archive-subtree)
+ (org-archive-to-archive-sibling, org-toggle-archive-tag): Add
+ autoload cookie.
+
+ * org-colview.el (org-columns, org-dblock-write:columnview)
+ (org-insert-columns-dblock, org-agenda-columns): Ditto.
+
+ * org-table.el (org-table-create-with-table.el)
+ (org-table-create-or-convert-from-region, org-table-create)
+ (org-table-convert-region, org-table-import)
+ (org-table-export, org-table-align)
+ (org-table-justify-field-maybe, org-table-next-field)
+ (org-table-previous-field, org-table-next-row)
+ (org-table-copy-down, org-table-field-info)
+ (org-table-current-dline, org-table-goto-column)
+ (org-table-insert-column, org-table-delete-column)
+ (org-table-move-column-right, org-table-move-column-left)
+ (org-table-move-column, org-table-move-row-down)
+ (org-table-move-row-up, org-table-move-row)
+ (org-table-insert-row, org-table-insert-hline)
+ (org-table-hline-and-move, org-table-kill-row)
+ (org-table-sort-lines, org-table-cut-region)
+ (org-table-copy-region, org-table-paste-rectangle)
+ (org-table-convert, org-table-wrap-region)
+ (org-table-edit-field, org-table-sum)
+ (org-table-get-stored-formulas)
+ (org-table-maybe-eval-formula)
+ (org-table-rotate-recalc-marks)
+ (org-table-maybe-recalculate-line, org-table-eval-formula)
+ (org-table-recalculate, org-table-iterate)
+ (org-table-edit-formulas)
+ (org-table-toggle-coordinate-overlays)
+ (org-table-toggle-formula-debugger, orgtbl-to-generic)
+ (orgtbl-to-tsv, orgtbl-to-csv, orgtbl-to-latex)
+ (orgtbl-to-html, orgtbl-to-texinfo, orgtbl-to-orgtbl): Ditto.
+
+ * org.el (turn-on-orgtbl): Moved here from org-table.el.
+ (org-clock-persistence-insinuate): Moved here from org-clock.el.
+ (org-update-all-dblocks, org-map-entries)
+ (org-require-autoloaded-modules, org-forward-element)
+ (org-backward-element, org-up-element)
+ (org-element-greater-elements, org-drag-element-backward)
+ (org-drag-element-forward, org-mark-element)
+ (org-narrow-to-element, org-transpose-element)
+ (org-unindent-buffer): Don't autoload.
+
+ * org-clock.el (org-clock-get-clocktable): Rename from
+ `org-get-clocktable'.
+ (org-clock-persistence-insinuate): Move to org.el.
+
+ * org-capture.el: Do no set `generated-autoload-file' locally.
+ Minor code clean up.
+
+ * org-agenda.el (org-agenda-list): Use
+ `org-clock-get-clocktable'. Do no set
+ `generated-autoload-file' locally.
+
+ * org-table.el (org-table-iterate-buffer-tables): Minor
+ reformatting.
+ (turn-on-orgtbl): Move to org.el.
+
+ * org-html.el (org-export-htmlize-generate-css): Don't autoload.
+
+ * org-timer.el (org-timer-pause-or-continue, org-timer-stop):
+ Ditto.
+
+ * ob-tangle.el (org-babel-tangle-lang-exts): Ditto.
+
+ * ob-lob.el (org-babel-lob-ingest): Ditto.
+
+ * org-id.el (org-id-copy)
+ (org-id-get-with-outline-path-completion)
+ (org-id-get-with-outline-drilling): Ditto.
+
+ * org-lparse.el (org-lparse-and-open, org-lparse-batch)
+ (org-lparse-to-buffer, org-replace-region-by)
+ (org-lparse-region): Ditto.
+
+ * org-mobile.el (org-mobile-create-sumo-agenda): Ditto.
+
+ * org.el (org-cycle): Fix misplaced autoload cookie.
+
+ * org-agenda.el (org-agenda-get-timestamps): Check if the item
+ is an habit when formatting it with `org-agenda-format-item'.
+ (org-agenda-get-blocks): Fix bug: don't assume the item is an
+ habit when formatting with `org-agenda-format-item'.
+
+ * org.el (org-calendar-agenda-action-key): Delete an option.
+ (org-mode-map): Delete its keybinding.
+ (org-agenda-action-marker, org-mark-entry-for-agenda-action):
+ Delete.
+
+ * org-agenda.el (org-agenda-diary-entry): Don't prevent from
+ being used outside of Org agendas, as it can be used in
+ calendar buffers too.
+
+2012-10-26 Caio Tiago Oliveira <asrail@gmail.com> (tiny change)
+
+ * ob-scala.el (org-babel-scala-wrapper-method): Use a Scala
+ block enclosing the submitted code.
+
+2012-10-26 Myles English <mylesenglish@gmail.com> (tiny change)
+
+ * org-clock.el (org-clock-in): Moved the call to
+ org-clock-in-prepare-hook until the task's properties
+ can be accessed.
+
+2012-10-26 Nicolas Goaziou <n.goaziou@gmail.com>
+
+ * org.el (org-auto-fill-function): Make sure `adaptive-fill-mode'
+ mode is nil when pre-computed `fill-prefix' is the empty string.
+ Otherwise filling functions from fill.el think it has to be computed
+ again and overwrite it.
+
+ * org.el: Make `org-closest-date' aware of hours repeaters.
+
+ * org.el (org-end-of-line): Do not call `end-of-visual-line' when
+ moving to the end of line. Also improve behaviour on elements that
+ can be hidden.
+
+ * org.el (org-sparse-tree): Allow to call `org-show-todo-tree'
+ with an argument.
+
+ * org-element.el (org-element--get-next-object-candidates): Fix
+ parsing of objects of the same type in a single paragraph.
+
+ * org-element.el (org-element-sub/superscript-successor): Fix
+ parsing of sub/superscript at beginning of item.
+ (org-element-latex-or-entity-successor): Fix parsing of latex
+ fragments at beginning of item.
+
+ * org-agenda.el (org-agenda-later): Fix function when span is
+ a number and an argument was provided. Also fix typo in docstring.
+
+ * org.el (org-read-date-analyze): Fix analyzing for dates like
+ "29.03 16:40".
+
+ * org-element.el (org-element-center-block-parser)
+ (org-element-drawer-parser, , org-element-footnote-definition-parser)
+ (org-element-inlinetask-parser, org-element-plain-list-parser)
+ (org-element-quote-block-parser, org-element-special-block-parser)
+ (org-element-babel-call-parser, org-element-clock-parser)
+ (org-element-comment-parser, org-element-comment-block-parser)
+ (org-element-example-block-parser, org-element-export-block-parser)
+ (org-element-fixed-width-parser, org-element-horizontal-rule-parser)
+ (org-element-keyword-parser, org-element-latex-environment-parser)
+ (org-element-paragraph-parser, org-element-planning-parser)
+ (org-element-property-drawer-parser, org-element-src-block-parser)
+ (org-element-table-parser)
+ (org-element-verse-block-parserorg-element-dynamic-block-parser):
+ Make sure element never ends at the end of a blank non-empty line.
+
+ * org-element.el (org-element-context)
+ (org-element--get-next-object-candidates): Fix `org-element-context'.
+ In particular, the restrictions for an object may be different from
+ those of its container (i.e. table rows and table cells).
+
+ * org-element.el (org-element-example-block-parser)
+ (org-element-src-block-parser): Store value of example-blocks and
+ src-blocks unescaped.
+ (org-element-example-block-interpreter)
+ (org-element-src-block-interpreter): Escape value again when storing
+ it.
+
+ * org-src.el (org-escape-code-in-string)
+ (org-unescape-code-in-string, org-escape-code-in-region)
+ (org-unescape-code-in-region): New functions.
+ (org-edit-src-code, org-edit-src-exit): Use new functions.
+
+ * org.el (org-strip-protective-commas): Removed function.
+
+ * org-exp.el (org-export-select-backend-specific-text): Use new
+ function.
+
+ * ob.el (org-babel-parse-src-block-match)
+ (org-babel-parse-inline-src-block-match, org-babel-insert-result):
+ Always escape produced blocks, independently on the language of the
+ block, if any. Use new functions.
+
+ * org-element.el (org-element-paragraph-parser): Fix regexp
+ starting a block.
+
+ * org-element.el (org-element-center-block-parser):
+ (org-element-drawer-parser, org-element-dynamic-block-parser)
+ (org-element-example-block-parser, org-element-export-block-parser)
+ (org-element-latex-environment-parser, org-element-paragraph-parser)
+ (org-element-property-drawer-parser, org-element-src-block-parser)
+ (org-element-verse-block-parser): Use stricter regexps for boundaries
+ of elements.
+
+2012-10-26 Toby S. Cubitt <tsc25@cantab.net>
+
+ * org-agenda.el (org-agenda-get-sexps): Reset `extra' to nil at
+ beginning of re-search-forward loop, otherwise next iteration picks up
+ `extra' value from previous entry.
+
2012-09-30 Abdó Roig-Maranges <abdo.roig@gmail.com>
* org-html.el (org-export-html-preprocess)
;;; Code:
(require 'ob)
+(require 'org-compat)
(defvar org-ditaa-jar-path) ;; provided by org-exp-blocks
(format "%S" var)))
(defvar org-src-preserve-indentation)
+(declare-function org-export-as-latex "org-latex"
+ (arg &optional ext-plist to-buffer body-only pub-dir))
(defun org-babel-haskell-export-to-lhs (&optional arg)
"Export to a .lhs file with all haskell code blocks escaped.
When called with a prefix argument the resulting
(require 'ob-eval)
(eval-when-compile (require 'cl))
+(defvar org-babel-tangle-lang-exts) ;; Autoloaded
(add-to-list 'org-babel-tangle-lang-exts '("io" . "io"))
(defvar org-babel-default-header-args:io '())
(defvar org-babel-io-command "io"
"Name of the command to use for executing Io code.")
-
(defun org-babel-execute:io (body params)
"Execute a block of Io code with org-babel. This function is
called by `org-babel-execute-src-block'"
(provide 'ob-keys)
-
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
;;; ob-keys.el ends here
(defvar org-babel-default-lob-header-args '((:exports . "results"))
"Default header arguments to use when exporting #+lob/call lines.")
-;;;###autoload
(defun org-babel-lob-ingest (&optional file)
"Add all named source-blocks defined in FILE to
`org-babel-library-of-babel'."
(provide 'ob-lob)
-
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
;;; ob-lob.el ends here
(eval-when-compile (require 'cl))
(declare-function run-picolisp "ext:inferior-picolisp" (cmd))
+(defvar org-babel-tangle-lang-exts) ;; Autoloaded
;; optionally define a file extension for this language
(add-to-list 'org-babel-tangle-lang-exts '("picolisp" . "l"))
(declare-function org-at-item-p "org-list" ())
(declare-function org-narrow-to-subtree "org" ())
(declare-function org-id-find-id-in-file "org-id" (id file &optional markerp))
+(declare-function org-id-find-id-file "org-id" (id))
(declare-function org-show-context "org" (&optional key))
(declare-function org-pop-to-buffer-same-window
"org-compat" (&optional buffer-or-name norecord label))
(require 'ob-eval)
(eval-when-compile (require 'cl))
+(defvar org-babel-tangle-lang-exts) ;; Autoloaded
(add-to-list 'org-babel-tangle-lang-exts '("scala" . "scala"))
(defvar org-babel-default-header-args:scala '())
(defvar org-babel-scala-command "scala"
"Name of the command to use for executing Scala code.")
-
(defun org-babel-execute:scala (body params)
"Execute a block of Scala code with org-babel. This function is
called by `org-babel-execute-src-block'"
(defvar org-babel-scala-wrapper-method
- "(
+
+"var str_result :String = null;
+
+Console.withOut(new java.io.OutputStream() {def write(b: Int){
+}}) {
+ str_result = {
%s
-) asString print
+ }.toString
+}
+
+print(str_result)
")
(eval-when-compile (require 'cl))
(declare-function org-table-import "org-table" (file arg))
-(declare-function orgtbl-to-csv "org-table" (TABLE PARAMS))
+(declare-function orgtbl-to-csv "org-table" (table params))
+(declare-function org-table-to-lisp "org-table" (&optional txt))
(defvar org-babel-default-header-args:sql '())
(declare-function org-fill-template "org" (template alist))
(declare-function org-table-convert-region "org-table"
(beg0 end0 &optional separator))
-(declare-function orgtbl-to-csv "org-table" (TABLE PARAMS))
+(declare-function orgtbl-to-csv "org-table" (table params))
+(declare-function org-table-to-lisp "org-table" (&optional txt))
(defvar org-babel-default-header-args:sqlite '())
(declare-function org-babel-update-block-body "org" (new-body))
(declare-function make-directory "files" (dir &optional parents))
-;;;###autoload
(defcustom org-babel-tangle-lang-exts
'(("emacs-lisp" . "el"))
"Alist mapping languages to their file extensions.
(provide 'ob-tangle)
-
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
;;; ob-tangle.el ends here
(declare-function show-all "outline" ())
(declare-function org-reduce "org" (CL-FUNC CL-SEQ &rest CL-KEYS))
(declare-function org-mark-ring-push "org" (&optional pos buffer))
-(declare-function org-strip-protective-commas "org" (beg end))
(declare-function tramp-compat-make-temp-file "tramp-compat"
(filename &optional dir-flag))
(declare-function tramp-dissect-file-name "tramp" (name &optional nodefault))
(declare-function org-cycle "org" (&optional arg))
(declare-function org-uniquify "org" (list))
(declare-function org-current-level "org" ())
-(declare-function org-strip-protective-commas "org" (beg end))
(declare-function org-table-import "org-table" (file arg))
(declare-function org-add-hook "org-compat"
(hook function &optional append local))
(declare-function org-list-struct "org-list" ())
(declare-function org-list-prevs-alist "org-list" (struct))
(declare-function org-list-get-list-end "org-list" (item struct prevs))
-(declare-function org-strip-protective-commas "org" (beg end))
(declare-function org-remove-if "org" (predicate seq))
(declare-function org-completing-read "org" (&rest args))
-(declare-function org-add-protective-commas "org-src" (beg end))
+(declare-function org-escape-code-in-region "org-src" (beg end))
+(declare-function org-unescape-code-in-string "org-src" (s))
+(declare-function org-table-to-lisp "org-table" (&optional txt))
(defgroup org-babel nil
"Code block evaluation and management in `org-mode' documents."
;;; functions
(defvar call-process-region)
-;;;###autoload
+;;;###autoload
(defun org-babel-execute-src-block (&optional arg info params)
"Execute the current source code block.
Insert the results of execution into the buffer. Source code
(key-binding (or key (read-key-sequence nil))))))
(defvar org-bracket-link-regexp)
+
;;;###autoload
(defun org-babel-open-src-block-result (&optional re-run)
"If `point' is on a src block then open the results of the
(def-edebug-spec org-babel-map-inline-src-blocks (form body))
(defvar org-babel-lob-one-liner-regexp)
+
;;;###autoload
(defmacro org-babel-map-call-lines (file &rest body)
"Evaluate BODY forms on each call line in FILE.
;; get block body less properties, protective commas, and indentation
(with-temp-buffer
(save-match-data
- (insert (org-babel-strip-protective-commas body lang))
+ (insert (org-unescape-code-in-string body))
(unless preserve-indentation (org-do-remove-indentation))
(buffer-string)))
(org-babel-merge-params
(let* ((lang (org-no-properties (match-string 2)))
(lang-headers (intern (concat "org-babel-default-header-args:" lang))))
(list lang
- (org-babel-strip-protective-commas
- (org-no-properties (match-string 5)) lang)
+ (org-unescape-code-in-string (org-no-properties (match-string 5)))
(org-babel-merge-params
org-babel-default-inline-header-args
(org-babel-params-from-properties lang)
((member "prepend" result-params)))) ; already there
(setq results-switches
(if results-switches (concat " " results-switches) ""))
- (let ((wrap (lambda (start finish &optional escape)
+ (let ((wrap (lambda (start finish)
(goto-char end) (insert (concat finish "\n"))
(goto-char beg) (insert (concat start "\n"))
- (if escape (org-add-protective-commas (point) end))
+ (org-escape-code-in-region (point) end)
(goto-char end) (goto-char (point-at-eol))
(setq end (point-marker))))
(proper-list-p (lambda (it) (and (listp it) (null (cdr (last it)))))))
((member "latex" result-params)
(funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX"))
((member "org" result-params)
- (funcall wrap "#+BEGIN_SRC org" "#+END_SRC" 'escape))
+ (funcall wrap "#+BEGIN_SRC org" "#+END_SRC"))
((member "code" result-params)
(funcall wrap (format "#+BEGIN_SRC %s%s" (or lang "none") results-switches)
"#+END_SRC"))
(funcall nb-add (buffer-substring index (point-max))))
new-body))
-(defun org-babel-strip-protective-commas (body &optional lang)
- "Strip protective commas from bodies of source blocks."
- (with-temp-buffer
- (insert body)
- (if (and lang (string= lang "org"))
- (progn (goto-char (point-min))
- (while (re-search-forward "^[ \t]*\\(,\\)" nil t)
- (replace-match "" nil nil nil 1)))
- (org-strip-protective-commas (point-min) (point-max)))
- (buffer-string)))
-
(defun org-babel-script-escape (str &optional force)
"Safely convert tables into elisp lists."
(let (in-single in-double out)
(provide 'ob)
-
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
;;; ob.el ends here
:version "24.3"
:type 'boolean)
+\f
;;;###autoload
(defun org-toggle-sticky-agenda (&optional arg)
"Toggle `org-agenda-sticky'."
(message "Sticky agenda was %s"
(if org-agenda-sticky "enabled" "disabled"))))))
+(autoload 'org-toggle-sticky-agenda "org-agenda" "\
+Toggle `org-agenda-sticky'.
+
+\(fn &optional ARG)" t nil)
+
(defvar org-agenda-buffer nil
"Agenda buffer currently being generated.")
((equal org-keys "!") (customize-variable 'org-stuck-projects))
(t (error "Invalid agenda key"))))))
+(autoload 'org-agenda "org-agenda" "\
+Dispatch agenda commands to collect entries to the agenda buffer.
+Prompts for a command to execute. Any prefix arg will be passed
+on to the selected command. The default selections are:
+
+a Call `org-agenda-list' to display the agenda for current day or week.
+t Call `org-todo-list' to display the global todo list.
+T Call `org-todo-list' to display the global todo list, select only
+ entries with a specific TODO keyword (the user gets a prompt).
+m Call `org-tags-view' to display headlines with tags matching
+ a condition (the user is prompted for the condition).
+M Like `m', but select only TODO entries, no ordinary headlines.
+L Create a timeline for the current buffer.
+e Export views to associated files.
+s Search entries for keywords.
+S Search entries for keywords, only with TODO keywords.
+/ Multi occur across all agenda files and also files listed
+ in `org-agenda-text-search-extra-files'.
+< Restrict agenda commands to buffer, subtree, or region.
+ Press several times to get the desired effect.
+> Remove a previous restriction.
+# List \"stuck\" projects.
+! Configure what \"stuck\" means.
+C Configure custom agenda commands.
+
+More commands can be added by configuring the variable
+`org-agenda-custom-commands'. In particular, specific tags and TODO keyword
+searches can be pre-defined in this way.
+
+If the current buffer is in Org-mode and visiting a file, you can also
+first press `<' once to indicate that the agenda should be temporarily
+\(until the next use of \\[org-agenda]) restricted to the current file.
+Pressing `<' twice means to restrict to the current subtree or region
+\(if active).
+
+\(fn &optional ARG ORG-KEYS RESTRICTION)" t nil)
+
(defun org-agenda-append-agenda ()
"Append another agenda view to the current one.
This function allows interactive building of block agendas.
(org-agenda nil cmd-key)))
(set-buffer org-agenda-buffer-name)
(princ (buffer-string)))
+
+(autoload 'org-batch-agenda "org-agenda" "\
+Run an agenda command in batch mode and send the result to STDOUT.
+If CMD-KEY is a string of length 1, it is used as a key in
+`org-agenda-custom-commands' and triggers this command. If it is a
+longer string it is used as a tags/todo match string.
+Parameters are alternating variable names and values that will be bound
+before running the agenda command.
+
+\(fn CMD-KEY &rest PARAMETERS)" nil t)
(def-edebug-spec org-batch-agenda (form &rest sexp))
(defvar org-agenda-info nil)
priority-letter priority agenda-day)
","))
(princ "\n")))))
+
+(autoload 'org-batch-agenda-csv "org-agenda" "\
+Run an agenda command in batch mode and send the result to STDOUT.
+If CMD-KEY is a string of length 1, it is used as a key in
+`org-agenda-custom-commands' and triggers this command. If it is a
+longer string it is used as a tags/todo match string.
+Parameters are alternating variable names and values that will be bound
+before running the agenda command.
+
+The output gives a line for each selected agenda item. Each
+item is a list of comma-separated values, like this:
+
+category,head,type,todo,tags,date,time,extra,priority-l,priority-n
+
+category The category of the item
+head The headline, without TODO kwd, TAGS and PRIORITY
+type The type of the agenda entry, can be
+ todo selected in TODO match
+ tagsmatch selected in tags match
+ diary imported from diary
+ deadline a deadline on given date
+ scheduled scheduled on given date
+ timestamp entry has timestamp on given date
+ closed entry was closed on given date
+ upcoming-deadline warning about deadline
+ past-scheduled forwarded scheduled item
+ block entry has date block including g. date
+todo The todo keyword, if any
+tags All tags including inherited ones, separated by colons
+date The relevant date, like 2007-2-14
+time The time, like 15:00-16:50
+extra Sting with extra planning info
+priority-l The priority letter if any was given
+priority-n The computed numerical priority
+agenda-day The day in the agenda where this is listed
+
+\(fn CMD-KEY &rest PARAMETERS)" nil t)
(def-edebug-spec org-batch-agenda-csv (form &rest sexp))
(defun org-fix-agenda-info (props)
(interactive)
(eval (list 'org-batch-store-agenda-views)))
+(autoload 'org-store-agenda-views "org-agenda" "\
+
+
+\(fn &rest PARAMETERS)" t nil)
+
;;;###autoload
(defmacro org-batch-store-agenda-views (&rest parameters)
"Run all custom agenda commands that have a file argument."
(org-agenda-write (expand-file-name (pop files) dir) nil t bufname)))
(and (get-buffer bufname)
(kill-buffer bufname)))))))
+
+(autoload 'org-batch-store-agenda-views "org-agenda" "\
+Run all custom agenda commands that have a file argument.
+
+\(fn &rest PARAMETERS)" nil t)
(def-edebug-spec org-batch-store-agenda-views (&rest sexp))
(defvar org-agenda-current-span nil
""
x))
filter ""))))
- (setq tbl (apply 'org-get-clocktable p))
+ (setq tbl (apply 'org-clock-get-clocktable p))
(insert tbl)))
(goto-char (point-min))
(or org-agenda-multi (org-agenda-fit-window-to-buffer))
(setq buffer-read-only t)
(message ""))))
+(autoload 'org-agenda-list "org-agenda" "\
+Produce a daily/weekly view from all files in variable `org-agenda-files'.
+The view will be for the current day or week, but from the overview buffer
+you will be able to go to other days/weeks.
+
+With a numeric prefix argument in an interactive call, the agenda will
+span ARG days. Lisp programs should instead specify SPAN to change
+the number of days. SPAN defaults to `org-agenda-span'.
+
+START-DAY defaults to TODAY, or to the most recent match for the weekday
+given in `org-agenda-start-on-weekday'.
+
+\(fn &optional ARG START-DAY SPAN)" t nil)
+
(defun org-agenda-ndays-to-span (n)
"Return a span symbol for a span of N days, or N if none matches."
(cond ((symbolp n) n)
(org-agenda-finalize)
(setq buffer-read-only t))))
+(autoload 'org-search-view "org-agenda" "\
+Show all entries that contain a phrase or words or regular expressions.
+
+With optional prefix argument TODO-ONLY, only consider entries that are
+TODO entries. The argument STRING can be used to pass a default search
+string into this function. If EDIT-AT is non-nil, it means that the
+user should get a chance to edit this string, with cursor at position
+EDIT-AT.
+
+The search string can be viewed either as a phrase that should be found as
+is, or it can be broken into a number of snippets, each of which must match
+in a Boolean way to select an entry. The default depends on the variable
+`org-agenda-search-view-always-boolean'.
+Even if this is turned off (the default) you can always switch to
+Boolean search dynamically by preceding the first word with \"+\" or \"-\".
+
+The default is a direct search of the whole phrase, where each space in
+the search string can expand to an arbitrary amount of whitespace,
+including newlines.
+
+If using a Boolean search, the search string is split on whitespace and
+each snippet is searched separately, with logical AND to select an entry.
+Words prefixed with a minus must *not* occur in the entry. Words without
+a prefix or prefixed with a plus must occur in the entry. Matching is
+case-insensitive. Words are enclosed by word delimiters (i.e. they must
+match whole words, not parts of a word) if
+`org-agenda-search-view-force-full-words' is set (default is nil).
+
+Boolean search snippets enclosed by curly braces are interpreted as
+regular expressions that must or (when preceded with \"-\") must not
+match in the entry. Snippets enclosed into double quotes will be taken
+as a whole, to include whitespace.
+
+- If the search string starts with an asterisk, search only in headlines.
+- If (possibly after the leading star) the search string starts with an
+ exclamation mark, this also means to look at TODO entries only, an effect
+ that can also be achieved with a prefix argument.
+- If (possibly after star and exclamation mark) the search string starts
+ with a colon, this will mean that the (non-regexp) snippets of the
+ Boolean search must match as full words.
+
+This command searches the agenda files, and in addition the files listed
+in `org-agenda-text-search-extra-files'.
+
+\(fn &optional TODO-ONLY STRING EDIT-AT)" t nil)
+
;;; Agenda TODO list
(defvar org-select-this-todo-keyword nil)
(org-agenda-finalize)
(setq buffer-read-only t))))
+(autoload 'org-todo-list "org-agenda" "\
+Show all (not done) TODO entries from all agenda file in a single list.
+The prefix arg can be used to select a specific TODO keyword and limit
+the list to these. When using \\[universal-argument], you will be prompted
+for a keyword. A numeric prefix directly selects the Nth keyword in
+`org-todo-keywords-1'.
+
+\(fn &optional ARG)" t nil)
+
;;; Agenda tags match
;;;###autoload
(org-agenda-finalize)
(setq buffer-read-only t))))
+(autoload 'org-tags-view "org-agenda" "\
+Show all headlines for all `org-agenda-files' matching a TAGS criterion.
+The prefix arg TODO-ONLY limits the search to TODO entries.
+
+\(fn &optional TODO-ONLY MATCH)" t nil)
+
;;; Agenda Finding stuck projects
(defvar org-agenda-skip-regexp nil
(setq org-agenda-redo-command
`(org-agenda-list-stuck-projects ,current-prefix-arg)))))
+(autoload 'org-agenda-list-stuck-projects "org-agenda" "\
+Create agenda view for projects that are stuck.
+Stuck projects are project that have no next actions. For the definitions
+of what a project is and how to check if it stuck, customize the variable
+`org-stuck-projects'.
+
+\(fn &rest IGNORE)" t nil)
+
;;; Diary integration
(defvar org-disable-agenda-to-diary nil) ;Dynamically-scoped param.
(if results
(concat (org-agenda-finalize-entries results) "\n"))))
+(autoload 'org-diary "org-agenda" "\
+Return diary information from org files.
+This function can be used in a \"sexp\" diary entry in the Emacs calendar.
+It accesses org files and extracts information from those files to be
+listed in the diary. The function accepts arguments specifying what
+items should be listed. For a list of arguments allowed here, see the
+variable `org-agenda-entry-types'.
+
+The call in the diary file should look like this:
+
+ &%%(org-diary) ~/path/to/some/orgfile.org
+
+Use a separate line for each org file to check. Or, if you omit the file name,
+all files listed in `org-agenda-files' will be checked automatically:
+
+ &%%(org-diary)
+
+If you don't give any arguments (as in the example above), the default
+arguments (:deadline :scheduled :timestamp :sexp) are used.
+So the example above may also be written as
+
+ &%%(org-diary :deadline :timestamp :sexp :scheduled)
+
+The function expects the lisp variables `entry' and `date' to be provided
+by the caller, because this is how the calendar works. Don't use this
+function from a program - use `org-agenda-get-day-entries' instead.
+
+\(fn &rest ARGS)" nil nil)
+
;;; Agenda entry finders
(defun org-agenda-get-day-entries (file date &rest args)
(>= days n)
(<= days n))))
-;;;###autoload
(defun org-agenda-check-for-timestamp-as-reason-to-ignore-todo-item
(&optional end)
"Do we have a reason to ignore this TODO entry because it has a time stamp?"
(match-string 1) org-agenda-todo-ignore-timestamp))
(t))))))))))
+(autoload 'org-agenda-check-for-timestamp-as-reason-to-ignore-todo-item "org-agenda" "\
+Do we have a reason to ignore this TODO entry because it has a time stamp?
+
+\(fn &optional END)" nil nil)
+
(defconst org-agenda-no-heading-message
"No heading for this item in buffer or region.")
"\\|\\(<%%\\(([^>\n]+)\\)>\\)"))
marker hdmarker deadlinep scheduledp clockp closedp inactivep
donep tmp priority category category-pos ee txt timestr tags
- b0 b3 e3 head todo-state end-of-match show-all warntime)
+ b0 b3 e3 head todo-state end-of-match show-all warntime habitp)
(goto-char (point-min))
(while (setq end-of-match (re-search-forward regexp nil t))
(setq b0 (match-beginning 0)
b3 (match-beginning 3) e3 (match-end 3)
todo-state (save-match-data (ignore-errors (org-get-todo-state)))
+ habitp (and (functionp 'org-is-habit-p) (save-match-data (org-is-habit-p)))
show-all (or (eq org-agenda-repeating-timestamp-show-all t)
(member todo-state
org-agenda-repeating-timestamp-show-all)))
(setq txt (org-agenda-format-item
(if inactivep org-agenda-inactive-leader nil)
head category tags timestr
- remove-re t)))
+ remove-re habitp)))
(setq priority (org-get-priority txt))
(org-add-props txt props
'org-marker marker 'org-hd-marker hdmarker)
tags (save-excursion (org-backward-heading-same-level 0)
(org-get-tags-at))
todo-state (org-get-todo-state)
- warntime (org-entry-get (point) "APPT_WARNTIME"))
+ warntime (org-entry-get (point) "APPT_WARNTIME")
+ extra nil)
(dolist (r (if (stringp result)
(list result)
(concat "<" start-time ">"))
((= d2 d0)
(concat "<" end-time ">")))
- remove-re t))))
+ remove-re))))
(org-add-props txt props
'org-marker marker 'org-hd-marker hdmarker
'type "block" 'date date
(move-beginning-of-line 1)))))
(defun org-agenda-later (arg)
- "Go forward in time by thee current span.
+ "Go forward in time by the current span.
With prefix ARG, go forward that many times the current span."
(interactive "p")
(org-agenda-check-type t 'agenda)
greg2)
(cond
((numberp span)
- (setq sd (+ span sd)))
+ (setq sd (+ (* span arg) sd)))
((eq span 'day)
(setq sd (+ arg sd)))
((eq span 'week)
`org-agenda-diary-entry-in-org-file' is called instead to create
entries in that Org-mode file."
(interactive)
- (org-agenda-check-type t 'agenda 'timeline)
(if (not (eq org-agenda-diary-file 'diary-file))
(org-agenda-diary-entry-in-org-file)
(require 'diary-lib)
(calendar-cursor-to-date))
nil))
+(autoload 'org-calendar-goto-agenda "org-agenda" "\
+Compute the Org-mode agenda for the calendar date displayed at the cursor.
+This is a command that has to be installed in `calendar-mode-map'.
+
+\(fn)" t nil)
+
(defun org-agenda-convert-date ()
(interactive)
(org-agenda-check-type t 'agenda 'timeline)
(message "No event to add")
(message "Added %d event%s for today" cnt (if (> cnt 1) "s" "")))))
+(autoload 'org-agenda-to-appt "org-agenda" "\
+Activate appointments found in `org-agenda-files'.
+With a \\[universal-argument] prefix, refresh the list of
+appointments.
+
+If FILTER is t, interactively prompt the user for a regular
+expression, and filter out entries that don't match it.
+
+If FILTER is a string, use this string as a regular expression
+for filtering entries out.
+
+If FILTER is a function, filter out entries against which
+calling the function returns nil. This function takes one
+argument: an entry from `org-agenda-get-day-entries'.
+
+FILTER can also be an alist with the car of each cell being
+either 'headline or 'category. For example:
+
+ '((headline \"IMPORTANT\")
+ (category \"Work\"))
+
+will only add headlines containing IMPORTANT or headlines
+belonging to the \"Work\" category.
+
+ARGS are symbols indicating what kind of entries to consider.
+By default `org-agenda-to-appt' will use :deadline, :scheduled
+and :timestamp entries. See the docstring of `org-diary' for
+details and examples.
+
+If an entry as a APPT_WARNTIME property, its value will be used
+to override `appt-message-warning-time'.
+
+\(fn &optional REFRESH FILTER &rest ARGS)" t nil)
+
(defun org-agenda-todayp (date)
"Does DATE mean today, when considering `org-extend-today-until'?"
(let ((today (org-today))
(file-name-nondirectory
(buffer-file-name (buffer-base-buffer))))))
+;;;###autoload
(defun org-archive-subtree (&optional find-done)
"Move the current subtree to the archive.
The archive can be a certain top-level heading in the current file, or in
(if (looking-at "^[ \t]*$")
(outline-next-visible-heading 1))))
+;;;###autoload
(defun org-archive-to-archive-sibling ()
"Archive the current heading by moving it under the archive sibling.
The archive sibling is a sibling of the heading with the heading name
(goto-char end)))))
(message "%d trees archived" cntarch)))
+;;;###autoload
(defun org-toggle-archive-tag (&optional find-done)
"Toggle the archive tag for the current headline.
With prefix ARG, check all children of current headline and offer tagging
(provide 'org-archive)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-archive.el ends here
(kill-buffer (current-buffer)))
(current-buffer))))
+;;;###autoload
(defun org-export-ascii-preprocess (parameters)
"Do extra work for ASCII export."
;;
(provide 'org-ascii)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-ascii.el ends here
(provide 'org-attach)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-attach.el ends here
(add-hook 'bbdb-after-change-hook 'org-bbdb-updated)
;;;###autoload
-(defun org-bbdb-anniversaries()
+(defun org-bbdb-anniversaries ()
"Extract anniversaries from BBDB for display in the agenda."
(require 'bbdb)
(require 'diary-lib)
(provide 'org-bbdb)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-bbdb.el ends here
(org-entry-put nil "BEAMER_env" (match-string 1 tags)))
(t (org-entry-delete nil "BEAMER_env"))))))
-
+;;;###autoload
(defun org-beamer-sectioning (level text)
"Return the sectioning entry for the current headline.
LEVEL is the reduced level of the headline.
"The keymap for `org-beamer-mode'.")
(define-key org-beamer-mode-map "\C-c\C-b" 'org-beamer-select-environment)
+;;;###autoload
(define-minor-mode org-beamer-mode
"Special support for editing Org-mode files made to export to beamer."
nil " Bm" nil)
;;; The main commands
-;;;###autoload
(defvar org-capture-initial nil)
(defvar org-capture-entry nil)
+
+;;;###autoload
(defun org-capture-string (string &optional keys)
(interactive "sInitial text: \n")
(let ((org-capture-initial string)
(save-restriction
(widen)
(goto-char pos)
- (bookmark-set "org-capture-last-stored")
+ (with-demoted-errors
+ (bookmark-set "org-capture-last-stored"))
(move-marker org-capture-last-stored-marker (point)))))))
(defun org-capture-narrow (beg end)
(goto-char pos)))
(defvar org-clock-marker) ; Defined in org.el
-;;;###autoload
+
(defun org-capture-insert-template-here ()
(let* ((template (org-capture-get :template))
(type (org-capture-get :type))
(const :tag "Standard beep" t)
(file :tag "Play sound file")))
-(defcustom org-clock-modeline-total 'auto
+(define-obsolete-variable-alias 'org-clock-modeline-total
+ 'org-clock-mode-line-total "24.3")
+
+(defcustom org-clock-mode-line-total 'auto
"Default setting for the time included for the mode line clock.
This can be overruled locally using the CLOCK_MODELINE_TOTAL property.
Allowed values are:
(not (memq ch '(?K ?G ?S ?C))))
fail-quietly)))))
+;;;###autoload
(defun org-resolve-clocks (&optional only-dangling-p prompt-fn last-valid)
"Resolve all currently open org-mode clocks.
If `only-dangling-p' is non-nil, only ask to resolve dangling
(setq org-clock-current-task nil))
(defvar org-clock-out-time nil) ; store the time of the last clock-out
+
+;;;###autoload
(defun org-clock-in (&optional select start-time)
"Start the clock on the current item.
If necessary, clock-out of the currently active clock.
(if (and (eobp) (not (org-at-heading-p)))
(point-at-bol 0)
(point)))
- (run-hooks 'org-clock-in-prepare-hook)
(save-excursion
(when (and selected-task (marker-buffer selected-task))
;; There is a selected task, move to the correct buffer
;; beginning of the heading, since the
;; user is liking to insert stuff here
;; manually
+ (run-hooks 'org-clock-in-prepare-hook)
(org-clock-history-push))
(org-clock-set-current)
(cond ((functionp org-clock-in-switch-to-state)
This is for the currently running clock as it is displayed
in the mode line. This function looks at the properties
LAST_REPEAT and in particular CLOCK_MODELINE_TOTAL and the
-corresponding variable `org-clock-modeline-total' and then
+corresponding variable `org-clock-mode-line-total' and then
decides which time to use."
(let ((cmt (or (org-entry-get nil "CLOCK_MODELINE_TOTAL")
- (symbol-name org-clock-modeline-total)))
+ (symbol-name org-clock-mode-line-total)))
(lr (org-entry-get nil "LAST_REPEAT")))
(cond
((equal cmt "current")
(and (re-search-forward org-property-end-re nil t)
(goto-char (match-beginning 0))))))))
+;;;###autoload
(defun org-clock-out (&optional switch-to-state fail-quietly at-time)
"Stop the currently running clock.
Throw an error if there is no running clock and FAIL-QUIETLY is nil.
((eq org-ts-what 'year) (* 24 3600 365.2)))))
org-ts-what 'updown)))))))
+;;;###autoload
(defun org-clock-cancel ()
"Cancel the running clock by removing the start timestamp."
(interactive)
(message "Clock canceled")
(run-hooks 'org-clock-cancel-hook))
+;;;###autoload
(defun org-clock-goto (&optional select)
"Go to the currently clocked-in entry, or to the most recently clocked one.
With prefix arg SELECT, offer recently clocked tasks for selection."
(let ((range (org-clock-special-range 'today)))
(org-clock-sum (car range) (cadr range) nil :org-clock-minutes-today)))
+;;;###autoload
(defun org-clock-sum (&optional tstart tend headline-filter propname)
"Sum the times for each subtree.
Puts the resulting times in minutes as a text property on each headline.
(org-clock-sum tstart)
org-clock-file-total-minutes)))
+;;;###autoload
(defun org-clock-display (&optional total-only)
"Show subtree times in the entire buffer.
If TOTAL-ONLY is non-nil, only show the total time for the entire file
'org-clock-out-if-current)
;;;###autoload
-(defun org-get-clocktable (&rest props)
+(defun org-clock-get-clocktable (&rest props)
"Get a formatted clocktable with parameters according to PROPS.
The table is created in a temporary buffer, fully formatted and
fontified, and then returned."
(re-search-forward "^[ \t]*#\\+END" nil t)
(point-at-bol)))))
+;;;###autoload
(defun org-clock-report (&optional arg)
"Create a table containing a report about clocked time.
If the cursor is inside an existing clocktable block, then the table
(org-update-dblock)
t)))))
+;;;###autoload
(defun org-dblock-write:clocktable (params)
"Write the standard clocktable."
(setq params (org-combine-plists org-clocktable-defaults params))
(defvar org-clock-loaded nil
"Was the clock file loaded?")
+(defun org-clock-update-time-maybe ()
+ "If this is a CLOCK line, update it and return t.
+Otherwise, return nil."
+ (interactive)
+ (save-excursion
+ (beginning-of-line 1)
+ (skip-chars-forward " \t")
+ (when (looking-at org-clock-string)
+ (let ((re (concat "[ \t]*" org-clock-string
+ " *[[<]\\([^]>]+\\)[]>]\\(-+[[<]\\([^]>]+\\)[]>]"
+ "\\([ \t]*=>.*\\)?\\)?"))
+ ts te h m s neg)
+ (cond
+ ((not (looking-at re))
+ nil)
+ ((not (match-end 2))
+ (when (and (equal (marker-buffer org-clock-marker) (current-buffer))
+ (> org-clock-marker (point))
+ (<= org-clock-marker (point-at-eol)))
+ ;; The clock is running here
+ (setq org-clock-start-time
+ (apply 'encode-time
+ (org-parse-time-string (match-string 1))))
+ (org-clock-update-mode-line)))
+ (t
+ (and (match-end 4) (delete-region (match-beginning 4) (match-end 4)))
+ (end-of-line 1)
+ (setq ts (match-string 1)
+ te (match-string 3))
+ (setq s (- (org-float-time
+ (apply 'encode-time (org-parse-time-string te)))
+ (org-float-time
+ (apply 'encode-time (org-parse-time-string ts))))
+ neg (< s 0)
+ s (abs s)
+ h (floor (/ s 3600))
+ s (- s (* 3600 h))
+ m (floor (/ s 60))
+ s (- s (* 60 s)))
+ (insert " => " (format (if neg "-%d:%02d" "%2d:%02d") h m))
+ t))))))
+
(defun org-clock-save ()
"Persist various clock-related data to disk.
The details of what will be saved are regulated by the variable
(if (outline-invisible-p)
(org-show-context))))))))))
-;;;###autoload
-(defun org-clock-persistence-insinuate ()
- "Set up hooks for clock persistence."
- (add-hook 'org-mode-hook 'org-clock-load)
- (add-hook 'kill-emacs-hook 'org-clock-save))
-
;; Suggested bindings
(org-defkey org-mode-map "\C-c\C-x\C-e" 'org-clock-modify-effort-estimate)
(provide 'org-clock)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-clock.el ends here
(move-marker org-columns-top-level-marker org-entry-property-inherited-from)
(move-marker org-columns-top-level-marker (point))))
+;;;###autoload
(defun org-columns (&optional columns-fmt-string)
"Turn on column view on an org-mode file.
When COLUMNS-FMT-STRING is non-nil, use it as the column format."
(push row tbl)))))
(append (list title 'hline) (nreverse tbl)))))
+;;;###autoload
(defun org-dblock-write:columnview (params)
"Write the column view table.
PARAMS is a property list of parameters:
(t (error "Garbage in listtable: %s" x))))
tbl "\n"))
+;;;###autoload
(defun org-insert-columns-dblock ()
"Create a dynamic block capturing a column view table."
(interactive)
(defvar org-agenda-columns-compute-summary-properties); defined in org-agenda.el
(defvar org-agenda-columns-add-appointments-to-effort-sum); as well
+;;;###autoload
(defun org-agenda-columns ()
"Turn on or update column view in the agenda."
(interactive)
(apply 'propertize string properties)))
(defmacro org-find-library-dir (library)
- `(file-name-directory (locate-library ,library)))
+ `(file-name-directory (or (locate-library ,library) "")))
(defun org-count-lines (s)
"How many lines in string S?"
(provide 'org-datetree)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-datetree.el ends here
(provide 'org-docbook)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-docbook.el ends here
Assume point is at the beginning of the block."
(let ((case-fold-search t))
(if (not (save-excursion
- (re-search-forward "^[ \t]*#\\+END_CENTER" limit t)))
+ (re-search-forward "^[ \t]*#\\+END_CENTER[ \t]*$" limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((block-end-line (match-beginning 0)))
(forward-line)
(point)))
(end (save-excursion (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'center-block
(nconc
(list :begin begin
Assume point is at beginning of drawer."
(let ((case-fold-search t))
- (if (not (save-excursion (re-search-forward "^[ \t]*:END:" limit t)))
+ (if (not (save-excursion (re-search-forward "^[ \t]*:END:[ \t]*$" limit t)))
;; Incomplete drawer: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((drawer-end-line (match-beginning 0)))
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'drawer
(nconc
(list :begin begin
Assume point is at beginning of dynamic block."
(let ((case-fold-search t))
- (if (not (save-excursion (re-search-forward org-dblock-end-re limit t)))
+ (if (not (save-excursion
+ (re-search-forward "^[ \t]*#\\+END:?[ \t]*$" limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((block-end-line (match-beginning 0)))
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'dynamic-block
(nconc
(list :begin begin
(contents-end (and contents-begin ending))
(end (progn (goto-char ending)
(skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'footnote-definition
(nconc
(list :label label
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position))))
(inlinetask
(list 'inlinetask
(nconc
(unless (bolp) (forward-line))
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
;; Return value.
(list 'plain-list
(nconc
Assume point is at the beginning of the block."
(let ((case-fold-search t))
(if (not (save-excursion
- (re-search-forward "^[ \t]*#\\+END_QUOTE" limit t)))
+ (re-search-forward "^[ \t]*#\\+END_QUOTE[ \t]*$" limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((block-end-line (match-beginning 0)))
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'quote-block
(nconc
(list :begin begin
(type (progn (looking-at "[ \t]*#\\+BEGIN_\\(S-+\\)")
(upcase (match-string-no-properties 1)))))
(if (not (save-excursion
- (re-search-forward (concat "^[ \t]*#\\+END_" type) limit t)))
+ (re-search-forward
+ (format "^[ \t]*#\\+END_%s[ \t]*$" type) limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((block-end-line (match-beginning 0)))
(pos-before-blank (progn (goto-char block-end-line)
(forward-line)
(point)))
- (end (progn (org-skip-whitespace)
- (if (eobp) (point) (point-at-bol)))))
+ (end (progn (skip-chars-forward " \r\t\n" limit)
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'special-block
(nconc
(list :type type
(begin (point-at-bol))
(pos-before-blank (progn (forward-line) (point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'babel-call
(list :begin begin
:end end
(status (if time 'closed 'running))
(post-blank (let ((before-blank (progn (forward-line) (point))))
(skip-chars-forward " \r\t\n" limit)
- (unless (eobp) (beginning-of-line))
+ (skip-chars-backward " \t")
+ (unless (bolp) (end-of-line))
(count-lines before-blank (point))))
(end (point)))
(list 'clock
(point)))
(end (progn (goto-char com-end)
(skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'comment
(nconc
(list :begin begin
Assume point is at comment block beginning."
(let ((case-fold-search t))
(if (not (save-excursion
- (re-search-forward "^[ \t]*#\\+END_COMMENT" limit t)))
+ (re-search-forward "^[ \t]*#\\+END_COMMENT[ \t]*$" limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((contents-end (match-beginning 0)))
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position))))
(value (buffer-substring-no-properties
contents-begin contents-end)))
(list 'comment-block
`:switches', `:value' and `:post-blank' keywords."
(let ((case-fold-search t))
(if (not (save-excursion
- (re-search-forward "^[ \t]*#\\+END_EXAMPLE" limit t)))
+ (re-search-forward "^[ \t]*#\\+END_EXAMPLE[ \t]*$" limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((contents-end (match-beginning 0)))
(begin (car keywords))
(contents-begin (progn (forward-line) (point)))
(hidden (org-invisible-p2))
- (value (buffer-substring-no-properties contents-begin contents-end))
+ (value (org-unescape-code-in-string
+ (buffer-substring-no-properties
+ contents-begin contents-end)))
(pos-before-blank (progn (goto-char contents-end)
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'example-block
(nconc
(list :begin begin
(let ((switches (org-element-property :switches example-block)))
(concat "#+BEGIN_EXAMPLE" (and switches (concat " " switches)) "\n"
(org-remove-indentation
- (org-element-property :value example-block))
+ (org-escape-code-in-string
+ (org-element-property :value example-block)))
"#+END_EXAMPLE")))
(type (progn (looking-at "[ \t]*#\\+BEGIN_\\(\\S-+\\)")
(upcase (org-match-string-no-properties 1)))))
(if (not (save-excursion
- (re-search-forward (concat "^[ \t]*#\\+END_" type) limit t)))
+ (re-search-forward
+ (format "^[ \t]*#\\+END_%s[ \t]*$" type) limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((contents-end (match-beginning 0)))
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position))))
(value (buffer-substring-no-properties contents-begin
contents-end)))
(list 'export-block
(forward-line))
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'fixed-width
(nconc
(list :begin begin
(begin (car keywords))
(post-hr (progn (forward-line) (point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'horizontal-rule
(nconc
(list :begin begin
(match-end 0) (point-at-eol))))
(pos-before-blank (progn (forward-line) (point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'keyword
(list :key key
:value value
(env (progn (looking-at "^[ \t]*\\\\begin{\\([A-Za-z0-9]+\\*?\\)}")
(regexp-quote (match-string 1))))
(code-end
- (progn (re-search-forward (format "^[ \t]*\\\\end{%s}" env) limit t)
+ (progn (re-search-forward
+ (format "^[ \t]*\\\\end{%s}[ \t]*$" env) limit t)
(forward-line)
(point)))
(value (buffer-substring-no-properties code-begin code-end))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'latex-environment
(nconc
(list :begin begin
Assume point is at the beginning of the paragraph."
(save-excursion
- (let* (;; INNER-PAR-P is non-nil when paragraph is at the
+ (let* ((contents-begin (point))
+ ;; INNER-PAR-P is non-nil when paragraph is at the
;; beginning of an item or a footnote reference. In that
;; case, we mustn't look for affiliated keywords since they
;; belong to the container.
(inner-par-p (not (bolp)))
- (contents-begin (point))
(keywords (unless inner-par-p
(org-element--collect-affiliated-keywords)))
(begin (if inner-par-p contents-begin (car keywords)))
(before-blank
(let ((case-fold-search t))
(end-of-line)
- (re-search-forward org-element-paragraph-separate limit 'm)
- (while (and (/= (point) limit)
- (cond
- ;; Skip non-existent or incomplete drawer.
- ((save-excursion
- (beginning-of-line)
- (and (looking-at "[ \t]*:\\S-")
- (or (not (looking-at org-drawer-regexp))
- (not (save-excursion
- (re-search-forward
- "^[ \t]*:END:" limit t)))))))
- ;; Stop at comments.
- ((save-excursion
- (beginning-of-line)
- (not (looking-at "[ \t]*#\\S-"))) nil)
- ;; Skip incomplete dynamic blocks.
- ((save-excursion
- (beginning-of-line)
- (looking-at "[ \t]*#\\+BEGIN: "))
- (not (save-excursion
- (re-search-forward
- "^[ \t]*\\+END:" limit t))))
- ;; Skip incomplete blocks.
- ((save-excursion
- (beginning-of-line)
- (looking-at "[ \t]*#\\+BEGIN_\\(\\S-+\\)"))
- (not (save-excursion
- (re-search-forward
- (concat "^[ \t]*#\\+END_"
- (match-string 1))
- limit t))))
- ;; Skip incomplete latex environments.
- ((save-excursion
- (beginning-of-line)
- (looking-at "^[ \t]*\\\\begin{\\([A-Za-z0-9]+\\*?\\)}"))
- (not (save-excursion
- (re-search-forward
- (format "^[ \t]*\\\\end{%s}"
- (match-string 1))
- limit t))))
- ;; Skip ill-formed keywords.
- ((not (save-excursion
- (beginning-of-line)
- (looking-at "[ \t]*#\\+\\S-+:"))))))
- (re-search-forward org-element-paragraph-separate limit 'm))
- (if (eobp) (point) (goto-char (line-beginning-position)))))
+ (if (not (re-search-forward
+ org-element-paragraph-separate limit 'm))
+ limit
+ ;; A matching `org-element-paragraph-separate' is not
+ ;; necessarily the end of the paragraph. In
+ ;; particular, lines starting with # or : as a first
+ ;; non-space character are ambiguous. We have check
+ ;; if they are valid Org syntax (i.e. not an
+ ;; incomplete keyword).
+ (beginning-of-line)
+ (while (not
+ (or
+ ;; There's no ambiguity for other symbols or
+ ;; empty lines: stop here.
+ (looking-at "[ \t]*\\(?:[^:#]\\|$\\)")
+ ;; Stop at valid fixed-width areas.
+ (looking-at "[ \t]*:\\(?: \\|$\\)")
+ ;; Stop at drawers.
+ (and (looking-at org-drawer-regexp)
+ (save-excursion
+ (re-search-forward
+ "^[ \t]*:END:[ \t]*$" limit t)))
+ ;; Stop at valid comments.
+ (looking-at "[ \t]*#\\(?: \\|$\\)")
+ ;; Stop at valid dynamic blocks.
+ (and (looking-at org-dblock-start-re)
+ (save-excursion
+ (re-search-forward
+ "^[ \t]*#\\+END:?[ \t]*$" limit t)))
+ ;; Stop at valid blocks.
+ (and (looking-at
+ "[ \t]*#\\+BEGIN_\\(\\S-+\\)")
+ (save-excursion
+ (re-search-forward
+ (format "^[ \t]*#\\+END_%s[ \t]*$"
+ (match-string 1))
+ limit t)))
+ ;; Stop at valid latex environments.
+ (and (looking-at
+ "^[ \t]*\\\\begin{\\([A-Za-z0-9]+\\*?\\)}[ \t]*$")
+ (save-excursion
+ (re-search-forward
+ (format "^[ \t]*\\\\end{%s}[ \t]*$"
+ (match-string 1))
+ limit t)))
+ ;; Stop at valid keywords.
+ (looking-at "[ \t]*#\\+\\S-+:")
+ ;; Skip everything else.
+ (not
+ (progn
+ (end-of-line)
+ (re-search-forward org-element-paragraph-separate
+ limit 'm)))))
+ (beginning-of-line)))
+ (if (= (point) limit) limit
+ (goto-char (line-beginning-position)))))
(contents-end (progn (skip-chars-backward " \r\t\n" contents-begin)
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'paragraph
(nconc
(list :begin begin
(begin (point))
(post-blank (let ((before-blank (progn (forward-line) (point))))
(skip-chars-forward " \r\t\n" limit)
- (unless (eobp) (beginning-of-line))
+ (skip-chars-backward " \t")
+ (unless (bolp) (end-of-line))
(count-lines before-blank (point))))
(end (point))
closed deadline scheduled)
(hidden (org-invisible-p2))
(properties
(let (val)
- (while (not (looking-at "^[ \t]*:END:"))
+ (while (not (looking-at "^[ \t]*:END:[ \t]*$"))
(when (looking-at "[ \t]*:\\([A-Za-z][-_A-Za-z0-9]*\\):")
(push (cons (org-match-string-no-properties 1)
(org-trim
(point-at-bol)))
(pos-before-blank (progn (forward-line) (point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'property-drawer
(list :begin begin
:end end
Assume point is at the beginning of the block."
(let ((case-fold-search t))
- (if (not (save-excursion (re-search-forward "^[ \t]*#\\+END_SRC" limit t)))
+ (if (not (save-excursion (re-search-forward "^[ \t]*#\\+END_SRC[ \t]*$"
+ limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((contents-end (match-beginning 0)))
;; Get visibility status.
(hidden (progn (forward-line) (org-invisible-p2)))
;; Retrieve code.
- (value (buffer-substring-no-properties (point) contents-end))
+ (value (org-unescape-code-in-string
+ (buffer-substring-no-properties (point) contents-end)))
(pos-before-blank (progn (goto-char contents-end)
(forward-line)
(point)))
;; Get position after ending blank lines.
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'src-block
(nconc
(list :language language
(params (org-element-property :parameters src-block))
(value (let ((val (org-element-property :value src-block)))
(cond
-
(org-src-preserve-indentation val)
((zerop org-edit-src-content-indentation)
(org-remove-indentation val))
(concat (and lang (concat " " lang))
(and switches (concat " " switches))
(and params (concat " " params))))
- value
+ (org-escape-code-in-string value)
"#+END_SRC")))
(type (if (org-at-table.el-p) 'table.el 'org))
(keywords (org-element--collect-affiliated-keywords))
(begin (car keywords))
- (table-end (goto-char (marker-position (org-table-end t))))
+ (table-end
+ (if (re-search-forward org-table-any-border-regexp limit 'm)
+ (goto-char (match-beginning 0))
+ (point)))
(tblfm (let (acc)
(while (looking-at "[ \t]*#\\+TBLFM: +\\(.*\\)[ \t]*$")
(push (org-match-string-no-properties 1) acc)
acc))
(pos-before-blank (point))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'table
(nconc
(list :begin begin
Assume point is at beginning of the block."
(let ((case-fold-search t))
(if (not (save-excursion
- (re-search-forward "^[ \t]*#\\+END_VERSE" limit t)))
+ (re-search-forward "^[ \t]*#\\+END_VERSE[ \t]*$" limit t)))
;; Incomplete block: parse it as a paragraph.
(org-element-paragraph-parser limit)
(let ((contents-end (match-beginning 0)))
(forward-line)
(point)))
(end (progn (skip-chars-forward " \r\t\n" limit)
- (if (eobp) (point) (point-at-bol)))))
+ (skip-chars-backward " \t")
+ (if (bolp) (point) (line-end-position)))))
(list 'verse-block
(nconc
(list :begin begin
Return value is a cons cell whose CAR is `entity' or
`latex-fragment' and CDR is beginning position."
(save-excursion
+ (unless (bolp) (backward-char))
(let ((matchers
(remove "begin" (plist-get org-format-latex-options :matchers)))
;; ENTITY-RE matches both LaTeX commands and Org entities.
Return value is a cons cell whose CAR is either `subscript' or
`superscript' and CDR is beginning position."
(save-excursion
+ (unless (bolp) (backward-char))
(when (re-search-forward org-match-substring-regexp limit t)
(cons (if (string= (match-string 2) "_") 'subscript 'superscript)
(match-beginning 2)))))
type, as a symbol.
OBJECTS is the previous candidates alist."
+ ;; Filter out any object found but not belonging to RESTRICTION.
+ (setq objects
+ (org-remove-if-not
+ (lambda (obj)
+ (let ((type (car obj)))
+ (memq (or (cdr (assq type org-element-object-successor-alist))
+ type)
+ restriction)))
+ objects))
(let (next-candidates types-to-search)
;; If no previous result, search every object type in RESTRICTION.
;; Otherwise, keep potential candidates (old objects located after
(progn (beginning-of-line)
(skip-chars-forward "* ")
(setq end (point-at-eol))))
- (and (memq type '(paragraph table-cell verse-block))
+ (and (memq type '(paragraph table-row verse-block))
(let ((cbeg (org-element-property
:contents-begin element))
(cend (org-element-property
candidates)))
;; If ORIGIN is before next object in element, there's
;; no point in looking further.
- (if (> (cdr closest-cand) origin) (throw 'exit element)
+ (if (> (cdr closest-cand) origin) (throw 'exit parent)
(let* ((object
(progn (goto-char (cdr closest-cand))
(funcall (intern (format "org-element-%s-parser"
;; search to the end of its contents.
(t (goto-char cbeg)
(org-element-put-property object :parent parent)
- (setq parent object end cend)))))))
+ (setq parent object
+ restriction (org-element-restriction object)
+ end cend)))))))
parent))))))
(defsubst org-element-nested-p (elem-A elem-B)
(cdr overlays)))
(goto-char (org-element-property :end elem-B)))))
-
(provide 'org-element)
+
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-element.el ends here
(declare-function org-table-colgroup-line-p "org-table" (line))
(declare-function org-pop-to-buffer-same-window "org-compat"
(&optional buffer-or-name norecord label))
+(declare-function org-unescape-code-in-region "org-src" (beg end))
(autoload 'org-export-generic "org-export-generic" "Export using the generic exporter" t)
beg-content end-content
`(org-protected t original-indentation ,ind org-native-text t))
;; strip protective commas
- (org-strip-protective-commas beg-content end-content)
+ (org-unescape-code-in-region beg-content end-content)
(delete-region (match-beginning 0) (match-end 0))
(save-excursion
(goto-char beg)
org-archive-location
"org file:~/org/%s.org"))
-;;;###autoload
(defun org-insert-export-options-template ()
"Insert into the buffer a template with information for exporting."
(interactive)
(provide 'org-exp)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-exp.el ends here
:group 'org-faces)
(defface org-agenda-filter-tags
- (org-compatible-face 'modeline
+ (org-compatible-face 'mode-line
nil)
"Face for tag(s) in the mode-line when filtering the agenda."
:group 'org-faces)
(defface org-agenda-filter-category
- (org-compatible-face 'modeline
+ (org-compatible-face 'mode-line
nil)
"Face for tag(s) in the mode-line when filtering the agenda."
:group 'org-faces)
"Face used to highlight math latex and other special exporter stuff."
:group 'org-faces)
-(org-copy-face 'modeline 'org-mode-line-clock
+(org-copy-face 'mode-line 'org-mode-line-clock
"Face used for clock display in mode line.")
-(org-copy-face 'modeline 'org-mode-line-clock-overrun
+(org-copy-face 'mode-line 'org-mode-line-clock-overrun
"Face used for clock display for overrun tasks in mode line."
:background "red")
(provide 'org-feed)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-feed.el ends here
(provide 'org-footnote)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-footnote.el ends here
(provide 'org-freemind)
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
;;; org-freemind.el ends here
your own style information."
:group 'org-export-html
:type 'boolean)
+
;;;###autoload
(put 'org-export-html-style-include-default 'safe-local-variable 'booleanp)
(plist-get htmlize-buffer-places 'content-end)))
(kill-buffer htmlbuf))))
-;;;###autoload
(defun org-export-htmlize-generate-css ()
"Create the CSS for all font definitions in the current Emacs session.
Use this to create face definitions in your CSS style file that can then
(provide 'org-html)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-html.el ends here
(provide 'org-icalendar)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-icalendar.el ends here
(org-entry-put (point) "ID" nil))
(org-id-get (point) 'create))
-;;;###autoload
(defun org-id-copy ()
"Copy the ID of the entry at point to the kill ring.
Create an ID if necessary."
(org-id-add-location id (buffer-file-name (buffer-base-buffer)))
id)))))
-;;;###autoload
(defun org-id-get-with-outline-path-completion (&optional targets)
"Use outline-path-completion to retrieve the ID of an entry.
TARGETS may be a setting for `org-refile-targets' to define the eligible
(prog1 (org-id-get pom 'create)
(move-marker pom nil))))
-;;;###autoload
(defun org-id-get-with-outline-drilling (&optional targets)
"Use an outline-cycling interface to retrieve the ID of an entry.
This only finds entries in the current buffer, using `org-get-location'.
(provide 'org-id)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-id.el ends here
(provide 'org-indent)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-indent.el ends here
-;;; org-install.el --- Outline-based notes management and organizer
-;; Carstens outline-mode for keeping track of everything.
-;; Copyright (C) 2004-2012 Free Software Foundation, Inc.
+;;; org-install.el --- autogenerated file, do not edit
;;
-;; Author: Carsten Dominik <carsten at orgmode dot org>
-;; Keywords: outlines, hypermedia, calendar, wp
-;; Homepage: http://orgmode.org
-;; Version: 6.06b
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Commentary:
-;;
-;; When Org-mode is distributed with Emacs, this is just a dummy file.
-;; In an Org-mode distribution outside Emacs, this file would provide
-;; the autoloads. We include this dummy version in Emacs, so that people
-;; can leave a (require 'org-install) in .emacs, independently of
-;; which kind of distribution they use.
-;;
-
+;;; Code:
+(warn "The file org-install is obsolete.
+Please change your configuration to (require 'org) instead.")
+\f
(provide 'org-install)
-
+\f
+;; Local Variables:
+;; no-byte-compile: t
+;; coding: utf-8
+;; End:
;;; org-install.el ends here
(provide 'org-irc)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-irc.el ends here
--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))
+ (org-export-as-latex org-export-headline-levels))
;;;###autoload
(defun org-export-as-latex-to-buffer (arg)
"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*")
+ (org-export-as-latex arg nil "*Org LaTeX Export*")
(when org-export-show-temporary-export-buffer
(switch-to-buffer-other-window "*Org LaTeX Export*")))
(set-mark (point)) ;; to activate the region
(goto-char beg)
(setq rtn (org-export-as-latex
- nil nil ext-plist
+ nil ext-plist
buffer body-only))
(if (fboundp 'deactivate-mark) (deactivate-mark))
(if (and (org-called-interactively-p 'any) (bufferp rtn))
rtn)))
;;;###autoload
-(defun org-export-as-latex (arg &optional hidden ext-plist
- to-buffer body-only pub-dir)
+(defun org-export-as-latex (arg &optional ext-plist to-buffer body-only pub-dir)
"Export current buffer to a LaTeX file.
If there is an active region, export only the region. The prefix
ARG specifies how many levels of the outline should become
headlines. The default is 3. Lower levels will be exported
depending on `org-export-latex-low-levels'. The default is to
convert them as description lists.
-HIDDEN is obsolete and does nothing.
-EXT-PLIST is a property list with
-external parameters overriding org-mode's default settings, but
-still inferior to file-local settings. When TO-BUFFER is
-non-nil, create a buffer with that name and export to that
-buffer. If TO-BUFFER is the symbol `string', don't leave any
-buffer behind but just return the resulting LaTeX as a string.
+EXT-PLIST is a property list with external parameters overriding
+org-mode's default settings, but still inferior to file-local settings.
+When TO-BUFFER is non-nil, create a buffer with that name and export
+to that buffer. If TO-BUFFER is the symbol `string', don't leave any
+buffer behind and just return the resulting LaTeX as a string, with
+no LaTeX header.
When BODY-ONLY is set, don't produce the file header and footer,
simply return the content of \\begin{document}...\\end{document},
without even the \\begin{document} and \\end{document} commands.
(auto-insert nil); Avoid any auto-insert stuff for the new file
(TeX-master (boundp 'TeX-master))
(buffer (if to-buffer
- (cond
- ((eq to-buffer 'string) (get-buffer-create
- "*Org LaTeX Export*"))
- (t (get-buffer-create to-buffer)))
+ (if (eq to-buffer 'string)
+ (get-buffer-create "*Org LaTeX Export*")
+ (get-buffer-create to-buffer))
(find-file-noselect filename)))
(odd org-odd-levels-only)
(header (org-export-latex-make-header title opt-plist))
(interactive "P")
(message "Exporting to PDF...")
(let* ((wconfig (current-window-configuration))
- (lbuf (org-export-as-latex arg hidden ext-plist
- to-buffer body-only pub-dir))
+ (lbuf (org-export-as-latex arg ext-plist to-buffer body-only pub-dir))
(file (buffer-file-name lbuf))
(base (file-name-sans-extension (buffer-file-name lbuf)))
(pdffile (concat base ".pdf"))
(provide 'org-export-latex)
(provide 'org-latex)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-latex.el ends here
(require 'org-list)
(require 'format-spec)
-;;;###autoload
(defun org-lparse-and-open (target-backend native-backend arg
&optional file-or-buf)
"Export outline to TARGET-BACKEND via NATIVE-BACKEND and open exported file.
(when org-export-kill-product-buffer-when-displayed
(kill-buffer (current-buffer))))))
-;;;###autoload
(defun org-lparse-batch (target-backend &optional native-backend)
"Call the function `org-lparse'.
This function can be used in batch processing as:
(org-lparse target-backend native-backend
org-export-headline-levels 'hidden))
-;;;###autoload
(defun org-lparse-to-buffer (backend arg)
"Call `org-lparse' with output to a temporary buffer.
No file is created. The prefix ARG is passed through to
(when org-export-show-temporary-export-buffer
(switch-to-buffer-other-window tempbuf))))
-;;;###autoload
(defun org-replace-region-by (backend beg end)
"Assume the current region has org-mode syntax, and convert it to HTML.
This can be used in any buffer. For example, you could write an
(delete-region beg end)
(insert backend-string)))
-;;;###autoload
(defun org-lparse-region (backend beg end &optional body-only buffer)
"Convert region from BEG to END in org-mode buffer to HTML.
If prefix arg BODY-ONLY is set, omit file header, footer, and table of
(error "Don't know how to export to backend %s %s" target-backend
(format "via %s" native-backend)))
(run-hooks 'org-export-first-hook)
- (org-do-lparse arg hidden ext-plist to-buffer body-only pub-dir)
- (remove-hook 'org-export-preprocess-hook
- 'org-lparse-strip-experimental-blocks-maybe)
- (remove-hook 'org-export-preprocess-after-blockquote-hook
- 'org-lparse-preprocess-after-blockquote)))
+ (prog1
+ (org-do-lparse arg hidden ext-plist to-buffer body-only pub-dir)
+ (remove-hook 'org-export-preprocess-hook
+ 'org-lparse-strip-experimental-blocks-maybe)
+ (remove-hook 'org-export-preprocess-after-blockquote-hook
+ 'org-lparse-preprocess-after-blockquote))))
(defcustom org-lparse-use-flashy-warning nil
"Control flashing of messages logged with `org-lparse-warn'.
(eval-when-compile
(require 'browse-url))
+(declare-function browse-url-file-url "browse-url" (file))
+
(defun org-lparse-do-convert (in-file out-fmt &optional prefix-arg)
"Workhorse routine for `org-export-odt-convert'."
(require 'browse-url)
(provide 'org-lparse)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-lparse.el ends here
(let ((table '(?: ?/)))
(org-link-escape s table)))
-;;;###autoload
(defun org-mobile-create-sumo-agenda ()
"Create a file that contains all custom agenda views."
(interactive)
(provide 'org-mobile)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-mobile.el ends here
(defun org-export-odt-preprocess (parameters)
(org-export-odt-preprocess-label-references))
-(declare-function archive-zip-extract "arc-mode.el" (archive name))
+(declare-function archive-zip-extract "arc-mode" (archive name))
(defun org-odt-zip-extract-one (archive member &optional target)
(require 'arc-mode)
(let* ((target (or target default-directory))
(provide 'org-odt)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-odt.el ends here
(provide 'org-plot)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-plot.el ends here
(if force nil org-publish-use-timestamps-flag)))
(org-publish-projects org-publish-project-alist))))
-
;;;###autoload
(defun org-publish-current-file (&optional force)
"Publish the current file.
(provide 'org-publish)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-publish.el ends here
(provide 'org-remember)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-remember.el ends here
(declare-function org-at-table.el-p "org" ())
(declare-function org-get-indentation "org" (&optional line))
(declare-function org-switch-to-buffer-other-window "org" (&rest args))
-(declare-function org-strip-protective-commas "org" (beg end))
(declare-function org-pop-to-buffer-same-window
"org-compat" (&optional buffer-or-name norecord label))
-(declare-function org-strip-protective-commas "org" (beg end))
(declare-function org-base-buffer "org" (buffer))
(defcustom org-edit-src-region-extra nil
(error "Language mode `%s' fails with: %S" lang-f (nth 1 e)))))
(dolist (pair transmitted-variables)
(org-set-local (car pair) (cadr pair)))
- (if (derived-mode-p 'org-mode)
- (progn
- (goto-char (point-min))
- (while (re-search-forward "^," nil t)
- (if (eq (org-current-line) line) (setq total-nindent (1+ total-nindent)))
- (replace-match "")))
- (org-strip-protective-commas (point-min) (point-max)))
+ ;; Remove protecting commas from visible part of buffer.
+ (org-unescape-code-in-region (point-min) (point-max))
(when markline
(org-goto-line (1+ (- markline begline)))
(org-move-to-column
(goto-char pos)
(org-get-indentation)))
-(defun org-add-protective-commas (beg end &optional line)
- "Add protective commas in region.
-Return the delta in size of the region."
+(defun org-escape-code-in-region (beg end)
+ "Escape lines between BEG and END.
+Escaping happens when a line starts with \"*\", \"#+\", \",*\" or
+\",#+\" by appending a comma to it."
(interactive "r")
- (let ((org-re "^\\(.\\)")
- (other-re "^\\([*]\\|[ \t]*#\\+\\)")
- (delta 0))
- (save-excursion
- (goto-char beg)
- (while (re-search-forward (if (derived-mode-p 'org-mode) org-re other-re)
- end t)
- (if (and line (eq (org-current-line) line)) (setq delta (1+ delta)))
- (replace-match ",\\1")))
- delta))
+ (save-excursion
+ (goto-char beg)
+ (while (re-search-forward "^[ \t]*,?\\(\\*\\|#\\+\\)" end t)
+ (replace-match ",\\1" nil nil nil 1))))
+
+(defun org-escape-code-in-string (s)
+ "Escape lines in string S.
+Escaping happens when a line starts with \"*\", \"#+\", \",*\" or
+\",#+\" by appending a comma to it."
+ (replace-regexp-in-string "^[ \t]*,?\\(\\*\\|#\\+\\)" ",\\1" s nil nil 1))
+
+(defun org-unescape-code-in-region (beg end)
+ "Un-escape lines between BEG and END.
+Un-escaping happens by removing the first comma on lines starting
+with \",*\", \",#+\", \",,*\" and \",,#+\"."
+ (interactive "r")
+ (save-excursion
+ (goto-char beg)
+ (while (re-search-forward "^[ \t]*,?\\(,\\)\\(?:\\*\\|#\\+\\)" end t)
+ (replace-match "" nil nil nil 1))))
+
+(defun org-unescape-code-in-string (s)
+ "Un-escape lines in string S.
+Un-escaping happens by removing the first comma on lines starting
+with \",*\", \",#+\", \",,*\" and \",,#+\"."
+ (replace-regexp-in-string
+ "^[ \t]*,?\\(,\\)\\(?:\\*\\|#\\+\\)" "" s nil nil 1))
(defun org-edit-src-exit (&optional context)
"Exit special edit and protect problematic lines."
(goto-char (point-min))
(if (looking-at "\\s-*") (replace-match " ")))
(when (org-bound-and-true-p org-edit-src-from-org-mode)
- (setq delta (+ delta (org-add-protective-commas
- (point-min) (point-max) line))))
+ (org-escape-code-in-region (point-min) (point-max))
+ (setq delta (+ delta
+ (save-excursion
+ (org-goto-line line)
+ (if (looking-at "[ \t]*\\(,,\\)?\\(\\*\\|#+\\)") 1
+ 0)))))
(when (org-bound-and-true-p org-edit-src-picture)
(setq preserve-indentation nil)
(untabify (point-min) (point-max))
(kill-buffer buffer))
(goto-char beg)
(when allow-write-back-p
- (delete-region beg (1- end))
- (insert code)
- (delete-char 1)
+ (delete-region beg (max beg (1- end)))
+ (unless (string-match "^[ \t]*$" code)
+ (insert code)
+ (delete-char 1))
(goto-char beg)
(if single (just-one-space)))
(if (memq t (mapcar (lambda (overlay)
(concat "\\(" "@[-0-9I$]+" "\\|" "[a-zA-Z]\\{1,2\\}\\([0-9]+\\|&\\)" "\\)")
"Match a reference that needs translation, for reference display.")
+;;;###autoload
(defun org-table-create-with-table.el ()
"Use the table.el package to insert a new table.
If there is already a table at point, convert between Org-mode tables
(org-table-convert)))
(t (call-interactively 'table-insert))))
+;;;###autoload
(defun org-table-create-or-convert-from-region (arg)
"Convert region to table, or create an empty table.
If there is an active region, convert it to a table, using the function
(org-table-convert-region (region-beginning) (region-end) arg)
(org-table-create arg)))
+;;;###autoload
(defun org-table-create (&optional size)
"Query for a size and insert a table skeleton.
SIZE is a string Columns x Rows like for example \"3x2\"."
(goto-char pos)))
(org-table-align)))
+;;;###autoload
(defun org-table-convert-region (beg0 end0 &optional separator)
"Convert region to a table.
The region goes from BEG0 to END0, but these borders will be moved
(goto-char beg)
(org-table-align)))
+;;;###autoload
(defun org-table-import (file arg)
"Import FILE as a table.
The file is assumed to be tab-separated. Such files can be produced by most
(defvar org-table-last-alignment)
(defvar org-table-last-column-widths)
+;;;###autoload
(defun org-table-export (&optional file format)
"Export table to a file, with configurable format.
Such a file can be imported into usual spreadsheet programs.
(defconst org-narrow-column-arrow "=>"
"Used as display property in narrowed table columns.")
+;;;###autoload
(defun org-table-align ()
"Align the table at point by aligning all vertical bars."
(interactive)
(goto-char (match-beginning 0)))
(point-marker)))
+;;;###autoload
(defun org-table-justify-field-maybe (&optional new)
"Justify the current field, text to left, number to right.
Optional argument NEW may specify text to replace the current field content."
(setq org-table-may-need-update t))
(goto-char pos))))))
+;;;###autoload
(defun org-table-next-field ()
"Go to the next field in the current table, creating new lines as needed.
Before doing so, re-align the table if necessary."
(error
(org-table-insert-row 'below)))))
+;;;###autoload
(defun org-table-previous-field ()
"Go to the previous field in the table.
Before doing so, re-align the table if necessary."
(forward-char 1)))
(if (<= (point) pos) (org-table-end-of-field 2))))
+;;;###autoload
(defun org-table-next-row ()
"Go to the next row (same column) in the current table.
Before doing so, re-align the table if necessary."
(skip-chars-backward "^|\n\r")
(if (looking-at " ") (forward-char 1)))))
+;;;###autoload
(defun org-table-copy-down (n)
"Copy a field down in the current column.
If the field at the cursor is empty, copy into it the content of
val)
(forward-char 1) ""))
+;;;###autoload
(defun org-table-field-info (arg)
"Show info about the current field, and highlight any reference at point."
(interactive "P")
(message "In table column %d" cnt))
cnt)))
+;;;###autoload
(defun org-table-current-dline ()
"Find out what table data line we are in.
Only data lines count for this."
(message "This is table line %d" cnt))
cnt)))
+;;;###autoload
(defun org-table-goto-column (n &optional on-delim force)
"Move the cursor to the Nth column in the current table line.
With optional argument ON-DELIM, stop with point before the left delimiter
(backward-char 1)
(if (looking-at " ") (forward-char 1)))))
+;;;###autoload
(defun org-table-insert-column ()
"Insert a new column into the table."
(interactive)
(setq i (1+ i)))))
nil))
+;;;###autoload
(defun org-table-delete-column ()
"Delete a column from the table."
(interactive)
(org-table-fix-formulas "$LR" (list (cons (number-to-string col) "INVALID"))
col -1 col))))
+;;;###autoload
(defun org-table-move-column-right ()
"Move column to the right."
(interactive)
(org-table-move-column nil))
+;;;###autoload
(defun org-table-move-column-left ()
"Move column to the left."
(interactive)
(org-table-move-column 'left))
+;;;###autoload
(defun org-table-move-column (&optional left)
"Move the current column to the right. With arg LEFT, move to the left."
(interactive "P")
"$LR" (list (cons (number-to-string col) (number-to-string colpos))
(cons (number-to-string colpos) (number-to-string col)))))))
+;;;###autoload
(defun org-table-move-row-down ()
"Move table row down."
(interactive)
(org-table-move-row nil))
+;;;###autoload
(defun org-table-move-row-up ()
"Move table row up."
(interactive)
(org-table-move-row 'up))
+;;;###autoload
(defun org-table-move-row (&optional up)
"Move the current table line down. With arg UP, move it up."
(interactive "P")
"@" (list (cons (number-to-string dline1) (number-to-string dline2))
(cons (number-to-string dline2) (number-to-string dline1)))))))
+;;;###autoload
(defun org-table-insert-row (&optional arg)
"Insert a new row above the current line into the table.
With prefix ARG, insert below the current line."
(funcall org-table-fix-formulas-confirm "Fix formulas? "))
(org-table-fix-formulas "@" nil (1- (org-table-current-dline)) 1))))
+;;;###autoload
(defun org-table-insert-hline (&optional above)
"Insert a horizontal-line below the current line into the table.
With prefix ABOVE, insert above the current line."
(org-move-to-column col)
(and org-table-overlay-coordinates (org-table-align))))
+;;;###autoload
(defun org-table-hline-and-move (&optional same-column)
"Insert a hline and move to the row below that line."
(interactive "P")
t t s)))
s))
+;;;###autoload
(defun org-table-kill-row ()
"Delete the current row or horizontal line from the table."
(interactive)
(org-table-fix-formulas "@" (list (cons (number-to-string dline) "INVALID"))
dline -1 dline))))
+;;;###autoload
(defun org-table-sort-lines (with-case &optional sorting-type)
"Sort table lines according to the column at point.
(org-table-goto-column thiscol)
(message "%d lines sorted, based on column %d" (length lns) column)))
-
+;;;###autoload
(defun org-table-cut-region (beg end)
"Copy region in table to the clipboard and blank all relevant fields.
If there is no active region, use just the field at point."
(if (org-region-active-p) (region-end) (point))))
(org-table-copy-region beg end 'cut))
+;;;###autoload
(defun org-table-copy-region (beg end &optional cut)
"Copy rectangular region in table to clipboard.
A special clipboard is used which can only be accessed
(if cut (org-table-align))
org-table-clip))
+;;;###autoload
(defun org-table-paste-rectangle ()
"Paste a rectangular region into a table.
The upper right corner ends up in the current field. All involved fields
(org-table-goto-column col)
(org-table-align)))
+;;;###autoload
(defun org-table-convert ()
"Convert from `org-mode' table to table.el and back.
Obviously, this only works within limits. When an Org-mode table is
contents ""))
(org-table-align)))
+;;;###autoload
(defun org-table-wrap-region (arg)
"Wrap several fields in a column like a paragraph.
This is useful if you'd like to spread the contents of a field over several
(defvar org-field-marker nil)
+;;;###autoload
(defun org-table-edit-field (arg)
"Edit table field in a different window.
This is mainly useful for fields that contain hidden parts.
(defvar org-timecnt) ; dynamically scoped parameter
+;;;###autoload
(defun org-table-sum (&optional beg end nlast)
"Sum numbers in region of current table column.
The result will be displayed in the echo area, and will be available
(bs (org-table-formula-make-cmp-string (car b))))
(and as bs (string< as bs))))
+;;;###autoload
(defun org-table-get-stored-formulas (&optional noerror)
"Return an alist with the stored formulas directly after current table."
- (interactive)
+ (interactive) ;; FIXME interactive?
(let ((case-fold-search t) scol eq eq-alist strings string seen)
(save-excursion
(goto-char (org-table-end))
(setq org-table-local-parameters
(append org-table-local-parameters al2))))))
+;;;###autoload
(defun org-table-maybe-eval-formula ()
"Check if the current field starts with \"=\" or \":=\".
If yes, store the formula and apply it."
("_" . "Names for values in row below this one.")
("^" . "Names for values in row above this one.")))
+;;;###autoload
(defun org-table-rotate-recalc-marks (&optional newchar)
"Rotate the recalculation mark in the first column.
If in any row, the first field is not consistent with a mark,
(and (org-called-interactively-p 'interactive)
(message "%s" (cdr (assoc new org-recalc-marks))))))
+;;;###autoload
(defun org-table-maybe-recalculate-line ()
"Recompute the current line if marked for it, and if we haven't just done it."
(interactive)
(cons var (cons value org-tbl-calc-modes)))
org-tbl-calc-modes)
+;;;###autoload
(defun org-table-eval-formula (&optional arg equation
suppress-align suppress-const
suppress-store suppress-analysis)
elements
",") "]"))))
+;;;###autoload
(defun org-table-recalculate (&optional all noalign)
"Recalculate the current table line by applying all stored formulas.
With prefix arg ALL, do this for all lines in the table.
(or noalign (and org-table-may-need-update (org-table-align))
(and all (message "Re-applying formulas...done"))))))
+;;;###autoload
(defun org-table-iterate (&optional arg)
"Recalculate the table until it does not change anymore.
The maximum number of iterations is 10, but you can choose a different value
"Iterate all tables in the buffer, to converge inter-table dependencies."
(interactive)
(let* ((imax 10)
+ (i imax)
(checksum (md5 (buffer-string)))
-
- c1
- (i imax))
+ c1)
(save-excursion
(save-restriction
(widen)
(defvar org-pos)
+;;;###autoload
(defun org-table-edit-formulas ()
"Edit the formulas of the current table in a separate buffer."
(interactive)
(org-overlay-display ov str 'org-special-keyword 'evaporate)))
(beginning-of-line 2)))))
+;;;###autoload
(defun org-table-toggle-coordinate-overlays ()
"Toggle the display of Row/Column numbers in tables."
(interactive)
(mapc 'delete-overlay org-table-coordinate-overlays)
(setq org-table-coordinate-overlays nil)))
+;;;###autoload
(defun org-table-toggle-formula-debugger ()
"Toggle the formula debugger in tables."
(interactive)
(defvar orgtbl-mode-map (make-keymap)
"Keymap for `orgtbl-mode'.")
-;;;###autoload
-(defun turn-on-orgtbl ()
- "Unconditionally turn on `orgtbl-mode'."
- (orgtbl-mode 1))
-
(defvar org-old-auto-fill-inhibit-regexp nil
"Local variable used by `orgtbl-mode'.")
(*orgtbl-lfmt* *orgtbl-llfmt*))
(orgtbl-format-line prevline))))))
+;;;###autoload
(defun orgtbl-to-generic (table params)
"Convert the orgtbl-mode TABLE to some other format.
This generic routine can be used for many standard cases.
(remq nil *orgtbl-rtn*)
*orgtbl-rtn*)) "\n")))
+;;;###autoload
(defun orgtbl-to-tsv (table params)
"Convert the orgtbl-mode table to TAB separated material."
(orgtbl-to-generic table (org-combine-plists '(:sep "\t") params)))
+;;;###autoload
(defun orgtbl-to-csv (table params)
"Convert the orgtbl-mode table to CSV material.
This does take care of the proper quoting of fields with comma or quotes."
'(:sep "," :fmt org-quote-csv-field)
params)))
+;;;###autoload
(defun orgtbl-to-latex (table params)
"Convert the orgtbl-mode TABLE to LaTeX.
TABLE is a list, each entry either the symbol `hline' for a horizontal
:efmt "%s\\,(%s)" :hline "\\hline")))
(orgtbl-to-generic table (org-combine-plists params2 params))))
+;;;###autoload
(defun orgtbl-to-html (table params)
"Convert the orgtbl-mode TABLE to HTML.
TABLE is a list, each entry either the symbol `hline' for a horizontal
(setq html (replace-match "" t t html)))
html))
+;;;###autoload
(defun orgtbl-to-texinfo (table params)
"Convert the orgtbl-mode TABLE to TeXInfo.
TABLE is a list, each entry either the symbol `hline' for a horizontal
:hlstart "@headitem ")))
(orgtbl-to-generic table (org-combine-plists params2 params))))
+;;;###autoload
(defun orgtbl-to-orgtbl (table params)
"Convert the orgtbl-mode TABLE into another orgtbl-mode table.
Useful when slicing one table into many. The :hline, :sep,
(provide 'org-table)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-table.el ends here
(provide 'org-taskjuggler)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-taskjuggler.el ends here
(org-timer-secs-to-hms (or delta 0)))
(run-hooks 'org-timer-start-hook))))
-;;;###autoload
(defun org-timer-pause-or-continue (&optional stop)
"Pause or continue the relative timer.
With prefix arg STOP, stop it entirely."
(org-timer-set-mode-line 'pause)
(message "Timer paused at %s" (org-timer-value-string)))))
-;;;###autoload
(defun org-timer-stop ()
"Stop the relative timer."
(interactive)
(provide 'org-timer)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-timer.el ends here
(defun org-git-version ()
"The Git version of org-mode.
Inserted by installing org-mode or when a release is made."
- (let ((org-git-version "7.9.2-GNU-Emacs-24-3"))
+ (let ((org-git-version "release_7.9.2-68-g7a9d34"))
org-git-version))
;;;###autoload
-(defconst org-odt-data-dir "/usr/share/emacs/etc/org"
+(defvar org-odt-data-dir "/usr/share/emacs/etc/org"
"The location of ODT styles.")
\f
(provide 'org-version)
(provide 'org-xoxo)
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
;;; org-xoxo.el ends here
(require 'find-func)
(require 'format-spec)
+(load "org-loaddefs.el" t t)
+
;; `org-outline-regexp' ought to be a defconst but is let-binding in
;; some places -- e.g. see the macro org-with-limited-levels.
;;
(declare-function org-clock-timestamps-down "org-clock" ())
(declare-function org-clock-sum-current-item "org-clock" (&optional tstart))
+(declare-function orgtbl-mode "org-table" (&optional arg))
+(declare-function org-clock-out "org-clock" (&optional switch-to-state fail-quietly at-time))
+(declare-function org-beamer-mode "org-beamer" ())
+(declare-function org-table-edit-field "org-table" (arg))
+(declare-function org-table-justify-field-maybe "org-table" (&optional new))
+(declare-function org-id-get-create "org-id" (&optional force))
+(declare-function org-id-find-id-file "org-id" (id))
+(declare-function org-tags-view "org-agenda" (&optional todo-only match))
+(declare-function org-agenda-list "org-agenda" (&optional arg start-day span))
+(declare-function org-table-align "org-table" ())
+(declare-function org-table-paste-rectangle "org-table" ())
+(declare-function org-table-maybe-eval-formula "org-table" ())
+(declare-function org-table-maybe-recalculate-line "org-table" ())
+
;; load languages based on value of `org-babel-load-languages'
(defvar org-babel-load-languages)
+
;;;###autoload
(defun org-babel-do-load-languages (sym value)
"Load the languages defined in `org-babel-load-languages'."
;;; Version
(require 'org-compat)
(org-check-version)
+
;;;###autoload
(defun org-version (&optional here full message)
"Show the org-mode version in the echo area.
When MESSAGE is non-nil, display a message with the version."
(interactive "P")
(let* ((org-dir (ignore-errors (org-find-library-dir "org")))
- (org-install-dir (ignore-errors (org-find-library-dir "org-install.el")))
+ (org-install-dir (ignore-errors (org-find-library-dir "org-loaddefs.el")))
(org-trash (or
(and (fboundp 'org-release) (fboundp 'org-git-version))
(load (concat org-dir "org-version.el")
(if (string= org-dir org-install-dir)
org-install-dir
(concat "mixed installation! " org-install-dir " and " org-dir))
- "org-install.el can not be found!")))
+ "org-loaddefs.el can not be found!")))
(_version (if full version org-version)))
(if (org-called-interactively-p 'interactive)
(if here
:group 'org-agenda
:type 'sexp)
-(defcustom org-calendar-agenda-action-key [?k]
- "The key to be installed in `calendar-mode-map' for agenda-action.
-The command `org-agenda-action' will be bound to this key. The
-default is the character `k' because we use the same key in the agenda."
- :group 'org-agenda
- :type 'sexp)
-
(defcustom org-calendar-insert-diary-entry-key [?i]
"The key to be installed in `calendar-mode-map' for adding diary entries.
This option is irrelevant until `org-agenda-diary-file' has been configured
'(progn
(org-defkey calendar-mode-map org-calendar-to-agenda-key
'org-calendar-goto-agenda)
- (org-defkey calendar-mode-map org-calendar-agenda-action-key
- 'org-agenda-action)
(add-hook 'calendar-mode-hook
(lambda ()
(unless (eq org-agenda-diary-file 'diary-file)
(eval-and-compile
(org-autoload "org-table"
- '(org-table-align org-table-begin org-table-blank-field
- org-table-convert org-table-convert-region org-table-copy-down
- org-table-copy-region org-table-create
- org-table-create-or-convert-from-region
- org-table-create-with-table.el org-table-current-dline
- org-table-cut-region org-table-delete-column org-table-edit-field
- org-table-edit-formulas org-table-end org-table-eval-formula
- org-table-export org-table-field-info
- org-table-get-stored-formulas org-table-goto-column
- org-table-hline-and-move org-table-import org-table-insert-column
- org-table-insert-hline org-table-insert-row org-table-iterate
- org-table-justify-field-maybe org-table-kill-row
- org-table-maybe-eval-formula org-table-maybe-recalculate-line
- org-table-move-column org-table-move-column-left
- org-table-move-column-right org-table-move-row
- org-table-move-row-down org-table-move-row-up
- org-table-next-field org-table-next-row org-table-paste-rectangle
- org-table-previous-field org-table-recalculate
- org-table-rotate-recalc-marks org-table-sort-lines org-table-sum
- org-table-toggle-coordinate-overlays
- org-table-toggle-formula-debugger org-table-wrap-region
- orgtbl-mode turn-on-orgtbl org-table-to-lisp
- orgtbl-to-generic orgtbl-to-tsv orgtbl-to-csv orgtbl-to-latex
- orgtbl-to-orgtbl orgtbl-to-html orgtbl-to-texinfo)))
+ '(org-table-begin org-table-blank-field org-table-end)))
+
+;;;###autoload
+(defun turn-on-orgtbl ()
+ "Unconditionally turn on `orgtbl-mode'."
+ (require 'org-table)
+ (orgtbl-mode 1))
(defun org-at-table-p (&optional table-type)
"Return t if the cursor is inside an org-type table.
(declare-function org-default-export-plist "org-exp")
(declare-function org-infile-export-plist "org-exp")
(declare-function org-get-current-options "org-exp")
-(eval-and-compile
- (org-autoload "org-exp"
- '(org-export org-export-visible
- org-insert-export-options-template
- org-table-clean-before-export))
- (org-autoload "org-ascii"
- '(org-export-as-ascii org-export-ascii-preprocess
- org-export-as-ascii-to-buffer org-replace-region-by-ascii
- org-export-region-as-ascii))
- (org-autoload "org-latex"
- '(org-export-as-latex-batch org-export-as-latex-to-buffer
- org-replace-region-by-latex org-export-region-as-latex
- org-export-as-latex org-export-as-pdf
- org-export-as-pdf-and-open))
- (org-autoload "org-html"
- '(org-export-as-html-and-open
- org-export-as-html-batch org-export-as-html-to-buffer
- org-replace-region-by-html org-export-region-as-html
- org-export-as-html))
- (org-autoload "org-docbook"
- '(org-export-as-docbook-batch org-export-as-docbook-to-buffer
- org-replace-region-by-docbook org-export-region-as-docbook
- org-export-as-docbook-pdf org-export-as-docbook-pdf-and-open
- org-export-as-docbook))
- (org-autoload "org-icalendar"
- '(org-export-icalendar-this-file
- org-export-icalendar-all-agenda-files
- org-export-icalendar-combine-agenda-files))
- (org-autoload "org-xoxo" '(org-export-as-xoxo))
- (org-autoload "org-beamer" '(org-beamer-mode org-beamer-sectioning)))
;; Declare and autoload functions from org-agenda.el
(eval-and-compile
(org-autoload "org-agenda"
- '(org-agenda org-agenda-list org-search-view
- org-todo-list org-tags-view org-agenda-list-stuck-projects
- org-diary org-agenda-to-appt
- org-agenda-check-for-timestamp-as-reason-to-ignore-todo-item)))
-
-;; Autoload org-remember
+ '(org-agenda-check-for-timestamp-as-reason-to-ignore-todo-item)))
-(eval-and-compile
- (org-autoload "org-remember"
- '(org-remember-insinuate org-remember-annotation
- org-remember-apply-template org-remember org-remember-handler)))
-
-(eval-and-compile
- (org-autoload "org-capture"
- '(org-capture org-capture-insert-template-here
- org-capture-import-remember-templates)))
-
-;; Autoload org-clock.el
-
-(declare-function org-clock-save-markers-for-cut-and-paste "org-clock"
- (beg end))
+(declare-function org-clock-save-markers-for-cut-and-paste "org-clock" (beg end))
(declare-function org-clock-update-mode-line "org-clock" ())
(declare-function org-resolve-clocks "org-clock"
(&optional also-non-dangling-p prompt last-valid))
(marker-buffer org-clock-marker))
(eval-and-compile
- (org-autoload
- "org-clock"
- '(org-clock-in org-clock-out org-clock-cancel
- org-clock-goto org-clock-sum org-clock-display
- org-clock-remove-overlays org-clock-report
- org-clocktable-shift org-dblock-write:clocktable
- org-get-clocktable org-resolve-clocks)))
-
-(defun org-clock-update-time-maybe ()
- "If this is a CLOCK line, update it and return t.
-Otherwise, return nil."
- (interactive)
- (save-excursion
- (beginning-of-line 1)
- (skip-chars-forward " \t")
- (when (looking-at org-clock-string)
- (let ((re (concat "[ \t]*" org-clock-string
- " *[[<]\\([^]>]+\\)[]>]\\(-+[[<]\\([^]>]+\\)[]>]"
- "\\([ \t]*=>.*\\)?\\)?"))
- ts te h m s neg)
- (cond
- ((not (looking-at re))
- nil)
- ((not (match-end 2))
- (when (and (equal (marker-buffer org-clock-marker) (current-buffer))
- (> org-clock-marker (point))
- (<= org-clock-marker (point-at-eol)))
- ;; The clock is running here
- (setq org-clock-start-time
- (apply 'encode-time
- (org-parse-time-string (match-string 1))))
- (org-clock-update-mode-line)))
- (t
- (and (match-end 4) (delete-region (match-beginning 4) (match-end 4)))
- (end-of-line 1)
- (setq ts (match-string 1)
- te (match-string 3))
- (setq s (- (org-float-time
- (apply 'encode-time (org-parse-time-string te)))
- (org-float-time
- (apply 'encode-time (org-parse-time-string ts))))
- neg (< s 0)
- s (abs s)
- h (floor (/ s 3600))
- s (- s (* 3600 h))
- m (floor (/ s 60))
- s (- s (* 60 s)))
- (insert " => " (format (if neg "-%d:%02d" "%2d:%02d") h m))
- t))))))
+ (org-autoload "org-clock" '(org-clock-remove-overlays
+ org-clock-update-time-maybe
+ org-clocktable-shift)))
(defun org-check-running-clock ()
"Check if the current buffer contains the running clock.
(when (org-match-line "^[ \t]*#\\+BEGIN:[ \t]+clocktable\\>")
(org-clocktable-shift dir n)))
-;; Autoload org-timer.el
-
-(eval-and-compile
- (org-autoload
- "org-timer"
- '(org-timer-start org-timer org-timer-item
- org-timer-change-times-in-region
- org-timer-set-timer
- org-timer-reset-timers
- org-timer-show-remaining-time)))
-
-;; Autoload org-feed.el
-
-(eval-and-compile
- (org-autoload
- "org-feed"
- '(org-feed-update org-feed-update-all org-feed-goto-inbox)))
-
-
-;; Autoload org-indent.el
+;;;###autoload
+(defun org-clock-persistence-insinuate ()
+ "Set up hooks for clock persistence."
+ (require 'org-clock)
+ (add-hook 'org-mode-hook 'org-clock-load)
+ (add-hook 'kill-emacs-hook 'org-clock-save))
;; Define the variable already here, to make sure we have it.
(defvar org-indent-mode nil
"Non-nil if Org-Indent mode is enabled.
Use the command `org-indent-mode' to change this variable.")
-(eval-and-compile
- (org-autoload
- "org-indent"
- '(org-indent-mode)))
-
-;; Autoload org-mobile.el
-
-(eval-and-compile
- (org-autoload
- "org-mobile"
- '(org-mobile-push org-mobile-pull org-mobile-create-sumo-agenda)))
-
;; Autoload archiving code
;; The stuff that is needed for cycling and tags has to be defined here.
(eval-and-compile
(org-autoload "org-archive"
- '(org-add-archive-files org-archive-subtree
- org-archive-to-archive-sibling org-toggle-archive-tag
- org-archive-subtree-default
- org-archive-subtree-default-with-confirmation)))
+ '(org-add-archive-files)))
;; Autoload Column View Code
(declare-function org-columns-compute "org-colview" (property))
(org-autoload (if (featurep 'xemacs) "org-colview-xemacs" "org-colview")
- '(org-columns-number-to-string org-columns-get-format-and-top-level
- org-columns-compute org-agenda-columns org-columns-remove-overlays
- org-columns org-insert-columns-dblock org-dblock-write:columnview))
+ '(org-columns-number-to-string
+ org-columns-get-format-and-top-level
+ org-columns-compute
+ org-columns-remove-overlays))
;; Autoload ID code
(declare-function org-id-locations-save "org-id")
(defvar org-id-track-globally)
(org-autoload "org-id"
- '(org-id-get-create org-id-new org-id-copy org-id-get
- org-id-get-with-outline-path-completion
- org-id-get-with-outline-drilling org-id-store-link
- org-id-goto org-id-find org-id-store-link))
-
-;; Autoload Plotting Code
-
-(org-autoload "org-plot"
- '(org-plot/gnuplot))
+ '(org-id-new
+ org-id-copy
+ org-id-get-with-outline-path-completion
+ org-id-get-with-outline-drilling))
;;; Variables for pre-computed regular expressions, all buffer local
(lambda (&rest ignore) (org-show-context 'isearch))))
;; Turn on org-beamer-mode?
- (and org-startup-with-beamer-mode (org-beamer-mode 1))
+ (and org-startup-with-beamer-mode (org-beamer-mode))
;; Setup the pcomplete hooks
(set (make-local-variable 'pcomplete-command-completion-function)
t)
(t nil))))))
-(defun org-strip-protective-commas (beg end)
- "Strip protective commas between BEG and END in the current buffer."
- (interactive "r")
- (save-excursion
- (save-match-data
- (goto-char beg)
- (let ((front-line (save-excursion
- (re-search-forward
- "[^[:space:]]" end t)
- (goto-char (match-beginning 0))
- (current-column))))
- (while (re-search-forward "^[ \t]*\\(,\\)\\([*]\\|#\\)" end t)
- (goto-char (match-beginning 1))
- (when (= (current-column) front-line)
- (replace-match "" nil nil nil 1)))))))
-
(defun org-activate-angle-links (limit)
"Run through the buffer and add overlays to links."
(if (re-search-forward org-angle-link-re limit t)
(defvar org-cycle-subtree-status nil)
(make-variable-buffer-local 'org-cycle-subtree-status)
-;;;###autoload
-
(defvar org-inlinetask-min-level)
+;;;###autoload
(defun org-cycle (&optional arg)
"TAB-action and visibility cycling for Org-mode.
(defun org-link-unescape (str)
"Unhex hexified Unicode strings as returned from the JavaScript function
-encodeURIComponent. E.g. `%C3%B6' is the german Umlaut `ö'."
+encodeURIComponent. E.g. `%C3%B6' is the german o-Umlaut."
(unless (and (null str) (string= "" str))
(let ((pos 0) (case-fold-search t) unhexed)
(while (setq pos (string-match "\\(%[0-9a-f][0-9a-f]\\)+" str pos))
str)
(defun org-link-unescape-compound (hex)
- "Unhexify Unicode hex-chars. E.g. `%C3%B6' is the German Umlaut `ö'.
+ "Unhexify Unicode hex-chars. E.g. `%C3%B6' is the German o-Umlaut.
Note: this function also decodes single byte encodings like
-`%E1' (\"á\") if not followed by another `%[A-F0-9]{2}' group."
+`%E1' (a-acute) if not followed by another `%[A-F0-9]{2}' group."
(save-match-data
(let* ((bytes (cdr (split-string hex "%")))
(ret "")
(and org-auto-align-tags
(let ((org-loop-over-headlines-in-active-region nil))
(org-set-tags nil t)))
- (bookmark-set "org-refile-last-stored")
+ (with-demoted-errors
+ (bookmark-set "org-refile-last-stored"))
;; If we are refiling for capture, make sure that the
;; last-capture pointers point here
(when (org-bound-and-true-p org-refile-for-capture)
- (bookmark-set "org-capture-last-stored-marker")
+ (with-demoted-errors
+ (bookmark-set "org-capture-last-stored-marker"))
(move-marker org-capture-last-stored-marker (point)))
(if (fboundp 'deactivate-mark) (deactivate-mark))
(run-hooks 'org-after-refile-insert-hook))))
(org-refile-new-child parent-target child)))
(error "Invalid target location")))))
-(declare-function org-string-nw-p "org-macs.el" (s))
+(declare-function org-string-nw-p "org-macs" (s))
(defun org-refile-check-position (refile-pointer)
- "Check if the refile pointer matches the readline to which it points."
+ "Check if the refile pointer matches the headline to which it points."
(let* ((file (nth 1 refile-pointer))
(re (nth 2 refile-pointer))
(pos (nth 3 refile-pointer))
buffer)
- (when (org-string-nw-p re)
- (setq buffer (if (markerp pos)
- (marker-buffer pos)
- (or (find-buffer-visiting file)
- (find-file-noselect file))))
- (with-current-buffer buffer
- (save-excursion
- (save-restriction
- (widen)
- (goto-char pos)
- (beginning-of-line 1)
- (unless (org-looking-at-p re)
- (error "Invalid refile position, please clear the cache with `C-0 C-c C-w' before refiling"))))))))
+ (if (and (not (markerp pos)) (not file))
+ (error "Please save the buffer to a file before refiling")
+ (when (org-string-nw-p re)
+ (setq buffer (if (markerp pos)
+ (marker-buffer pos)
+ (or (find-buffer-visiting file)
+ (find-file-noselect file))))
+ (with-current-buffer buffer
+ (save-excursion
+ (save-restriction
+ (widen)
+ (goto-char pos)
+ (beginning-of-line 1)
+ (unless (org-looking-at-p re)
+ (error "Invalid refile position, please clear the cache with `C-0 C-c C-w' before refiling")))))))))
(defun org-refile-new-child (parent-target child)
"Use refile target PARENT-TARGET to add new CHILD below it."
(goto-char pos)
(error "Not in a dynamic block"))))
-;;;###autoload
(defun org-update-all-dblocks ()
"Update all dynamic blocks in the buffer.
This function can be used in a hook."
((equal ans ?D)
(call-interactively 'org-check-dates-range))
((equal ans ?t)
- (org-show-todo-tree nil))
+ (call-interactively 'org-show-todo-tree))
((equal ans ?T)
(org-show-todo-tree '(4)))
((member ans '(?T ?m))
;;;; The mapping API
-;;;###autoload
(defun org-map-entries (func &optional match scope &rest skip)
"Call FUNC at each headline selected by MATCH in SCOPE.
;; Help matching dotted european dates
(when (string-match
- "^ *\\(3[01]\\|0?[1-9]\\|[12][0-9]\\)\\. ?\\(0?[1-9]\\|1[012]\\)\\. ?\\([1-9][0-9][0-9][0-9]\\)?" ans)
- (setq year (if (match-end 3)
- (string-to-number (match-string 3 ans))
- (progn (setq kill-year t)
- (string-to-number (format-time-string "%Y"))))
+ "^ *\\(3[01]\\|0?[1-9]\\|[12][0-9]\\)\\. ?\\(0?[1-9]\\|1[012]\\)\\.\\( ?[1-9][0-9]\\{3\\}\\)?" ans)
+ (setq year (if (match-end 3) (string-to-number (match-string 3 ans))
+ (setq kill-year t)
+ (string-to-number (format-time-string "%Y")))
day (string-to-number (match-string 1 ans))
month (string-to-number (match-string 2 ans))
- ans (replace-match (format "%04d-%02d-%02d\\5" year month day)
+ ans (replace-match (format "%04d-%02d-%02d" year month day)
t nil ans)))
;; Help matching american dates, like 5/30 or 5/30/7
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)))
+ (let ((a1 '(("h" . hour)
+ ("d" . day)
+ ("w" . week)
+ ("m" . month)
+ ("y" . year)))
+ (shour (nth 2 (org-parse-time-string start)))
dn dw sday cday n1 n2 n0
d m y y1 y2 date1 date2 nmonths nm ny m2)
(error "Invalid change specifier: %s" change))
(if (eq dw 'week) (setq dw 'day dn (* 7 dn)))
(cond
+ ((eq dw 'hour)
+ (let ((missing-hours
+ (mod (+ (- (* 24 (- cday sday)) shour) org-extend-today-until)
+ dn)))
+ (setq n1 (if (zerop missing-hours) cday
+ (- cday (1+ (floor (/ missing-hours 24)))))
+ n2 (+ cday (floor (/ (- dn missing-hours) 24))))))
((eq dw 'day)
(setq n1 (+ sday (* dn (floor (/ (- cday sday) dn))))
n2 (+ n1 dn)))
(file-alist (mapcar (lambda (x)
(cons (file-truename x) x))
(org-agenda-files t)))
- (ctf (file-truename buffer-file-name))
+ (ctf (file-truename
+ (or buffer-file-name
+ (error "Please save the current buffer to a file"))))
x had)
(setq x (assoc ctf file-alist) had x)
Optional argument FILE means use this file instead of the current."
(interactive)
(let* ((org-agenda-skip-unavailable-files nil)
- (file (or file buffer-file-name))
+ (file (or file buffer-file-name
+ (error "Current buffer does not visit a file")))
(true-file (file-truename file))
(afile (abbreviate-file-name file))
(files (delq nil (mapcar
(defun org-check-agenda-file (file)
"Make sure FILE exists. If not, ask user what to do."
(when (not (file-exists-p file))
- (message "non-existent agenda file %s. [R]emove from list or [A]bort?"
+ (message "Non-existent agenda file %s. [R]emove from list or [A]bort?"
(abbreviate-file-name file))
(let ((r (downcase (read-char-exclusive))))
(cond
(org-defkey org-mode-map [?\C-c (control ?*)] 'org-list-make-subtree)
;;(org-defkey org-mode-map [?\C-c (control ?-)] 'org-list-make-list-from-subtree)
-(org-defkey org-mode-map "\C-c\C-x\C-k" 'org-mark-entry-for-agenda-action)
(org-defkey org-mode-map "\C-c\C-x\C-w" 'org-cut-special)
(org-defkey org-mode-map "\C-c\C-x\M-w" 'org-copy-special)
(org-defkey org-mode-map "\C-c\C-x\C-y" 'org-paste-special)
nil))))
(autoload 'org-element-at-point "org-element")
+(autoload 'org-element-type "org-element")
(declare-function org-element-at-point "org-element" (&optional keep-trail))
(declare-function org-element-type "org-element" (element))
-(declare-function org-element-context "org-element" ())
(declare-function org-element-contents "org-element" (element))
(declare-function org-element-property "org-element" (property element))
-(declare-function org-element-paragraph-parser "org-element" (limit))
(declare-function org-element-map "org-element" (data types fun &optional info first-match no-recursion))
(declare-function org-element-nested-p "org-element" (elem-a elem-b))
(declare-function org-element-swap-A-B "org-element" (elem-a elem-b))
;;;; Documentation
-;;;###autoload
(defun org-require-autoloaded-modules ()
(interactive)
(mapc 'require
(nth 2 date))))))
(or defd (current-time))))
-(defvar org-agenda-action-marker (make-marker)
- "Marker pointing to the entry for the next agenda action.")
-
-(defun org-mark-entry-for-agenda-action ()
- "Mark the current entry as target of an agenda action.
-Agenda actions are actions executed from the agenda with the key `k',
-which make use of the date at the cursor."
- (interactive)
- (move-marker org-agenda-action-marker
- (save-excursion (org-back-to-heading t) (point))
- (current-buffer))
- (message
- "Entry marked for action; press `k' at desired date in agenda or calendar"))
-
(defun org-mark-subtree (&optional up)
"Mark the current subtree.
This puts point at the start of the current subtree, and mark at
;; Check if auto-filling is meaningful.
(let ((fc (current-fill-column)))
(when (and fc (> (current-column) fc))
- (let ((fill-prefix (org-adaptive-fill-function)))
+ (let* ((fill-prefix (org-adaptive-fill-function))
+ ;; Enforce empty fill prefix, if required. Otherwise, it
+ ;; will be computed again.
+ (adaptive-fill-mode (not (equal fill-prefix ""))))
(when fill-prefix (do-auto-fill))))))
(defun org-comment-line-break-function (&optional soft)
(defun org-end-of-line (&optional arg)
"Go to the end of the line.
-If this is a headline, and `org-special-ctrl-a/e' is set, ignore tags on the
-first attempt, and only move to after the tags when the cursor is already
-beyond the end of the headline."
+If this is a headline, and `org-special-ctrl-a/e' is set, ignore
+tags on the first attempt, and only move to after the tags when
+the cursor is already beyond the end of the headline."
(interactive "P")
- (let ((special (if (consp org-special-ctrl-a/e)
- (cdr org-special-ctrl-a/e)
- org-special-ctrl-a/e)))
+ (let ((special (if (consp org-special-ctrl-a/e) (cdr org-special-ctrl-a/e)
+ org-special-ctrl-a/e))
+ (type (org-element-type
+ (save-excursion (beginning-of-line) (org-element-at-point)))))
(cond
- ((or (not special) arg
- (not (or (org-at-heading-p) (org-at-item-p) (org-at-drawer-p))))
+ ((or (not special) arg)
(call-interactively
- (cond ((org-bound-and-true-p line-move-visual) 'end-of-visual-line)
- ((fboundp 'move-end-of-line) 'move-end-of-line)
- (t 'end-of-line))))
- ((org-at-heading-p)
+ (if (fboundp 'move-end-of-line) 'move-end-of-line 'end-of-line)))
+ ((memq type '(headline inlinetask))
(let ((pos (point)))
- (beginning-of-line 1)
- (if (looking-at (org-re ".*?\\(?:\\([ \t]*\\)\\(:[[:alnum:]_@#%:]+:\\)?[ \t]*\\)?$"))
- (if (eq special t)
- (if (or (< pos (match-beginning 1))
- (= pos (match-end 0)))
- (goto-char (match-beginning 1))
- (goto-char (match-end 0)))
- (if (or (< pos (match-end 0)) (not (eq this-command last-command)))
- (goto-char (match-end 0))
- (goto-char (match-beginning 1))))
- (call-interactively (if (fboundp 'move-end-of-line)
- 'move-end-of-line
- 'end-of-line)))))
- ((org-at-drawer-p)
- (move-end-of-line 1)
- (when (overlays-at (1- (point))) (backward-char 1)))
- ;; At an item: Move before any hidden text.
- (t (call-interactively
- (cond ((org-bound-and-true-p line-move-visual) 'end-of-visual-line)
- ((fboundp 'move-end-of-line) 'move-end-of-line)
- (t 'end-of-line)))))
- (org-no-warnings
- (and (featurep 'xemacs) (setq zmacs-region-stays t)))))
+ (beginning-of-line 1)
+ (if (looking-at (org-re ".*?\\(?:\\([ \t]*\\)\\(:[[:alnum:]_@#%:]+:\\)?[ \t]*\\)?$"))
+ (if (eq special t)
+ (if (or (< pos (match-beginning 1)) (= pos (match-end 0)))
+ (goto-char (match-beginning 1))
+ (goto-char (match-end 0)))
+ (if (or (< pos (match-end 0))
+ (not (eq this-command last-command)))
+ (goto-char (match-end 0))
+ (goto-char (match-beginning 1))))
+ (call-interactively
+ (if (fboundp 'move-end-of-line) 'move-end-of-line 'end-of-line)))))
+ ((memq type
+ '(center-block comment-block drawer dynamic-block example-block
+ export-block item plain-list property-drawer
+ quote-block special-block src-block verse-block))
+ ;; Never move past the ellipsis.
+ (or (eolp) (move-end-of-line 1))
+ (when (org-invisible-p2) (backward-char)))
+ (t
+ (call-interactively
+ (if (fboundp 'move-end-of-line) 'move-end-of-line 'end-of-line))))
+ (org-no-warnings (and (featurep 'xemacs) (setq zmacs-region-stays t)))))
(define-key org-mode-map "\C-a" 'org-beginning-of-line)
(define-key org-mode-map "\C-e" 'org-end-of-line)
(if (< l level) (setq arg 1)))
(setq arg (1- arg)))))
-;;;###autoload
(defun org-forward-element ()
"Move forward by one element.
Move to the next element at the same level, when possible."
(goto-char (org-element-property :end parent))
(goto-char end))))))
-;;;###autoload
(defun org-backward-element ()
"Move backward by one element.
Move to the previous element at the same level, when possible."
((org-before-first-heading-p) (goto-char (point-min)))
(t (org-back-to-heading)))))))
-;;;###autoload
(defun org-up-element ()
"Move to upper element."
(interactive)
(error "No surrounding element")
(org-with-limited-levels (org-back-to-heading)))))))
-;;;###autoload
(defvar org-element-greater-elements)
(defun org-down-element ()
"Move to inner element."
(error "No content for this element"))))
(t (error "No inner element")))))
-;;;###autoload
(defun org-drag-element-backward ()
"Move backward element at point."
(interactive)
(goto-char (+ (org-element-property :begin prev-elem)
(- pos (org-element-property :begin elem)))))))))
-;;;###autoload
(defun org-drag-element-forward ()
"Move forward element at point."
(interactive)
(org-element-swap-A-B elem next-elem)
(goto-char (+ pos size-next size-blank))))))
-;;;###autoload
(defun org-mark-element ()
"Put point at beginning of this element, mark at end.
(push-mark (org-element-property :end element) t t)
(goto-char (org-element-property :begin element))))))
-;;;###autoload
(defun org-narrow-to-element ()
"Narrow buffer to current element."
(interactive)
(org-element-property :begin elem)
(org-element-property :end elem))))))
-;;;###autoload
(defun org-transpose-element ()
"Transpose current and previous elements, keeping blank lines between.
Point is moved after both elements."
(org-drag-element-backward)
(goto-char end)))
-;;;###autoload
(defun org-unindent-buffer ()
"Un-indent the visible part of the buffer.
Relative indentation (between items, inside blocks, etc.) isn't
projects / emacs.git / commitdiff