emacs: lisp/textmodes/org.el comparison

comparison lisp/textmodes/org.el @ 71310:0d8984127630

(org-agenda-mode-map): Add bindings for clocking functions. (org-agenda-clock-in, org-check-running-clock) (org-clock-out-if-current, org-remove-clock-overlays) (org-put-clock-overlay): New functions. (org-clock-marker, org-clock-file-total-minutes) (org-clock-overlays): New variables (org-clock-display, org-clock-sum, org-clock-cancel) (org-clock-out, org-clock-in): New commands. (org-export): New function. (org-emph-re): New constant. (org-set-emph-re, org-do-emphasis-faces): New functions. (org-emphasis-regexp-components, org-emphasis-alist): New options. (org-set-font-lock-defaults): Call `org-do-emphasis-faces'. (org-export-html-convert-emphasize): Use the configurable emphasis. (org-cleaned-string-for-export): Make multiline emphasis visible to the exporter. New optional argument PARAMETERS. (org-export-as-html): Specify :emph-multiline parameter to `org-cleaned-string-for-export'.

author	Carsten Dominik <dominik@science.uva.nl>
date	Sat, 10 Jun 2006 14:15:25 +0000
parents	11ad1dbc7d45
children	9853142939b3 138027c8c982

comparison

equal deleted inserted replaced

-:ac498715ccc8
+:0d8984127630
 ;; Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
 ;;
 ;; Author: Carsten Dominik <dominik at science dot uva dot nl>
 ;; Keywords: outlines, hypermedia, calendar, wp
 ;; Homepage: http://www.astro.uva.nl/~dominik/Tools/org/
-;; Version: 4.36
+;; Version: 4.36b
 ;;
 ;; 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
 ;; excellent reference card made by Philip Rooke.  This card can be found
 ;; in the etc/ directory of Emacs 22.
 ;;
 ;; Recent changes
 ;; --------------
