lisp/org-inlinetask.el

   1 ;;; org-inlinetask.el --- Tasks independent of outline hierarchy
   2
   3 ;; Copyright (C) 2009, 2010 Free Software Foundation, Inc.
   4 ;;
   5 ;; Author: Carsten Dominik <carsten at orgmode dot org>
   6 ;; Keywords: outlines, hypermedia, calendar, wp
   7 ;; Homepage: http://orgmode.org
   8 ;; Version: 7.3
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13
  14 ;; it under the terms of the GNU General Public License as published by
  15 ;; the Free Software Foundation, either version 3 of the License, or
  16 ;; (at your option) any later version.
  17
  18 ;; GNU Emacs is distributed in the hope that it will be useful,
  19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ;; GNU General Public License for more details.
  22
  23 ;; You should have received a copy of the GNU General Public License
  24 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  25
  26 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  27 ;;
  28 ;;; Commentary:
  29 ;;
  30 ;; This module implements inline tasks in Org-mode.  Inline tasks are
  31 ;; tasks that have all the properties of normal outline nodes, including
  32 ;; the ability to store meta data like scheduling dates, TODO state, tags
  33 ;; and properties.  However, these nodes are treated specially by the
  34 ;; visibility cycling and export commands.
  35 ;;
  36 ;; Visibility cycling exempts these nodes from cycling.  So whenever their
  37 ;; parent is opened, so are these tasks.  This will only work with
  38 ;; `org-cycle', so if you are also using other commands to show/hide
  39 ;; entries, you will occasionally find these tasks to behave like
  40 ;; all other outline nodes, seemingly splitting the text of the parent
  41 ;; into children.
  42 ;;
  43 ;; Export commands do not treat these nodes as part of the sectioning
  44 ;; structure, but as a special inline text that is either removed, or
  45 ;; formatted in some special way.
  46 ;;
  47 ;; Special fontification of inline tasks, so that they can be immediately
  48 ;; recognized.  From the stars of the headline, only the first and the
  49 ;; last two will be visible, the others will be hidden using the
  50 ;; `org-hide' face.
  51 ;;
  52 ;; An inline task is identified solely by a minimum outline level, given
  53 ;; by the variable `org-inlinetask-min-level', default 15.
  54 ;;
  55 ;; Inline tasks are normally assumed to contain at most a time planning
  56 ;; line (DEADLINE etc) after it, and then any number of drawers, for
  57 ;; example LOGBOOK of PROPERTIES.  No empty lines are allowed.
  58 ;; If you need to have normal text as part of an inline task, you
  59 ;; can do so by adding an "END" headline with the same number of stars,
  60 ;; for example
  61 ;;
  62 ;;    **************** TODO some small task
  63 ;;                     DEADLINE: <2009-03-30 Mon>
  64 ;;                     :PROPERTIES:
  65 ;;                       :SOMETHING: or other
  66 ;;                     :END:
  67 ;;                     And here is some extra text
  68 ;;    **************** END
  69 ;;
  70 ;; Also, if you want to use refiling and archiving for inline tasks,
  71 ;; The END line must be present to make things work properly.
  72 ;;
  73 ;; This package installs one new command:
  74 ;;
  75 ;; C-c C-x t      Insert a new inline task with END line
  76
  77 ;;; Code:
  78
  79 (require 'org)
  80
  81 (defgroup org-inlinetask nil
  82   "Options concerning inline tasks in Org mode."
  83   :tag "Org Inline Tasks"
  84   :group 'org-structure)
  85
  86 (defcustom org-inlinetask-min-level 15
  87   "Minimum level a headline must have before it is treated as an inline task.
  88 It is strongly recommended that you set `org-cycle-max-level' not at all,
  89 or to a number smaller than this one.  In fact, when `org-cycle-max-level' is
  90 not set, it will be assumed to be one less than the value of smaller than
  91 the value of this variable."
  92   :group 'org-inlinetask
  93   :type '(choice
  94           (const :tag "Off" nil)
  95           (integer)))
  96
  97 (defcustom org-inlinetask-export t
  98   "Non-nil means export inline tasks.
  99 When nil, they will not be exported."
 100   :group 'org-inlinetask
 101   :type 'boolean)
 102
 103 (defvar org-odd-levels-only)
 104 (defvar org-keyword-time-regexp)
 105 (defvar org-drawer-regexp)
 106 (defvar org-complex-heading-regexp)
 107 (defvar org-property-end-re)
 108
 109 (defcustom org-inlinetask-default-state nil
 110   "Non-nil means make inline tasks have a TODO keyword initially.
 111 This should be the state `org-inlinetask-insert-task' should use by
 112 default, or nil of no state should be assigned."
 113   :group 'org-inlinetask
 114   :type '(choice
 115           (const :tag "No state" nil)
 116           (string :tag "Specific state")))
 117
 118 (defun org-inlinetask-insert-task (&optional no-state)
 119   "Insert an inline task.
 120 If prefix arg NO-STATE is set, ignore `org-inlinetask-default-state'."
 121   (interactive "P")
 122   (or (bolp) (newline))
 123   (let ((indent org-inlinetask-min-level))
 124     (if org-odd-levels-only
 125         (setq indent (- (* 2 indent) 1)))
 126     (insert (make-string indent ?*)
 127             (if (or no-state (not org-inlinetask-default-state))
 128                 " \n"
 129               (concat " " org-inlinetask-default-state " \n"))
 130             (make-string indent ?*) " END\n"))
 131   (end-of-line -1))
 132 (define-key org-mode-map "\C-c\C-xt" 'org-inlinetask-insert-task)
 133
 134 (defun org-inlinetask-in-task-p ()
 135   "Return true if point is inside an inline task."
 136   (save-excursion
 137     (let* ((nstars (if org-odd-levels-only
 138                        (1- (* 2 (or org-inlinetask-min-level 200)))
 139                      (or org-inlinetask-min-level 200)))
 140            (stars-re (concat "^\\(?:\\*\\{"
 141                              (format "%d" (- nstars 1))
 142                              ",\\}\\)[ \t]+"))
 143            (task-beg-re (concat stars-re "\\(?:.*\\)"))
 144            (task-end-re (concat stars-re "\\(?:END\\|end\\)")))
 145       (beginning-of-line)
 146       (or (looking-at task-beg-re)
 147           (and (re-search-forward "^\\*+[ \t]+" nil t)
 148                (progn (beginning-of-line) (looking-at task-end-re)))))))
 149
 150 (defvar htmlp)  ; dynamically scoped into the next function
 151 (defvar latexp) ; dynamically scoped into the next function
 152 (defun org-inlinetask-export-handler ()
 153   "Handle headlines with level larger or equal to `org-inlinetask-min-level'.
 154 Either remove headline and meta data, or do special formatting."
 155   (goto-char (point-min))
 156   (let* ((nstars (if org-odd-levels-only
 157                      (1- (* 2 (or org-inlinetask-min-level 200)))
 158                    (or org-inlinetask-min-level 200)))
 159          (re1 (format "^\\(\\*\\{%d,\\}\\) .*\n" nstars))
 160          (re2 (concat "^[ \t]*" org-keyword-time-regexp))
 161          headline beg end stars content indent)
 162     (while (re-search-forward re1 nil t)
 163       (setq headline (match-string 0)
 164             stars (match-string 1)
 165             content nil)
 166       (replace-match "")
 167       (while (looking-at re2)
 168         (delete-region (point) (1+ (point-at-eol))))
 169       (while (looking-at org-drawer-regexp)
 170         (setq beg (point))
 171         (if (re-search-forward org-property-end-re nil t)
 172             (delete-region beg (1+ (match-end 0)))))
 173       (setq beg (point))
 174       (when (and (re-search-forward "^\\(\\*+\\) " nil t)
 175                  (= (length (match-string 1)) (length stars))
 176                  (progn (goto-char (match-end 0))
 177                         (looking-at "END[ \t]*$")))
 178         (setq content (buffer-substring beg (1- (point-at-bol))))
 179         (delete-region beg (1+ (match-end 0))))
 180       (goto-char beg)
 181       (when org-inlinetask-export
 182         (when (string-match org-complex-heading-regexp headline)
 183           (setq headline (concat
 184                           (if (match-end 2)
 185                               (concat
 186                                (org-add-props
 187                                    (format
 188                                     "@<span class=\"%s %s\"> %s@</span>"
 189                                     (if (member (match-string 2 headline)
 190                                                 org-done-keywords)
 191                                         "done" "todo")
 192                                     (match-string 2 headline)
 193                                     (match-string 2 headline))
 194                                    nil 'org-protected t)
 195                                " ") "")
 196                           (match-string 4 headline)))
 197           (when content
 198             (if (not (string-match "\\S-" content))
 199                 (setq content nil)
 200               (if (string-match "[ \t\n]+\\'" content)
 201                   (setq content (substring content 0 (match-beginning 0))))
 202               (setq content (org-remove-indentation content))
 203               (if latexp (setq content (concat "\\quad \\\\\n" content)))))
 204           (insert (make-string (org-inlinetask-get-current-indentation) ?\ )
 205                   "- ")
 206           (setq indent (make-string (current-column) ?\ ))
 207           (insert headline " ::")
 208           (if content
 209               (insert (if htmlp " " (concat "\n" indent))
 210                       (mapconcat 'identity (org-split-string content "\n")
 211                                  (concat "\n" indent)) "\n")
 212             (insert "\n"))
 213           (insert indent)
 214           (backward-delete-char 2)
 215           (insert "THISISTHEINLINELISTTEMINATOR\n"))))))
 216
 217 (defun org-inlinetask-get-current-indentation ()
 218   "Get the indentation of the last non-while line above this one."
 219   (save-excursion
 220     (beginning-of-line 1)
 221     (skip-chars-backward " \t\n")
 222     (beginning-of-line 1)
 223     (or (org-at-item-p)
 224         (looking-at "[ \t]*"))
 225     (goto-char (match-end 0))
 226     (current-column)))
 227
 228 (defun org-inlinetask-fontify (limit)
 229   "Fontify the inline tasks."
 230   (let* ((nstars (if org-odd-levels-only
 231                      (1- (* 2 (or org-inlinetask-min-level 200)))
 232                    (or org-inlinetask-min-level 200)))
 233          (re (concat "^\\(\\*\\)\\(\\*\\{"
 234                     (format "%d" (- nstars 3))
 235                     ",\\}\\)\\(\\*\\* .*\\)")))
 236     (while (re-search-forward re limit t)
 237       (add-text-properties (match-beginning 1) (match-end 1)
 238                            '(face org-warning font-lock-fontified t))
 239       (add-text-properties (match-beginning 2) (match-end 2)
 240                            '(face org-hide font-lock-fontified t))
 241       (add-text-properties (match-beginning 3) (match-end 3)
 242                            '(face shadow font-lock-fontified t)))))
 243
 244 (defun org-inlinetask-remove-END-maybe ()
 245   "Remove an END line when present."
 246   (when (looking-at (format "\\([ \t]*\n\\)*\\*\\{%d,\\}[ \t]+END[ \t]*$"
 247                             org-inlinetask-min-level))
 248     (replace-match "")))
 249
 250 (defun org-inlinetask-remove-terminator ()
 251   (let (beg end)
 252     (save-excursion
 253       (goto-char (point-min))
 254       (while (re-search-forward "THISISTHEINLINELISTTEMINATOR\n" nil t)
 255         (setq beg (match-beginning 0) end (match-end 0))
 256         (save-excursion
 257           (beginning-of-line 1)
 258           (and (looking-at "<p\\(ara\\)?>THISISTHEINLINELISTTEMINATOR[ \t\n]*</p\\(ara\\)?>")
 259                (setq beg (point) end (match-end 0))))
 260         (delete-region beg end)))))
 261
 262 (eval-after-load "org-exp"
 263   '(add-hook 'org-export-preprocess-after-tree-selection-hook
 264              'org-inlinetask-export-handler))
 265 (eval-after-load "org"
 266   '(add-hook 'org-font-lock-hook 'org-inlinetask-fontify))
 267 (eval-after-load "org-html"
 268   '(add-hook 'org-export-html-final-hook 'org-inlinetask-remove-terminator))
 269 (eval-after-load "org-latex"
 270   '(add-hook 'org-export-latex-final-hook 'org-inlinetask-remove-terminator))
 271 (eval-after-load "org-ascii"
 272   '(add-hook 'org-export-ascii-final-hook 'org-inlinetask-remove-terminator))
 273 (eval-after-load "org-docbook"
 274   '(add-hook 'org-export-docbook-final-hook 'org-inlinetask-remove-terminator))
 275
 276 (provide 'org-inlinetask)
 277
 278 ;;; org-inlinetask.el ends here