+;; Version 4.37
+;;    - Clock-feature for measuring time spent on specific items.
+;;    - Improved emphasizing allows configuration and stacking.
+;;
 ;; Version 4.36
 ;;    - Improved indentation of ASCII export, when headlines become items.
 ;;    - Handling of 12am and 12pm fixed.  Times beyond 24:00 can be used
 ;;      and will not lead to conflicts.
 ;;    - Support for mutually exclusive TAGS with the fast tags interface.
 ;;    - `org-export-publishing-directory' can be an alist, with different
 ;;      directories for different export types.
 ;;    - All context-sensitive commands use `call-interactively' to dispatch.
 ;;    - `org-confirm-shell-links' renamed to `org-confirm-shell-link-function'.
 ;;    - Bug fixes.
 ;;
 ;; Version 4.31
 ;;    - Bug fixes.
 ;;
 ;; Version 4.30
 ;;    - Modified installation: Autoloads have been collected in org-install.el.
 ;;      entries that are sublevels of another TODO entry.
 ;;
 ;;
 ;;; Code:
 (eval-when-compile
 (require 'cl)
 (require 'calendar))
 (require 'outline)
 (require 'time-date)
 (require 'easymenu)
 ;;; Customization variables
-(defvar org-version "4.36"
+(defvar org-version "4.36b"
 "The version number of the file org.el.")
 (defun org-version ()
 (interactive)
 (message "Org-mode version %s" org-version))
 :group 'org-keywords
 :type 'string)
 (defcustom org-closed-string "CLOSED:"
 "String used as the prefix for timestamps logging closing a TODO entry."
+:group 'org-keywords
+:type 'string)
+(defcustom org-clock-string "CLOCK:"
+"String used as prefix for timestamps clocking work hours on an item."
 :group 'org-keywords
 :type 'string)
 (defcustom org-comment-string "COMMENT"
 "Entries starting with this keyword will never be exported.
 "Non-nil means fontify *bold*, /italic/ and _underlined_ text.
 Changing this variable requires a restart of Emacs to take effect."
 :group 'org-font-lock
 :type 'boolean)
+(defvar org-emph-re nil
+"Regular expression for matching emphasis.")
+(defvar org-emphasis-regexp-components) ; defined just below
+(defvar org-emphasis-alist) ; defined just below
+(defun org-set-emph-re (var val)
+"Set variable and compute the emphasis regular expression."
+(set var val)
+(when (and (boundp 'org-emphasis-alist)
+	     (boundp 'org-emphasis-regexp-components)
+	     org-emphasis-alist org-emphasis-regexp-components)
+(let* ((e org-emphasis-regexp-components)
+	   (pre (car e))
+	   (post (nth 1 e))
+	   (border (nth 2 e))
+	   (body (nth 3 e))
+	   (nl (nth 4 e))
+	   (stacked (nth 5 e))
+	   (body1 (concat body "*?"))
+	   (markers (mapconcat 'car org-emphasis-alist "")))
+;; make sure special characters appear at the right position in the class
+(if (string-match "\\^" markers)
+	  (setq markers (concat (replace-match "" t t markers) "^")))
+(if (string-match "-" markers)
+	  (setq markers (concat (replace-match "" t t markers) "-")))
+(while (>= (setq nl (1- nl)) 0) (setq body1 (concat body1 "\n?" body "*?")))
+;; Make the regexp
+(setq org-emph-re
+	    (concat "\\([" pre (if stacked markers) "]\\|^\\)"
+		    "\\("
+		    "\\([" markers "]\\)"
+		    "\\("
+		    "[^" border markers "]"
+		    body1
+		    "[^" border markers "]"
+		    "\\)"
+		    "\\3\\)"
+		    "\\([" post (if stacked markers) "]\\|$\\)")))))
+(defcustom org-emphasis-regexp-components
+'(" \t(" " \t.,?;:'\")" " \t\r\n,." "." 1 nil)
+"Components used to build the reqular expression for emphasis.
+This is a list with 6 entries.  Terminology:  In an emphasis string
+like \" *strong word* \", we call the initial space PREMATCH, the final
+space POSTMATCH, the stars MARKERS, \"s\" and \"d\" are BORDER characters
+and \"trong wor\" is the body.  The different components in this variable
+specify what is allowed/forbidden in each part:
+pre          Chars allowed as prematch.  Beginning of line will be allowed too.
+post         Chars allowed as postmatch.  End of line will be allowed too.
+border       The chars *forbidden* as border characters.  In addition to the
+characters given here, all marker characters are forbidden too.
+body-regexp  A regexp like \".\" to match a body character.  Don't use
+non-shy groups here, and don't allow newline here.
+newline      The maximum number of newlines allowed in an emphasis exp.
+stacked      Non-nil means, allow stacked styles.  This works only in HTML
+export.  When this is set, all marker characters (as given in
+`org-emphasis-alist') will be allowed as pre/post, aiding
+inside-out matching.
+Use customize to modify this, or restart emacs after changing it."
+:group 'org-fixme
+:set 'org-set-emph-re
+:type '(list
+	  (sexp    :tag "Allowed chars in pre      ")
+	  (sexp    :tag "Allowed chars in post     ")
+	  (sexp    :tag "Forbidden chars in border ")
+	  (sexp    :tag "Regexp for body           ")
+	  (integer :tag "number of newlines allowed")
+	  (boolean :tag "Stacking allowed          ")))
+(defcustom org-emphasis-alist
+'(("*" bold "<b>" "</b>")
+("/" italic "<i>" "</i>")
+("_" underline "<u>" "</u>")
+("=" shadow "<code>" "</code>"))
+"Special syntax for emphasised text.
+Text starting and ending with a special character will be emphasized, for
+example *bold*, _underlined_ and /italic/.  This variable sets the marker
+characters, the face to bbe used by font-lock for highlighting in Org-mode
+emacs buffers, and the HTML tags to be used for this.
+Use customize to modify this, or restart emacs after changing it."
+:group 'org-fixme
+:set 'org-set-emph-re
+:type '(repeat
+	  (list
+	   (string :tag "Marker character")
+	   (face :tag "Font-lock-face")
+	   (string :tag "HTML start tag")
+	   (string :tag "HTML end tag"))))
 (defgroup org-faces nil
 "Faces in Org-mode."
 :tag "Org Faces"
 :group 'org-font-lock)
 '(org-level-1 org-level-2 org-level-3 org-level-4
 org-level-5 org-level-6 org-level-7 org-level-8
 ))
 (defconst org-n-levels (length org-level-faces))
-(defconst org-bold-re
-(if (featurep 'xemacs)
-"\\([ ]\\|^\\)\\(\\*\\(\\w[a-zA-Z0-9-_ ]*?\\w\\)\\*\\)\\([ ,.]\\|$\\)"
-"\\([ ]\\|^\\)\\(\\*\\(\\w[[:word:] -_]*?\\w\\)\\*\\)\\([ ,.]\\|$\\)")
-"Regular expression for bold emphasis.")
-(defconst org-italic-re
-(if (featurep 'xemacs)
-"\\([ ]\\|^\\)\\(/\\(\\w[a-zA-Z0-9-_ ]*?\\w\\)/\\)\\([ ,.]\\|$\\)"
-"\\([ ]\\|^\\)\\(/\\(\\w[[:word:] -_]*?\\w\\)/\\)\\([ ,.]\\|$\\)")
-"Regular expression for italic emphasis.")
-(defconst org-underline-re
-(if (featurep 'xemacs)
-"\\([ ]\\|^\\)\\(_\\(\\w[a-zA-Z0-9-_ ]*?\\w\\)_\\)\\([ ,.]\\|$\\)"
-"\\([ ]\\|^\\)\\(_\\(\\w[[:word:] -_]*?\\w\\)_\\)\\([ ,.]\\|$\\)")
-"Regular expression for underline emphasis.")
 ;; Variables for pre-computed regular expressions, all buffer local
 (defvar org-done-string nil
 "The last string in `org-todo-keywords', indicating an item is DONE.")
 (make-variable-buffer-local 'org-done-string)
 	  org-closed-time-regexp
 	  (concat "\\<" org-closed-string " *\\[\\([^]]+\\)\\]")
 	  org-keyword-time-regexp
 	  (concat "\\<\\(" org-scheduled-string
 		  "\\|" org-deadline-string
-		  "\\|" org-closed-string "\\)"
+		  "\\|" org-closed-string
+		  "\\|" org-clock-string "\\)"
 		  " *[[<]\\([^]>]+\\)[]>]")
 	  org-maybe-keyword-time-regexp
 	  (concat "\\(\\<\\(" org-scheduled-string
 		  "\\|" org-deadline-string
-		  "\\|" org-closed-string "\\)\\)?"
+		  "\\|" org-closed-string
+		  "\\|" org-clock-string "\\)\\)?"
 		  " *\\([[<][0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\}[^]\r\n>]*?[]>]\\)"))
 (org-set-font-lock-defaults)))
 ;; Tell the compiler about dynamically scoped variables,
 (defvar org-ts-what) ; dynamically scoped parameter
 (defvar mark-active) ; Emacs only, not available in XEmacs.
 (defvar timecnt) ; dynamically scoped parameter
 (defvar levels-open) ; dynamically scoped parameter
 (defvar entry) ; dynamically scoped parameter
+(defvar state) ; dynamically scoped into `org-after-todo-state-change-hook'
 (defvar date) ; dynamically scoped parameter
 (defvar description) ; dynamically scoped parameter
 (defvar ans1) ; dynamically scoped parameter
 (defvar ans2) ; dynamically scoped parameter
 (defvar starting-day) ; local variable
 (defvar Info-current-file) ; from info.el
 (defvar Info-current-node) ; from info.el
 ;;; Define the mode
 (defvar org-mode-map
 (if (and (not (keymapp outline-mode-map)) (featurep 'allout))
 (error "Conflict with outdated version of allout.el.  Load org.el before allout.el, or ugrade to newer allout, for example by switching to Emacs 22.")
 (copy-keymap outline-mode-map))
 "Keymap for Org-mode.")
 ;;(setq outline-regexp "\\(?:\\*+\\|[ \t]*\\(?:[-+*]\\|[0-9]+[.)]\\) \\)")
 (setq outline-level 'org-outline-level)
 (when (and org-ellipsis (stringp org-ellipsis))
 (unless org-display-table
 (setq org-display-table (make-display-table)))
 (set-display-table-slot org-display-table
 			    4 (string-to-vector org-ellipsis))
 (setq buffer-display-table org-display-table))
 (org-set-regexps-and-options)
+(modify-syntax-entry ?# "<")
 (if org-startup-truncated (setq truncate-lines t))
 (set (make-local-variable 'font-lock-unfontify-region-function)
 'org-unfontify-region)
 ;; Activate before-change-function
 (set (make-local-variable 'org-table-may-need-update) t)
 (org-add-hook 'before-change-functions 'org-before-change-function nil
 		'local)
+;; Check for running clock before killing a buffer
+(org-add-hook 'kill-buffer-hook 'org-check-running-clock nil 'local)
 ;; Paragraphs and auto-filling
 (org-set-autofill-regexps)
 (org-update-radio-target-regexp)
 ;; Settings for Calc embedded mode
 (set (make-local-variable 'calc-embedded-open-formula) "|\\|\n")
 (require 'font-lock)
 (defconst org-non-link-chars "]\t\n\r<>")
 (defconst org-link-types '("https?" "ftp" "mailto" "file" "news" "bbdb" "vm"
 			   "wl" "mhe" "rmail" "gnus" "shell" "info" "elisp"))
 (defconst org-link-re-with-space
 (concat
 "<?\\(" (mapconcat 'identity org-link-types "\\|") "\\):"
 "\\([^" org-non-link-chars " ]"
 "[^" org-non-link-chars "]*"
 "[^" org-non-link-chars " ]\\)>?")
 "\\([^" org-non-link-chars " ]"
 "[^]\t\n\r]*"
 "[^" org-non-link-chars " ]\\)>?")
 "Matches a link with spaces, optional angular brackets around it.")
 (defconst org-angle-link-re
 (concat
 "<\\(" (mapconcat 'identity org-link-types "\\|") "\\):"
 "\\([^" org-non-link-chars " ]"
 "[^" org-non-link-chars "]*"
 "\\)>")
 (defconst org-tr-regexp (concat org-ts-regexp "--?-?" org-ts-regexp)
 "Regular expression matching a time stamp range.")
 (defconst org-tsr-regexp (concat org-ts-regexp "\\(--?-?"
 				 org-ts-regexp "\\)?")
 "Regular expression matching a time stamp or time stamp range.")
+(defvar org-�emph-face nil)
+(defun org-do-emphasis-faces (limit)
+"Run through the buffer and add overlays to links."
+(if (re-search-forward org-emph-re limit t)
+(progn
+	(font-lock-prepend-text-property (match-beginning 2) (match-end 2)
+					 'face
+					 (nth 1 (assoc (match-string 3)
+						       org-emphasis-alist)))
+	(add-text-properties (match-beginning 2) (match-end 2)
+			     '(font-lock-multiline t))
+	(backward-char 1)
+	t)))
 (defun org-activate-plain-links (limit)
 "Run through the buffer and add overlays to links."
 (if (re-search-forward org-plain-link-re limit t)
 (progn
 	   (list (concat "\\[#[A-Z]\\]") '(0 'org-special-keyword t))
 	   ;; Special keywords
 	   (list (concat "\\<" org-deadline-string) '(0 'org-special-keyword t))
 	   (list (concat "\\<" org-scheduled-string) '(0 'org-special-keyword t))
 	   (list (concat "\\<" org-closed-string) '(0 'org-special-keyword t))
+	   (list (concat "\\<" org-clock-string) '(0 'org-special-keyword t))
 	   ;; Emphasis
-	   (if em (list org-bold-re 2 ''bold 'prepend))
+	   (if em '(org-do-emphasis-faces))
-	   (if em (list org-italic-re 2 ''italic 'prepend))
-	   (if em (list org-underline-re 2 ''underline 'prepend))
 	   ;; Checkboxes, similar to Frank Ruell's org-checklet.el
 	   '("^[ \t]*\\([-+*]\\|[0-9]+[.)]\\) +\\(\\[[ X]\\]\\)"
 	     2 'bold prepend)
 	   ;; COMMENT
 	   (list (concat "^\\*+[ \t]*\\<\\(" org-comment-string
 (let* ((outline-regexp
 	  (if org-cycle-include-plain-lists
 	      "\\*+\\|\\([ \t]*\\)\\([-+*]\\|[0-9]+[.)]\\) "
 	    outline-regexp))
 	 (bob-special (and org-cycle-global-at-bob (bobp)
 			   (not (looking-at outline-regexp))))
 	 (org-cycle-hook (if bob-special nil org-cycle-hook))
 	 (pos (point)))
 (if (or bob-special (equal arg '(4)))
 (t (save-excursion
 	  (org-back-to-heading)
 	  (org-cycle))))))
 ;;;###autoload
-(defun org-global-cycle ()
+(defun org-global-cycle (&optional arg)
 "Cycle the global visibility.  For details see `org-cycle'."
-(interactive)
+(interactive "P")
-(org-cycle '(4)))
+(if (integerp arg)
+(progn
+	(show-all)
+	(hide-sublevels arg)
+	(setq org-cycle-global-status 'contents))
+(org-cycle '(4))))
 (defun org-overview ()
 "Switch to overview mode, shoing only top-level headlines.
 Really, this shows all headlines with level equal or greater than the level
 of the first headline in the buffer.  This is important, because if the
 			 (progn
 			   (org-back-to-heading)
 			   (match-string 0))
 		       (error "*"))))
 	     pos)
 	(cond
 	 ((and (org-on-heading-p) (bolp)
 	       (save-excursion (backward-char 1) (not (org-invisible-p))))
 	  (open-line 1))
-	 ((bolp) nil)
+	 ((and (bolp) (save-excursion
+			(backward-char 1) (not (org-invisible-p))))
+	  nil)
 	 (t (newline)))
 	(insert head) (just-one-space)
 	(setq pos (point))
 	(end-of-line 1)
 	(unless (= (point) pos) (just-one-space) (backward-delete-char 1))
 		    (outline-next-heading)
 		    (< (point) end))
 		  (not (eobp)))
 	(funcall fun)))))
+;; FIXME: this does not work well with Tabulators.  This has to be re-written entirely.
 (defun org-fixup-indentation (from to prohibit)
 "Change the indentation in the current entry by re-replacing FROM with TO.
 However, if the regexp PROHIBIT matches at all, don't do anything.
 This is being used to change indentation along with the length of the
 heading marker.  But if there are any lines which are not indented, nothing
 (org-end-of-item)
 (setq end (point))
 (setq ind1 (org-get-indentation))
 (unless (and (org-at-item-p) (= ind ind1))
 (goto-char pos)
 (error "On last item"))))
 (defun org-previous-item ()
 "Move to the beginning of the previous item in the current plain list.
 Error if not at a plain list, or if this is the last item in the list."
 (interactive)
 (goto-char (match-end 1))
 (setq col (current-column))
 (goto-char (1+ (match-end 0)))
 (if (and (not (looking-at outline-regexp))
 	       (looking-at (concat "[^\r\n]*?" org-keyword-time-regexp
-				   "[^\r\n]*")))
+				   "[^\r\n]*"))
+	       (not (equal (match-string 1) org-clock-string)))
 	  (narrow-to-region (match-beginning 0) (match-end 0))
 	(insert "\n")
 	(backward-char 1)
 	(narrow-to-region (point) (point))
 	(indent-to-column col))
 	       ((eq what 'deadline) org-deadline-string)
 	       ((eq what 'closed) org-closed-string))
 	 " ")
 	(insert
 	 (setq ts
 	       (format-time-string
 		(if (eq what 'closed)
 		    (concat "[" (substring (cdr org-time-stamp-formats) 1 -1) "]")
 		  (car org-time-stamp-formats))
 		time))))
 (goto-char (point-min))
 "Insert time stamp corresponding to cursor date in *Calendar* buffer.
 If there is already a time stamp at the cursor position, update it."
 (interactive)
 (org-timestamp-change 0 'calendar))
+;;; The clock for measuring work time.
+(defvar org-clock-marker (make-marker)
+"Marker recording the last clock-in.")
+(defun org-clock-in ()
+"Start the clock on the current item.
+If necessary, clock-out of the currently active clock."
+(interactive)
+(org-clock-out t)
+(let (ts)
+(save-excursion
+(org-back-to-heading t)
+(beginning-of-line 2)
+(if (and (looking-at (concat "[ \t]*" org-keyword-time-regexp))
+	       (not (equal (match-string 1) org-clock-string)))
+	  (beginning-of-line 1))
+(insert "\n") (backward-char 1)
+(indent-relative)
+(insert org-clock-string " "
+	      (setq ts (concat "[" (format-time-string
+				    (substring
+				     (cdr org-time-stamp-formats) 1 -1)
+				    (current-time))
+			       "]")))
+(move-marker org-clock-marker (point))
+(message "Clock started at %s" ts))))
+(defun org-clock-out (&optional fail-quietly)
+"Stop the currently running clock.
+If there is no running clock, throw an error, unless FAIL-QUIETLY is set."
+(interactive)
+(catch 'exit
+(if (not (marker-buffer org-clock-marker))
+(if fail-quietly (throw 'exit t) (error "No active clock")))
+(let (ts te s h m)
+(save-excursion
+(set-buffer (marker-buffer org-clock-marker))
+(goto-char org-clock-marker)
+(beginning-of-line 1)
+(if (and (looking-at (concat "[ \t]*" org-keyword-time-regexp))
+	       (equal (match-string 1) org-clock-string))
+	  (setq ts (match-string 2))
+	(if fail-quietly (throw 'exit nil) (error "Clock start time is gone")))
+(goto-char org-clock-marker)
+(setq te (concat "[" (format-time-string
+			    (substring
+			     (cdr org-time-stamp-formats) 1 -1)
+			    (current-time))
+		       "]"))
+(setq s (- (time-to-seconds (apply 'encode-time (org-parse-time-string te)))
+		 (time-to-seconds (apply 'encode-time (org-parse-time-string ts))))
+	    h (floor (/ s 3600))
+	    s (- s (* 3600 h))
+	    m (floor (/ s 60))
+	    s (- s (* 60 s)))
+(insert "--" te " => " (format "%2d:%02d" h m))
+(move-marker org-clock-marker nil)
+(message "Clock stopped at %s after HH:MM = %d:%02d" te h m)))))
+(defun org-clock-cancel ()
+"Cancel the running clock be removing the start timestamp."
+(interactive)
+(if (not (marker-buffer org-clock-marker))
+(error "No active clock"))
+(save-excursion
+(set-buffer (marker-buffer org-clock-marker))
+(goto-char org-clock-marker)
+(delete-region (1- (point-at-bol)) (point-at-eol)))
+(message "Clock canceled"))
+(defvar org-clock-file-total-minutes nil
+"Holds the file total time in minutes, after a call to `org-clock-sum'.")
+(make-variable-buffer-local 'org-clock-file-total-minutes)
+(defun org-clock-sum ()
+"Sum the times for each subtree.
+Puts the resulting times in minutes as a text property on each headline."
+(interactive)
+(remove-text-properties (point-min) (point-max) '(:org-clock-minutes t))
+(let* ((re (concat "^\\(\\*+\\)[ \t]\\|^[ \t]*"
+		     org-clock-string
+		     ".*=>[ \t]*\\([0-9]+\\):\\([0-9]+\\)[ \t]*$"))
+	 (lmax 30)
+	 (ltimes (make-vector lmax 0))
+	 (t1 0)
+	 (level 0)
+	 (lastlevel 0) time)
+(save-excursion
+(goto-char (point-max))
+(while (re-search-backward re nil t)
+	(if (match-end 2)
+	    ;; A time
+	    (setq t1 (+ t1 (* 60 (string-to-number (match-string 2)))
+			(string-to-number (match-string 3))))
+	  ;; A headline
+	  (setq level (- (match-end 1) (match-beginning 1)))
+	  (when (or (> t1 0) (> (aref ltimes level) 0))
+	    (loop for l from 0 to level do
+		  (aset ltimes l (+ (aref ltimes l) t1)))
+	    (setq t1 0 time (aref ltimes level))
+	    (loop for l from level to (1- lmax) do
+		  (aset ltimes l 0))
+	    (goto-char (match-beginning 0))
+	    (put-text-property (point) (point-at-eol) :org-clock-minutes time))))
+(setq org-clock-file-total-minutes (aref ltimes 0)))))
+(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
+in the echo area."
+(interactive)
+(org-remove-clock-overlays)
+(let (time h m p)
+(org-clock-sum)
+(unless total-only
+(save-excursion
+	(goto-char (point-min))
+	(while (setq p (next-single-property-change (point) :org-clock-minutes))
+	  (goto-char p)
+	  (when (setq time (get-text-property p :org-clock-minutes))
+	    (org-put-clock-overlay time (funcall outline-level))))
+	(setq h (/ org-clock-file-total-minutes 60)
+	      m (- org-clock-file-total-minutes (* 60 h)))
+	;; Arrange to remove the overlays upon next change.
+	(org-add-hook 'before-change-functions 'org-remove-clock-overlays
+		      nil 'local)))
+(message "Total file time: %d:%02d (%d hours and %d minutes)" h m h m)))
+(defvar org-clock-overlays nil)
+(defun org-put-clock-overlay (time &optional level)
+"Put an overlays on the current line, displaying TIME.
+If LEVEL is given, prefix time with a corresponding number of stars.
+This creates a new overlay and stores it in `org-clock-overlays', so that it
+will be easy to remove."
+(let* ((c 60) (h (floor (/ time 60))) (m (- time (* 60 h)))
+	 (l (if level (org-get-legal-level level 0) 0))
+	 (off 0)
+	 ov tx)
+(move-to-column c)
+(if (eolp) (setq off 1))
+(unless (eolp) (skip-chars-backward "^ \t"))
+(skip-chars-backward " \t")
+(setq ov (org-make-overlay (- (point) off) (point-at-eol))
+	  tx (concat (make-string (+ off (max 0 (- c (current-column)))) ?.)
+		     (org-add-props (format "%s %2d:%02d%s"
+					    (make-string l ?*) h m
+					    (make-string (- 10 l) ?\ ))
+			 '(face secondary-selection))
+		     ""))
+(org-overlay-put ov 'display tx)
+(push ov org-clock-overlays)))
+(defun org-remove-clock-overlays (&optional beg end noremove)
+"Remove the occur highlights from the buffer.
+BEG and END are ignored.  If NOREMOVE is nil, remove this function
+from the `before-change-functions' in the current buffer."
+(interactive)
+(mapc 'org-delete-overlay org-clock-overlays)
+(setq org-clock-overlays nil)
+(unless noremove
+(remove-hook 'before-change-functions
+		 'org-remove-clock-overlays 'local)))
+(defun org-clock-out-if-current ()
+"Clock out if the current entry contains the running clock.
+This is used to stop the clock after a TODO entry is marked DONE."
+(when (and (equal state org-done-string)
+	     (equal (marker-buffer org-clock-marker) (current-buffer))
+	     (< (point) org-clock-marker)
+	     (> (save-excursion (outline-next-heading) (point))
+		org-clock-marker))
+(org-clock-out)))
+(add-hook 'org-after-todo-state-change-hook
+	  'org-clock-out-if-current)
+(defun org-check-running-clock ()
+"Check if the current buffer contains the running clock.
+If yes, offer to stop it and to save the buffer with the changes."
+(when (and (equal (marker-buffer org-clock-marker) (current-buffer))
+	     (y-or-n-p (format "Clock-out in buffer %s before killing it? "
+			       (buffer-name))))
+(org-clock-out)
+(when (y-or-n-p "Save changed buffer?")
+(save-buffer))))
 ;;; Agenda, and Diary Integration
 ;;; Define the mode
 (defvar org-agenda-mode-map (make-sparse-keymap)
 (define-key org-agenda-mode-map "s" 'org-agenda-sunrise-sunset)
 (define-key org-agenda-mode-map "S" 'org-agenda-sunrise-sunset)
 (define-key org-agenda-mode-map "h" 'org-agenda-holidays)
 (define-key org-agenda-mode-map "H" 'org-agenda-holidays)
 (define-key org-agenda-mode-map "+" 'org-agenda-priority-up)
+(define-key org-agenda-mode-map "I" 'org-agenda-clock-in)
+(define-key org-agenda-mode-map "O" 'org-clock-out)
+(define-key org-agenda-mode-map "X" 'org-clock-cancel)
 (define-key org-agenda-mode-map "-" 'org-agenda-priority-down)
 (define-key org-agenda-mode-map (org-key 'S-up) 'org-agenda-priority-up)
 (define-key org-agenda-mode-map (org-key 'S-down) 'org-agenda-priority-down)
 (define-key org-agenda-mode-map [?\C-c ?\C-x (up)] 'org-agenda-priority-up)
 (define-key org-agenda-mode-map [?\C-c ?\C-x (down)] 'org-agenda-priority-down)
 		      'keymap org-agenda-keymap
 		      'help-echo
 		      (format "mouse-2 or RET jump to org file %s"
 			      (abbreviate-file-name buffer-file-name))))
 	 (regexp (concat
-		  "\\<" org-closed-string " *\\["
+		  "\\<\\(" org-closed-string "\\|" org-clock-string "\\) *\\["
 		  (regexp-quote
 		   (substring
 		    (format-time-string
 		     (car org-time-stamp-formats)
 		     (apply 'encode-time  ; DATE bound by calendar
 			    (list 0 0 0 (nth 1 date) (car date) (nth 2 date))))
 		    1 11))))
-	 marker hdmarker priority category tags
+	 marker hdmarker priority category tags closedp
 	 ee txt timestr)
 (goto-char (point-min))
 (while (re-search-forward regexp nil t)
 (if (not (save-match-data (org-at-date-range-p)))
 	  (progn
 	    (setq marker (org-agenda-new-marker (match-beginning 0))
+		  closedp (equal (match-string 1) org-closed-string)
 		  category (org-get-category (match-beginning 0))
 		  timestr (buffer-substring (match-beginning 0) (point-at-eol))
 		  ;; donep (org-entry-is-done-p)
 		  )
 	    (if (string-match "\\]" timestr)
 		    (goto-char (match-end 1))
 		    (setq hdmarker (org-agenda-new-marker)
 			  tags (org-get-tags-at))
 		    (looking-at "\\*+[ \t]*\\([^\r\n]+\\)")
 		    (setq txt (org-format-agenda-item
-			       "Closed:    "
+			       (if closedp "Closed:    " "Clocked:   ")
 			       (match-string 1) category tags timestr)))
 		(setq txt org-agenda-no-heading-message))
 	      (setq priority 100000)
 	      (org-add-props txt props
 		'org-marker marker 'org-hd-marker hdmarker 'face 'org-done
 		  (if (string-match org-looking-at-done-regexp head)
 		      (setq txt nil)
 		    (setq txt (org-format-agenda-item
 			       (format "In %3d d.: " diff) head category tags))))
 	      (setq txt org-agenda-no-heading-message))
 	    (when txt
 	      (setq face (cond ((<= diff 0) 'org-warning)
 			       ((<= diff 5) 'org-upcoming-deadline)
 			       (t nil)))
 	      (org-add-props txt props
 		'org-marker (org-agenda-new-marker pos)
 	;; Tags are in the string
 	(if (or (eq org-agenda-remove-tags-when-in-prefix t)
 		(and org-agenda-remove-tags-when-in-prefix
 		     org-prefix-has-tag))
 	    (setq txt (replace-match "" t t txt))
 	  (setq txt (replace-match
 		     (concat (make-string (max (- 50 (length txt)) 1) ?\ )
 			     (match-string 2 txt))
 		     t t txt))))
 ;; Create the final string
 (defun org-agenda-show-tags ()
 "Show the tags applicable to the current item."
 (interactive)
 (let* ((tags (get-text-property (point-at-bol) 'tags)))
 (if tags
 	(message "Tags are :%s:"
 		 (org-no-properties (mapconcat 'identity tags ":")))
 (message "No tags associated with this line"))))
 (defun org-agenda-goto (&optional highlight)
 "Go to the Org-mode file which contains the item at point."
 (save-match-data
 	(org-back-to-heading t)
 	(condition-case nil
 	    (while t
 	      (if (looking-at "[^\r\n]+?:\\([a-zA-Z_@0-9:]+\\):[ \t]*\\([\n\r]\\|\\'\\)")
 		  (setq tags (append (org-split-string
 				      (org-match-string-no-properties 1) ":")
 				     tags)))
 	      (or org-use-tag-inheritance (error ""))
 	      (org-up-heading-all 1))
 	  (error nil))))
 (and (memq (char-before) '(?\n ?\r)) (skip-chars-forward "^\n\r"))
 (if (and (re-search-backward "[\r\n]\\*" nil t)
 	     (looking-at "[\r\n]\\*+[ \t]+\\([^\r\n]*\\)"))
 	(match-string 1)
 "")))
+(defun org-agenda-clock-in (&optional arg)
+"Start the clock on the currently selected item."
+(interactive "P")
+(org-agenda-check-no-diary)
+(let* ((marker (or (get-text-property (point) 'org-marker)
+		     (org-agenda-error)))
+	 (buffer (marker-buffer marker))
+	 (pos (marker-position marker))
+	 (hdmarker (get-text-property (point) 'org-hd-marker)))
+(with-current-buffer (marker-buffer marker)
+(widen)
+(goto-char pos)
+(org-clock-in))))
 (defun org-agenda-diary-entry ()
 "Make a diary entry, like the `i' command from the calendar.
 All the standard commands work: block, weekly etc."
 (interactive)
 (org-fast-tag-insert "Inherited" inherited i-face "\n")
 (org-fast-tag-insert "Current" current c-face "\n\n")
 (setq tbl table char ?a cnt 0)
 (while (setq e (pop tbl))
 	(cond
 	 ((equal e '(:startgroup))
 	  (push '() groups) (setq ingroup t)
 	  (when (not (= cnt 0))
 	    (setq cnt 0)
 	    (insert "\n"))
 	  (insert "{ "))
 	  (setq tg (car e) c2 nil)
 	  (if (cdr e)
 	      (setq c (cdr e))
 	    ;; automatically assign a character.
 	    (setq c1 (string-to-char
 		      (downcase (substring
 				 tg (if (= (string-to-char tg) ?@) 1 0)))))
 	    (if (or (rassoc c1 ntable) (rassoc c1 table))
 		(while (or (rassoc char ntable) (rassoc char table))
 		  (setq char (1+ char)))
 	      (setq c2 c1))
 		(message "[key]:Toggle  SPC: clear current  RET accept%s"
 			 (if groups "  [!] ignore goups" ""))
 		(setq c (read-char-exclusive))
 		(cond
 		 ((= c ?\r) (throw 'exit t))
 		 ((= c ?!)
 		  (setq groups nil)
 		  (goto-char (point-min))
 		  (while (re-search-forward "[{}]" nil t) (replace-match " ")))
 		 ((or (= c ?\C-g)
 		      (and (= c ?q) (not (rassoc c ntable))))
 	(s0 (mapconcat 'identity (org-split-string s "[ \t\r\n]+") " "))
 	(pos (point))
 	(pre "") (post "")
 	words re0 re1 re2 re3 re4 re5 re2a reall camel)
 (cond
 ;; First check if there are any special
 ((run-hook-with-args-until-success 'org-execute-file-search-functions s))
 ;; Now try the builtin stuff
 ((save-excursion
 	(goto-char (point-min))
 	(and
 With arg query-description, ask at each match for a description text to use
 for this link."
 (interactive (list (y-or-n-p "Would you like to be queried for a description at each link?")))
 (save-excursion
 (goto-char (point-min))
 (let ((re (concat "\\([^[]\\)<\\("
 		      "\\(" (mapconcat 'identity org-link-types "\\|")
 		      "\\):"
 		      "[^" org-non-link-chars "]+\\)>"))
 	  l1 l2 (cnt 0))
 (while (re-search-forward re nil t)
 	(setq cnt (1+ cnt)
 		    (or (bbdb-record-name (bbdb-current-record))
 			(bbdb-record-company (bbdb-current-record))))
 	    link (org-make-link cpltxt)))
 ((eq major-mode 'Info-mode)
 (setq link (org-make-link "info:"
 				(file-name-nondirectory Info-current-file)
 				":" Info-current-node))
 (setq cpltxt (concat (file-name-nondirectory Info-current-file)
 			   ":" Info-current-node)))
 	     (<= (match-beginning 0) pos)
 	     (>= (match-end 0) pos)))
 ;; We do have a link at point, and we are going to edit it.
 (setq remove (list (match-beginning 0) (match-end 0)))
 (setq desc (if (match-end 3) (org-match-string-no-properties 3)))
 (setq link (read-string "Link: "
 			      (org-link-unescape
 			       (org-match-string-no-properties 1)))))
 (complete-file
 ;; Completing read for file names.
 (setq file (read-file-name "File: "))
 (let ((pwd (file-name-as-directory (expand-file-name ".")))
 	  (setq path (expand-file-name path)))
 	 ((eq org-link-file-path-type 'relative)
 	  (setq path (file-relative-name path)))
 	 (t
 	  (save-match-data
 	    (if (string-match (concat "^" (regexp-quote
 					   (file-name-as-directory
 					    (expand-file-name "."))))
 			      (expand-file-name path))
 		;; We are linking a file with relative path name.
 		(setq path (substring (expand-file-name path)
 (unless (string-match "\\S-" desc) (setq desc nil))
 (if remove (apply 'delete-region remove))
 (insert (org-make-link-string link desc))))
 (defun org-completing-read (&rest args)
 (let ((minibuffer-local-completion-map
 	 (copy-keymap minibuffer-local-completion-map)))
 (define-key minibuffer-local-completion-map " " 'self-insert-command)
 (apply 'completing-read args)))
 ;;; Hooks for remember.el
 		  (setq f1 (min fmax (or (string-match org-bracket-link-regexp xx) fmax)))
 		  (unless (> f1 1)
 		    (error "Cannot narrow field starting with wide link \"%s\""
 			   (match-string 0 xx)))
 		  (add-text-properties f1 (length xx) (list 'org-cwidth t) xx)
 		  (add-text-properties (- f1 2) f1
 				       (list 'display org-narrow-column-arrow)
 				       xx)))))
 ;; Get the maximum width for each column
 (push (apply 'max 1 (mapcar 'org-string-width column)) lengths)
 ;; Get the fraction of numbers, to decide about alignment of the column
 (error "Not at a table"))
 (let ((line (org-table-clean-line
 	       (buffer-substring (point-at-bol) (point-at-eol))))
 	(col (current-column)))
 (while (string-match "|\\( +\\)|" line)
 (setq line (replace-match
 		  (concat "+" (make-string (- (match-end 1) (match-beginning 1))
 					   ?-) "|") t t line)))
 (and (string-match "\\+" line) (setq line (replace-match "|" t t line)))
 (beginning-of-line (if arg 1 2))
 (insert line "\n")
 	  (text nil)
 	  p key val text options)
 (while (re-search-forward re nil t)
 	(setq key (org-match-string-no-properties 1)
 	      val (org-match-string-no-properties 2))
 	(cond
 	 ((string-equal key "TITLE") (setq p (plist-put p :title val)))
 	 ((string-equal key "AUTHOR")(setq p (plist-put p :author val)))
 	 ((string-equal key "EMAIL") (setq p (plist-put p :email val)))
 	 ((string-equal key "LANGUAGE") (setq p (plist-put p :language val)))
 	 ((string-equal key "TEXT")
 (setq p (plist-put p :text text))
 (when options
 	(let ((op '(("H"     . :headline-levels)
 		    ("num"   . :section-numbers)
 		    ("toc"   . :table-of-contents)
 		    ("\\n"   . :preserve-breaks)
 		    ("@"     . :expand-quoted-html)
 		    (":"     . :fixed-width)
 		    ("|"     . :tables)
 		    ("^"     . :sub-superscript)
 		    ("*"     . :emphasize)
 		    ("TeX"   . :TeX-macros)))
 	      o)
 	  (while (setq o (pop op))
 	    (if (string-match (concat (regexp-quote (car o))
 				      ":\\([^ \t\n\r;,.]*\\)")
 			      options)
 		(setq p (plist-put p (cdr o)
 				   (car (read-from-string
 					 (match-string 1 options)))))))))
 		      (not (string-match "| *[^ <|]" line)))))
 	;; a special table line that should be removed
 	)
 (t (setq rtn (cons line rtn)))))
 (nreverse rtn)))
+(defun org-export (&optional arg)
+(interactive)
+(let ((help "[t]   insert the export option template
+\[v]   limit export to visible part of outline tree
+\[a] export as ASCII
+\[h] export as HTML
+\[b] export as HTML and browse immediately
+\[x] export as XOXO
+\[i] export current file as iCalendar file
+\[I] export all agenda files as iCalendar files
+\[c] export agenda files into combined iCalendar file
+\[F] publish current file
+\[P] publish current project
+\[X] publish... (project will be prompted for)
+\[A] publish all projects")
+	(cmds
+	 '((?v . org-export-visible)
+	   (?a . org-export-as-ascii)
+	   (?h . org-export-as-html)
+	   (?b . org-export-as-html-and-open)
+	   (?x . org-export-as-xoxo)
+	   (?i . org-export-icalendar-this-file)
+	   (?I . org-export-icalendar-all-agenda-files)
+	   (?c . org-export-icalendar-combine-agenda-files)
+	   (?F . org-publish-current-file)
+	   (?P . org-publish-current-project)
+	   (?X . org-publish)
+	   (?A . org-publish-all)))
+	r1 r2 ass)
+(save-window-excursion
+(delete-other-windows)
+(with-output-to-temp-buffer "*Org Export/Publishing Help*"
+	(princ help))
+(message "Select command: ")
+(setq r1 (read-char-exclusive)))
+(setq r2 (if (< r1 27) (+ r1 96) r1))
+(if (setq ass (assq r2 cmds))
+	(call-interactively (cdr ass))
+(error "No command associated with key %c" r1))))
 ;; ASCII
 (defconst org-html-entities
 '(("nbsp")
 In that case, \"\\ent\" will be translated to \"&other;\".
 The list contains HTML entities for Latin-1, Greek and other symbols.
 It is supplemented by a number of commonly used TeX macros with appropriate
 translations.  There is currently no way for users to extend this.")
-(defun org-cleaned-string-for-export (string)
+(defun org-cleaned-string-for-export (string &rest parameters)
 "Cleanup a buffer substring so that links can be created safely."
 (interactive)
 (let* ((cb (current-buffer))
 	 (re-radio (and org-target-link-regexp
 			(concat "\\([^<]\\)\\(" org-target-link-regexp "\\)")))
 	(goto-char (match-beginning 0)))
 ;; Normalize links: Convert angle and plain links into bracket links
 (goto-char (point-min))
 (while (re-search-forward re-plain-link nil t)
 	(replace-match
 	 (concat
 	  (match-string 1) "[[" (match-string 2) ":" (match-string 3) "]]")
 	 t t))
 (goto-char (point-min))
 (while (re-search-forward re-angle-link nil t)
 	(replace-match
 	 (concat
 	  (match-string 1) "[[" (match-string 2) ":" (match-string 3) "]]")
 	 t t))
+;; Find multiline emphasis and put them into single line
+(when (assq :emph-multiline parameters)
+	(goto-char (point-min))
+	(while (re-search-forward org-emph-re nil t)
+	  (subst-char-in-region (match-beginning 0) (match-end 0) ?\n ?\  t)
+	  (goto-char (1- (match-end 0)))))
 ;; Remove comments
 (goto-char (point-min))
 (while (re-search-forward "^#.*\n?" nil t)
 	(replace-match ""))
 	 (level 0) line txt
 	 (umax nil)
 	 (case-fold-search nil)
 (filename (concat (file-name-as-directory
 			    (org-export-directory :ascii opt-plist))
 			   (file-name-sans-extension
 			    (file-name-nondirectory buffer-file-name))
 			   ".txt"))
 	 (buffer (find-file-noselect filename))
 	 (levels-open (make-vector org-level-max nil))
 	 (odd org-odd-levels-only)
 (erase-buffer)
 (fundamental-mode)
 ;; create local variables for all options, to make sure all called
 ;; functions get the correct information
 (mapcar (lambda (x)
 	      (set (make-local-variable (cdr x))
 		   (plist-get opt-plist (car x))))
 	    org-export-plist-vars)
 (set (make-local-variable 'org-odd-levels-only) odd)
 (setq umax (if arg (prefix-numeric-value arg)
 		 org-export-headline-levels))
 ((string-match "^\\(\\*+\\)[ \t]*\\(.*\\)" line)
 	;; a Headline
 	(setq level (org-tr-level (- (match-end 1) (match-beginning 1)))
 	      txt (match-string 2 line))
 	(org-ascii-level-start level txt umax lines))
 (t
 	(insert (org-fix-indentation line org-ascii-current-indentation) "\n"))))
 (normal-mode)
 (save-buffer)
 ;; remove display and invisible chars
 (let (beg end s)
 (defun org-ascii-level-start (level title umax &optional lines)
 "Insert a new level in ASCII export."
 (let (char (n (- level umax 1)) (ind 0))
 (if (> level umax)
 	(progn
 	  (insert (make-string (* 2 n) ?\ )
 		  (char-to-string (nth (% n (length org-export-ascii-bullets))
 				       org-export-ascii-bullets))
 		  " " title "\n")
 	  ;; find the indentation of the next non-empty line
 	  (catch 'stop
 run the export command - in interactive use, the command prompts for this
 key.  As a special case, if the you type SPC at the prompt, the temporary
 org-mode file will not be removed but presented to you so that you can
 continue to use it.  The prefix arg ARG is passed through to the exporting
 command."
 (interactive
 (list (progn
 	   (message "Export visible: [a]SCII  [h]tml  [b]rowse HTML  [x]OXO  [ ]keep buffer")
 	   (char-to-string (read-char-exclusive)))
 	 current-prefix-arg))
 (if (not (member type '("a" "\C-a" "b" "\C-b" "h" "x" " ")))
 (error "Invalid export key"))
+;; FIXME: do this more explicit?
 (let* ((binding (key-binding (concat "\C-c\C-x" type)))
 	 (keepp (equal type " "))
 	 (file buffer-file-name)
 	 (buffer (get-buffer-create "*Org Export Visible*"))
 	 s e)
 (setq-default org-deadline-line-regexp org-deadline-line-regexp)
 (setq-default org-done-string org-done-string)
 (let* ((opt-plist (org-combine-plists (org-default-export-plist)
 					ext-plist
 					(org-infile-export-plist)))
 	 (style (plist-get opt-plist :style))
 	 (odd org-odd-levels-only)
 	 (region-p (org-region-active-p))
 (region
 (buffer-substring
 (if region-p (region-beginning) (point-min))
 (if region-p (region-end) (point-max))))
 (all_lines
 (org-skip-comments (org-split-string
-			      (org-cleaned-string-for-export region)
+			      (org-cleaned-string-for-export
+			       region :emph-multiline)
 			      "[\r\n]")))
 (lines (org-export-find-first-heading-line all_lines))
 (level 0) (line "") (origline "") txt todo
 (umax nil)
 (filename (concat (file-name-as-directory
 			    (org-export-directory :html opt-plist))
 			   (file-name-sans-extension
 			    (file-name-nondirectory buffer-file-name))
 			   ".html"))
 (buffer (find-file-noselect filename))
 (levels-open (make-vector org-level-max nil))
 	 (date (format-time-string "%Y/%m/%d" (current-time)))
 (let ((case-fold-search nil)
 	  (org-odd-levels-only odd))
 ;; create local variables for all options, to make sure all called
 ;; functions get the correct information
 (mapcar (lambda (x)
 		(set (make-local-variable (cdr x))
 		     (plist-get opt-plist (car x))))
 	      org-export-plist-vars)
 (setq umax (if arg (prefix-numeric-value arg)
 org-export-headline-levels))
 		     thefile file-is-image-p search)
 		(save-match-data
 		  (if (string-match "::\\(.*\\)" filename)
 		      (setq search (match-string 1 filename)
 			    filename (replace-match "" t nil filename)))
 		  (setq file-is-image-p
 			(string-match (org-image-file-name-regexp) filename))
 		  (setq thefile (if abs-p (expand-file-name filename) filename))
 		  (when (and org-export-html-link-org-files-as-html
 			     (string-match "\\.org$" thefile))
 		    (setq thefile (concat (substring thefile 0
 		    (if (and search
 			     ;; make sure this is can be used as target search
 			     (not (string-match "^[0-9]*$" search))
 			     (not (string-match "^\\*" search))
 			     (not (string-match "^/.*/$" search)))
 			(setq thefile (concat thefile "#"
 					      (org-solidify-link-text
 					       (org-link-unescape search)))))
 		    (when (string-match "^file:" desc)
 		      (setq desc (replace-match "" t t desc))
 		      (if (string-match "\\.org$" desc)
 		    ((= llt ?\)) "^\\( \t]*\\)\\(\\([-+*]\\)\\|\\([0-9]+)\\) \\)?\\( *[^ \t\n\r]\\|[ \t]*$\\)")
 		    (t (error "Invalid value of `org-plain-list-ordered-item-terminator'")))
 		   line)
 	      (setq ind (org-get-string-indentation line)
 		    start-is-num (match-beginning 4)
 		    starter (if (match-beginning 2)
 				(substring (match-string 2 line) 0 -1))
 		    line (substring line (match-beginning 5)))
 	      (unless (string-match "[^ \t]" line)
 		;; empty line.  Pretend indentation is large.
 		(setq ind (1+ (or (car local-list-indent) 1))))
 	       (starter
 		;; continue current list
 		(org-close-li)
 		(insert "<li>\n")))
 	      (if (string-match "^[ \t]*\\[\\([X ]\\)\\]" line)
 		  (setq line
 			(replace-match
 			 (if (equal (match-string 1 line) "X")
 			     "<b>[X]</b>"
 			   "<b>[<span style=\"visibility:hidden;\">X</span>]</b>")
 			   t t line))))
 	      (setq line (replace-match "<br/>" t t line)))
 	     (org-export-preserve-breaks
 	      (setq line (concat line "<br/>"))))
 	    (insert line "\n")))))
 ;; Properly close all local lists and other lists
 (when inquote (insert "</pre>\n"))
 (when in-local-list
 	;; Close any local lists before inserting a new header line
 	(while local-list-num
 	  (insert "</p>\n"))
 	(when (and date time)
 	  (insert "<p class=\"date\"> "
 		  (nth 2 lang-words) ": "
 		  date " " time "</p>\n")))
 (if org-export-html-with-timestamp
 	  (insert org-export-html-html-helper-timestamp))
 (insert (or (plist-get opt-plist :postamble) ""))
 (insert "</body>\n</html>\n")
 (normal-mode)
 (while (string-match org-maybe-keyword-time-regexp s)
 (or b (setq b (substring s 0 (match-beginning 0))))
 (if (not org-export-with-timestamps)
 	  (setq r (concat r (substring s 0 (match-beginning 0)))
 		s (substring s (match-end 0)))
 	(setq r (concat
 		 r (substring s 0 (match-beginning 0))
 		 (if (match-end 1)
 		     (format "@<span class=\"timestamp-kwd\">%s @</span>"
 			     (match-string 1 s)))
 		 (format " @<span class=\"timestamp\">%s@</span>"
 			 (substring (match-string 3 s) 1 -1)))
 	      s (substring s (match-end 0)))))
 (while (string-match "\\\\\\([_^]\\)" string)
 (setq string (replace-match (match-string 1 string) t t string))))
 string)
 (defun org-export-html-convert-emphasize (string)
-(while (string-match org-italic-re string)
+"Apply emphasis."
-(setq string (replace-match "\\1<i>\\3</i>\\4" t nil string)))
+(while (string-match org-emph-re string)
-(while (string-match org-bold-re string)
+(setq string (replace-match (concat "\\1" (nth 2 (assoc (match-string 3 string) org-emphasis-alist)) "\\4" (nth 3 (assoc (match-string 3 string) org-emphasis-alist)) "\\5") t nil string)))
-(setq string (replace-match "\\1<b>\\3</b>\\4" t nil string)))
-(while (string-match org-underline-re string)
-(setq string (replace-match "\\1<u>\\3</u>\\4" t nil string)))
 string)
 (defvar org-par-open nil)
 (defun org-open-par ()
 "Insert <p>, but first close previous paragraph if any."
 (setq l (1+ l)))
 (when title
 ;; If title is nil, this means this function is called to close
 ;; all levels, so the rest is done only if title is given
 	(when (string-match "\\(:[a-zA-Z0-9_@:]+:\\)[ \t]*$" title)
 	  (setq title (replace-match
 		       (if org-export-with-tags
 			   (save-match-data
 			     (concat
 			      "&nbsp;&nbsp;&nbsp;<span class=\"tag\">"
 			      (mapconcat 'identity (org-split-string
 						    (match-string 1 title) ":")
 					 "&nbsp;")
 			      "</span>"))
 			 "")
 		       t t title)))
 (if (string-match "\\(\\.0\\)+\\'" string)
 	  (setq string (replace-match "" t nil string))))
 string))
+;;;###autoload
 (defun org-export-icalendar-this-file ()
 "Export current file as an iCalendar file.
 The iCalendar file will be located in the same directory as the Org-mode
 file, but with extension `.ics'."
 (interactive)
 (goto-char (point-min))  ;; CD:  beginning-of-buffer is not allowed.
 (let* ((opt-plist (org-combine-plists (org-default-export-plist)
 					(org-infile-export-plist)))
 	   (filename (concat (file-name-as-directory
 			      (org-export-directory :xoxo opt-plist))
 			     (file-name-sans-extension
 			      (file-name-nondirectory buffer-file-name))
 			     ".html"))
 	   (out (find-file-noselect filename))
 	   (last-level 1)
 	   (hanging-li nil))
 (defun org-export-icalendar (combine &rest files)
 "Create iCalendar files for all elements of FILES.
 If COMBINE is non-nil, combine all calendar entries into a single large
 file and store it under the name `org-combined-agenda-icalendar-file'."
 (save-excursion
 (let* ((dir (org-export-directory
 		 :ical (list :publishing-directory
 			     org-export-publishing-directory)))
 	   file ical-file ical-buffer category started org-agenda-new-buffers)
 (when combine
 	(setq ical-file
 	      (if (file-name-absolute-p org-combined-agenda-icalendar-file)
 		  org-combined-agenda-icalendar-file
 		(expand-file-name org-combined-agenda-icalendar-file dir))
 	(catch 'nextfile
 	  (org-check-agenda-file file)
 	  (set-buffer (org-get-agenda-file-buffer file))
 	  (unless combine
 	    (setq ical-file (concat (file-name-as-directory dir)
 				    (file-name-sans-extension
 				     (file-name-nondirectory buffer-file-name))
 				    ".ics"))
 	    (setq ical-buffer (org-get-agenda-file-buffer ical-file))
 	    (with-current-buffer ical-buffer (erase-buffer)))
 	  (setq category (or org-category
 ;;                     i k                 @                                expendable from outline-mode
 ;;   0123456789                               % &     ()_{}    "      `     free
 ;; Make `C-c C-x' a prefix key
 (define-key org-mode-map "\C-c\C-x" (make-sparse-keymap))
-(define-key org-mode-map "\C-c\C-e" (make-sparse-keymap))
 ;; TAB key with modifiers
 (define-key org-mode-map "\C-i"       'org-cycle)
 (define-key org-mode-map [(tab)]      'org-cycle)
 (define-key org-mode-map [(meta tab)] 'org-complete)
 (define-key org-mode-map "\C-c|"          'org-table-create-or-convert-from-region)
 (define-key org-mode-map "\C-c*"          'org-table-recalculate)
 (define-key org-mode-map [(control ?#)]   'org-table-rotate-recalc-marks)
 (define-key org-mode-map "\C-c~"          'org-table-create-with-table.el)
 (define-key org-mode-map "\C-c\C-q"       'org-table-wrap-region)
-(define-key org-mode-map "\C-c\C-xa"      'org-export-as-ascii)
+(define-key org-mode-map "\C-c\C-e"       'org-export)
-(define-key org-mode-map "\C-c\C-x\C-a"   'org-export-as-ascii)
+;(define-key org-mode-map "\C-c\C-xa"      'org-export-as-ascii)
-(define-key org-mode-map "\C-c\C-xv"      'org-export-visible)
+;(define-key org-mode-map "\C-c\C-x\C-a"   'org-export-as-ascii)
-(define-key org-mode-map "\C-c\C-x\C-v"   'org-export-visible)
+;(define-key org-mode-map "\C-c\C-xv"      'org-export-visible)
+;(define-key org-mode-map "\C-c\C-x\C-v"   'org-export-visible)
 ;; OPML support is only an option for the future
 ;(define-key org-mode-map "\C-c\C-xo"      'org-export-as-opml)
 ;(define-key org-mode-map "\C-c\C-x\C-o"   'org-export-as-opml)
-(define-key org-mode-map "\C-c\C-xi"      'org-export-icalendar-this-file)
+;(define-key org-mode-map "\C-c\C-xi"      'org-export-icalendar-this-file)
-(define-key org-mode-map "\C-c\C-x\C-i"   'org-export-icalendar-all-agenda-files)
+;(define-key org-mode-map "\C-c\C-x\C-i"   'org-export-icalendar-all-agenda-files)
-(define-key org-mode-map "\C-c\C-xc"      'org-export-icalendar-combine-agenda-files)
+;(define-key org-mode-map "\C-c\C-xc"      'org-export-icalendar-combine-agenda-files)
-(define-key org-mode-map "\C-c\C-x\C-c"   'org-export-icalendar-combine-agenda-files)
+;(define-key org-mode-map "\C-c\C-x\C-c"   'org-export-icalendar-combine-agenda-files)
-(define-key org-mode-map "\C-c\C-xt"      'org-insert-export-options-template)
+;(define-key org-mode-map "\C-c\C-xt"      'org-insert-export-options-template)
 (define-key org-mode-map "\C-c:"          'org-toggle-fixed-width-section)
-(define-key org-mode-map "\C-c\C-xh"      'org-export-as-html)
+;(define-key org-mode-map "\C-c\C-xh"      'org-export-as-html)
-(define-key org-mode-map "\C-c\C-xx"      'org-export-as-xoxo)
+;(define-key org-mode-map "\C-c\C-xx"      'org-export-as-xoxo)
-(define-key org-mode-map "\C-c\C-x\C-x"   'org-export-as-xoxo)
+;(define-key org-mode-map "\C-c\C-x\C-x"   'org-export-as-xoxo)
-(define-key org-mode-map "\C-c\C-xb"      'org-export-as-html-and-open)
+;(define-key org-mode-map "\C-c\C-xb"      'org-export-as-html-and-open)
-(define-key org-mode-map "\C-c\C-x\C-b"   'org-export-as-html-and-open)
+;(define-key org-mode-map "\C-c\C-x\C-b"   'org-export-as-html-and-open)
 (define-key org-mode-map "\C-c\C-x\C-k"   'org-cut-special)
 (define-key org-mode-map "\C-c\C-x\C-w"   'org-cut-special)
 (define-key org-mode-map "\C-c\C-x\M-w"   'org-copy-special)
 (define-key org-mode-map "\C-c\C-x\C-y"   'org-paste-special)
-(define-key org-mode-map "\C-c\C-ef"    'org-publish-current-file)
+(define-key org-mode-map "\C-c\C-x\C-i" 'org-clock-in)
-(define-key org-mode-map "\C-c\C-ep"    'org-publish-current-project)
+(define-key org-mode-map "\C-c\C-x\C-o" 'org-clock-out)
-(define-key org-mode-map "\C-c\C-ec"    'org-publish)
+(define-key org-mode-map "\C-c\C-x\C-x" 'org-clock-cancel)
-(define-key org-mode-map "\C-c\C-ea"    'org-publish-all)
+(define-key org-mode-map "\C-c\C-x\C-d" 'org-clock-display)
-(define-key org-mode-map "\C-c\C-e\C-f" 'org-publish-current-file)
-(define-key org-mode-map "\C-c\C-e\C-p" 'org-publish-current-project)
+;(define-key org-mode-map "\C-c\C-ef"    'org-publish-current-file)
-(define-key org-mode-map "\C-c\C-e\C-c" 'org-publish)
+;(define-key org-mode-map "\C-c\C-ep"    'org-publish-current-project)
-(define-key org-mode-map "\C-c\C-e\C-a" 'org-publish-all)
+;(define-key org-mode-map "\C-c\C-ec"    'org-publish)
+;(define-key org-mode-map "\C-c\C-ea"    'org-publish-all)
-(when (featurep 'xemacs)
+;(define-key org-mode-map "\C-c\C-e\C-f" 'org-publish-current-file)
+;(define-key org-mode-map "\C-c\C-e\C-p" 'org-publish-current-project)
+;(define-key org-mode-map "\C-c\C-e\C-c" 'org-publish)
+;(define-key org-mode-map "\C-c\C-e\C-a" 'org-publish-all)
+(when (featurep 'xemacs)
 (define-key org-mode-map 'button3   'popup-mode-menu))
 (defsubst org-table-p () (org-at-table-p))
 (defun org-self-insert-command (N)
 (interactive "p")
 (if (and (org-table-p)
 	   (eq N 1)
 	   (string-match "|" (buffer-substring (point-at-bol) (point)))
 	   (looking-at ".*?|"))
 (let ((pos (point))
 	    (noalign (looking-at "[^|\n\r]*  |"))
 	    (c org-table-may-need-update))
 	(backward-delete-char N)
 	(skip-chars-forward "^|")
 	(insert " ")
 (defun org-shiftcursor-error ()
 "Throw an error because Shift-Cursor command was applied in wrong context."
 (error "This command is active in special context like tables, headlines or timestamps"))
-(defun org-shifttab ()
+(defun org-shifttab (&optional arg)
 "Global visibility cycling or move to previous table field.
 Calls `org-cycle' with argument t, or `org-table-previous-field', depending
 on context.
 See the individual commands for more information."
-(interactive)
+(interactive "P")
 (cond
 ((org-at-table-p) (call-interactively 'org-table-previous-field))
 (t (call-interactively 'org-global-cycle))))
 (defun org-shiftmetaleft ()
 into the current line, aligned to `org-tags-column'.  When called
 with prefix arg, realign all tags in the current buffer.
 - If the cursor is in one of the special #+KEYWORD lines, this
 triggers scanning the buffer for these lines and updating the
 information.
 - If the cursor is inside a table, realign the table.  This command
 works even if the automatic table editor has been turned off.
 - If the cursor is on a #+TBLFM line, re-apply the formulas to
 - If the cursor is on a numbered item in a plain list, renumber the
 ordered list."
 (interactive "P")
 (let  ((org-enable-table-editor t))
 (cond
+(org-clock-overlays
+(org-remove-clock-overlays)
+(message "Clock overlays removed"))
+(org-occur-highlights
+(org-remove-occur-highlights)
+(message "occur highlights removed"))
 ((and (local-variable-p 'org-finish-function (current-buffer))
 	   (fboundp org-finish-function))
 (funcall org-finish-function))
 ((org-on-target-p) (call-interactively 'org-update-radio-target-regexp))
 ((org-on-heading-p) (call-interactively 'org-set-tags))
 ["Schedule Item" org-schedule t]
 ["Deadline" org-deadline t]
 "--"
 ["Goto Calendar" org-goto-calendar t]
 ["Date from Calendar" org-date-from-calendar t])
+("Logging work"
+["Clock in" org-clock-in t]
+["Clock out" org-clock-out t]
+["Clock cancel" org-clock-cancel t]
+["Display times" org-clock-display t]
+"--"
+["Record DONE time"
+(progn (setq org-log-done (not org-log-done))
+	     (message "Switching to %s will %s record a timestamp"
+		      org-done-string
+		      (if org-log-done "automatically" "not")))
+:style toggle :selected org-log-done])
 "--"
 ["Agenda Command" org-agenda t]
 ("File List for Agenda")
 ("Special views current file"
 ["TODO Tree"  org-show-todo-tree t]
 (progn
 	(org-remove-from-invisibility-spec '(org-link)) (org-restart-font-lock))
 :style radio :selected (not (member '(org-link) buffer-invisibility-spec))]
 "--"
 ["Upgrade all <link> to [[link][desc]]" org-upgrade-old-links
 (save-excursion (goto-char (point-min))
 		      (re-search-forward "<[a-z]+:" nil t))])
 "--"
-("Export"
+["Export/Publish" org-export t]
-["ASCII" org-export-as-ascii t]
-["Export visible part..." org-export-visible t]
-["HTML"  org-export-as-html t]
-["HTML and Open" org-export-as-html-and-open t]
-["XOXO" org-export-as-xoxo t]
-"--"
-["iCalendar this file" org-export-icalendar-this-file t]
-["iCalendar all agenda files" org-export-icalendar-all-agenda-files
-:active t :keys "C-c C-x C-i"]
-["iCalendar combined" org-export-icalendar-combine-agenda-files t]
-"--"
-["Option Template" org-insert-export-options-template t]
-["Toggle Fixed Width" org-toggle-fixed-width-section t])
-("Publish"
-["Current File" org-publish-current-file t]
-["Current Project" org-publish-current-project t]
-["Project..." org-publish t]
-["All Projects" org-publish-all t])
 "--"
 ("Documentation"
 ["Show Version" org-version t]
 ["Info Documentation" org-info t])
 ("Customize"
 "\f\\|[ 	]*$\\|\\([*\f]+\\)\\|[ \t]*\\([-+*]\\|[0-9]+[.)][ \t]+\\)\\|[ \t]*[:|]")
 ;; Inhibit auto-fill for headers, tables and fixed-width lines.
 ;; But only if the user has not turned off tables or fixed-width regions
 (set (make-local-variable 'auto-fill-inhibit-regexp)
 (concat "\\*\\|#"
+	       "\\|[ \t]*" org-keyword-time-regexp
 	       (if (or org-enable-table-editor org-enable-fixed-width-editor)
 		   (concat
 		    "\\|[ \t]*["
 		    (if org-enable-table-editor "|" "")
 		    (if org-enable-fixed-width-editor ":"  "")
 (provide 'org)
 (run-hooks 'org-load-hook)
 ;; arch-tag: e77da1a7-acc7-4336-b19e-efa25af3f9fd
 ;;; org.el ends here

Mercurial > emacs

comparison lisp/textmodes/org.el @ 71310:0d8984127630