Merge branch 'master' of orgmode.org:org-mode

5 files changed, 547 insertions, 437 deletions

diff --git a/doc/org.texi b/doc/org.texi
index 6b189bd..1d0790f 100644
--- a/doc/org.texi
+++ b/doc/org.texi
@@ -9634,10 +9634,11 @@ Insert template with export options, see example below.
 @vindex user-full-name
 @vindex user-mail-address
 @vindex org-export-default-language
+@vindex org-export-date-timestamp-format
 @example
 #+TITLE:       the title to be shown (default is the buffer name)
 #+AUTHOR:      the author (default taken from @code{user-full-name})
-#+DATE:        a date, fixed, or a format string for @code{format-time-string}
+#+DATE:        a date, an Org timestamp@footnote{@code{org-export-date-timestamp-format} defines how this timestamp will be exported.}, or a format string for @code{format-time-string}
 #+EMAIL:       his/her email address (default from @code{user-mail-address})
 #+DESCRIPTION: the page description, e.g.@: for the XHTML meta tag
 #+KEYWORDS:    the page keywords, e.g.@: for the XHTML meta tag
@@ -9656,8 +9657,8 @@ Insert template with export options, see example below.
 @end example
 
 @noindent
-The OPTIONS line is a compact@footnote{If you want to configure many options
-this way, you can use several OPTIONS lines.} form to specify export
+The @code{#+OPTIONS} line is a compact@footnote{If you want to configure many options
+this way, you can use several @code{#+OPTIONS} lines.} form to specify export
 settings.  Here you can:
 @cindex headline levels
 @cindex section-numbers
diff --git a/lisp/org-agenda.el b/lisp/org-agenda.el
index 780794e..79aaf99 100644
--- a/lisp/org-agenda.el
+++ b/lisp/org-agenda.el
@@ -1901,7 +1901,7 @@ The following commands are available:
 (org-defkey org-agenda-mode-map "\C-c\C-xp" 'org-agenda-set-property)
 (org-defkey org-agenda-mode-map "q" 'org-agenda-quit)
 (org-defkey org-agenda-mode-map "x" 'org-agenda-exit)
-(org-defkey org-agenda-mode-map "\C-x\C-w" 'org-write-agenda)
+(org-defkey org-agenda-mode-map "\C-x\C-w" 'org-agenda-write)
 (org-defkey org-agenda-mode-map "\C-x\C-s" 'org-save-all-org-buffers)
 (org-defkey org-agenda-mode-map "s" 'org-save-all-org-buffers)
 (org-defkey org-agenda-mode-map "P" 'org-agenda-show-priority)
@@ -2015,7 +2015,7 @@ The following commands are available:
       :keys "v A"]
      "--"
      ["Remove Restriction" org-agenda-remove-restriction-lock org-agenda-restrict])
-    ["Write view to file" org-write-agenda t]
+    ["Write view to file" org-agenda-write t]
     ["Rebuild buffer" org-agenda-redo t]
     ["Save all Org-mode Buffers" org-save-all-org-buffers t]
     "--"
@@ -2608,17 +2608,9 @@ before running the agenda command."
 	(org-tags-view nil cmd-key)
       (org-agenda nil cmd-key)))
   (set-buffer org-agenda-buffer-name)
-  (princ (org-encode-for-stdout (buffer-string))))
+  (princ (buffer-string)))
 (def-edebug-spec org-batch-agenda (form &rest sexp))
 
-;(defun org-encode-for-stdout (string)
-;  (if (fboundp 'encode-coding-string)
-;      (encode-coding-string string buffer-file-coding-system)
-;    string))
-
-(defun org-encode-for-stdout (string)
-  string)
-
 (defvar org-agenda-info nil)
 
 ;;;###autoload
@@ -2670,11 +2662,10 @@ agenda-day   The day in the agenda where this is listed"
 	(setq org-agenda-info
 	      (org-fix-agenda-info (text-properties-at 0 line)))
 	(princ
-	 (org-encode-for-stdout
-	  (mapconcat 'org-agenda-export-csv-mapper
-		     '(org-category txt type todo tags date time extra
-				    priority-letter priority agenda-day)
-		     ",")))
+	 (mapconcat 'org-agenda-export-csv-mapper
+		    '(org-category txt type todo tags date time extra
+				   priority-letter priority agenda-day)
+		    ","))
 	(princ "\n")))))
 (def-edebug-spec org-batch-agenda-csv (form &rest sexp))
 
@@ -2750,7 +2741,7 @@ This ensures the export commands can easily use it."
 	  (while files
 	    (org-eval-in-environment (append org-agenda-exporter-settings
 					     opts pars)
-	      (org-write-agenda (expand-file-name (pop files) dir) nil t)))
+	      (org-agenda-write (expand-file-name (pop files) dir) nil t)))
 	  (and (get-buffer org-agenda-buffer-name)
 	       (kill-buffer org-agenda-buffer-name)))))))
 (def-edebug-spec org-batch-store-agenda-views (&rest sexp))
@@ -2766,7 +2757,8 @@ This ensures the export commands can easily use it."
 			 'org-agenda-title-append org-agenda-title-append))))
 
 (defvar org-mobile-creating-agendas)
-(defun org-write-agenda (file &optional open nosettings)
+(defvar org-agenda-write-buffer-name "Agenda View")
+(defun org-agenda-write (file &optional open nosettings)
   "Write the current buffer (an agenda view) as a file.
 Depending on the extension of the file name, plain text (.txt),
 HTML (.html or .htm) or Postscript (.ps) is produced.
@@ -2788,7 +2780,7 @@ higher priority settings."
 	 (let ((bs (copy-sequence (buffer-string))) beg)
 	   (org-agenda-unmark-filtered-text)
 	   (with-temp-buffer
-	     (rename-buffer "Agenda View" t)
+	     (rename-buffer org-agenda-write-buffer-name t)
 	     (set-buffer-modified-p nil)
 	     (insert bs)
 	     (org-agenda-remove-marked-text 'org-filtered)
@@ -6187,14 +6179,14 @@ to switch to narrowing."
        "%s by tag [%s ], [TAB], %s[/]:off, [+-]:narrow, [>=<?]:effort: "
        (if narrow "Narrow" "Filter") tag-chars
        (if org-agenda-auto-exclude-function "[RET], " ""))
-      (setq char (read-char)))
+      (setq char (read-char-exclusive)))
     (when (member char '(?+ ?-))
       ;; Narrowing down
       (cond ((equal char ?-) (setq strip t narrow t))
 	    ((equal char ?+) (setq strip nil narrow t)))
       (message
        "Narrow by tag [%s ], [TAB], [/]:off, [>=<]:effort: " tag-chars)
-      (setq char (read-char)))
+      (setq char (read-char-exclusive)))
     (when (member char '(?< ?> ?= ??))
       ;; An effort operator
       (setq effort-op (char-to-string char))
@@ -6207,7 +6199,7 @@ to switch to narrowing."
 		     (if (= i 9) "0" (int-to-string (1+ i)))
 		     "]" (nth i efforts))))
 	(message "Effort%s: %s " effort-op effort-prompt)
-	(setq char (read-char))
+	(setq char (read-char-exclusive))
 	(when (or (< char ?0) (> char ?9))
 	  (error "Need 1-9,0 to select effort" ))))
     (when (equal char ?\t)
diff --git a/lisp/org-archive.el b/lisp/org-archive.el
index e426055..8cdb153 100644
--- a/lisp/org-archive.el
+++ b/lisp/org-archive.el
@@ -190,158 +190,166 @@ If the cursor is not at a headline when this command is called, try all level
 1 trees.  If the cursor is on a headline, only try the direct children of
 this heading."
   (interactive "P")
-  (if find-done
-      (org-archive-all-done)
-    ;; Save all relevant TODO keyword-relatex variables
-
-    (let ((tr-org-todo-line-regexp org-todo-line-regexp) ; keep despite compiler
-	  (tr-org-todo-keywords-1 org-todo-keywords-1)
-	  (tr-org-todo-kwd-alist org-todo-kwd-alist)
-	  (tr-org-done-keywords org-done-keywords)
-	  (tr-org-todo-regexp org-todo-regexp)
-	  (tr-org-todo-line-regexp org-todo-line-regexp)
-	  (tr-org-odd-levels-only org-odd-levels-only)
-	  (this-buffer (current-buffer))
-	  ;; start of variables that will be used for saving context
-	  ;; The compiler complains about them - keep them anyway!
-	  (file (abbreviate-file-name
-		 (or (buffer-file-name (buffer-base-buffer))
-		     (error "No file associated to buffer"))))
-	  (olpath (mapconcat 'identity (org-get-outline-path) "/"))
-	  (time (format-time-string
-		 (substring (cdr org-time-stamp-formats) 1 -1)
-		 (current-time)))
-	  category todo priority ltags itags atags
-	  ;; end of variables that will be used for saving context
-	  location afile heading buffer level newfile-p infile-p visiting)
-
-      ;; Find the local archive location
-      (setq location (org-get-local-archive-location)
-	    afile (org-extract-archive-file location)
-	    heading (org-extract-archive-heading location)
-	    infile-p (equal file (abbreviate-file-name afile)))
-      (unless afile
-	(error "Invalid `org-archive-location'"))
-
-      (if (> (length afile) 0)
-	  (setq newfile-p (not (file-exists-p afile))
-		visiting (find-buffer-visiting afile)
-		buffer (or visiting (find-file-noselect afile)))
-	(setq buffer (current-buffer)))
-      (unless buffer
-	(error "Cannot access file \"%s\"" afile))
-      (if (and (> (length heading) 0)
-	       (string-match "^\\*+" heading))
-	  (setq level (match-end 0))
-	(setq heading nil level 0))
-      (save-excursion
-	(org-back-to-heading t)
-	;; Get context information that will be lost by moving the tree
-	(setq category (org-get-category nil 'force-refresh)
-	      todo (and (looking-at org-todo-line-regexp)
-			(match-string 2))
-	      priority (org-get-priority
-			(if (match-end 3) (match-string 3) ""))
-	      ltags (org-get-tags)
-	      itags (org-delete-all ltags (org-get-tags-at))
-	      atags (org-get-tags-at))
-	(setq ltags (mapconcat 'identity ltags " ")
-	      itags (mapconcat 'identity itags " "))
-	;; We first only copy, in case something goes wrong
-	;; we need to protect `this-command', to avoid kill-region sets it,
-	;; which would lead to duplication of subtrees
-	(let (this-command) (org-copy-subtree 1 nil t))
-	(set-buffer buffer)
-	;; Enforce org-mode for the archive buffer
-	(if (not (eq major-mode 'org-mode))
-	    ;; Force the mode for future visits.
-	    (let ((org-insert-mode-line-in-empty-file t)
-		  (org-inhibit-startup t))
-	      (call-interactively 'org-mode)))
-	(when newfile-p
-	  (goto-char (point-max))
-	  (insert (format "\nArchived entries from file %s\n\n"
-			  (buffer-file-name this-buffer))))
-	;; Force the TODO keywords of the original buffer
-	(let ((org-todo-line-regexp tr-org-todo-line-regexp)
-	      (org-todo-keywords-1 tr-org-todo-keywords-1)
-	      (org-todo-kwd-alist tr-org-todo-kwd-alist)
-	      (org-done-keywords tr-org-done-keywords)
-	      (org-todo-regexp tr-org-todo-regexp)
-	      (org-todo-line-regexp tr-org-todo-line-regexp)
-	      (org-odd-levels-only
-	       (if (local-variable-p 'org-odd-levels-only (current-buffer))
-		   org-odd-levels-only
-		 tr-org-odd-levels-only)))
-	  (goto-char (point-min))
-	  (show-all)
-	  (if heading
-	      (progn
-		(if (re-search-forward
-		     (concat "^" (regexp-quote heading)
-			     (org-re "[ \t]*\\(:[[:alnum:]_@#%:]+:\\)?[ \t]*\\($\\|\r\\)"))
-		     nil t)
-		    (goto-char (match-end 0))
-		  ;; Heading not found, just insert it at the end
-		  (goto-char (point-max))
-		  (or (bolp) (insert "\n"))
-		  (insert "\n" heading "\n")
-		  (end-of-line 0))
-		;; Make the subtree visible
-		(show-subtree)
-		(if org-archive-reversed-order
-		    (progn
-		      (org-back-to-heading t)
-		      (outline-next-heading))
-		  (org-end-of-subtree t))
-		(skip-chars-backward " \t\r\n")
-		(and (looking-at "[ \t\r\n]*")
-		     (replace-match "\n\n")))
-	    ;; No specific heading, just go to end of file.
-	    (goto-char (point-max)) (insert "\n"))
-	  ;; Paste
-	  (org-paste-subtree (org-get-valid-level level (and heading 1)))
-	  ;; Shall we append inherited tags?
-	  (and itags
-	       (or (and (eq org-archive-subtree-add-inherited-tags 'infile)
-			infile-p)
-		   (eq org-archive-subtree-add-inherited-tags t))
-	       (org-set-tags-to atags))
-	  ;; Mark the entry as done
-	  (when (and org-archive-mark-done
-		     (looking-at org-todo-line-regexp)
-		     (or (not (match-end 2))
-			 (not (member (match-string 2) org-done-keywords))))
-	    (let (org-log-done org-todo-log-states)
-	      (org-todo
-	       (car (or (member org-archive-mark-done org-done-keywords)
-			org-done-keywords)))))
-
-	  ;; Add the context info
-	  (when org-archive-save-context-info
-	    (let ((l org-archive-save-context-info) e n v)
-	      (while (setq e (pop l))
-		(when (and (setq v (symbol-value e))
-			   (stringp v) (string-match "\\S-" v))
-		  (setq n (concat "ARCHIVE_" (upcase (symbol-name e))))
-		  (org-entry-put (point) n v)))))
-
-	  ;; Save and kill the buffer, if it is not the same buffer.
-	  (when (not (eq this-buffer buffer))
-	    (save-buffer))))
-      ;; Here we are back in the original buffer.  Everything seems to have
-      ;; worked.  So now cut the tree and finish up.
-      (let (this-command) (org-cut-subtree))
-      (when (featurep 'org-inlinetask)
-	(org-inlinetask-remove-END-maybe))
-      (setq org-markers-to-move nil)
-      (message "Subtree archived %s"
-	       (if (eq this-buffer buffer)
-		   (concat "under heading: " heading)
-		 (concat "in file: " (abbreviate-file-name afile))))))
-  (org-reveal)
-  (if (looking-at "^[ \t]*$")
-      (outline-next-visible-heading 1)))
+  (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
+      (let ((cl (if (eq org-loop-over-headlines-in-active-region 'start-level)
+		    'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
+	(org-map-entries
+	 `(progn (setq org-map-continue-from (progn (org-back-to-heading) (point)))
+		 (org-archive-subtree ,find-done))
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
+    (if find-done
+	(org-archive-all-done)
+      ;; Save all relevant TODO keyword-relatex variables
+      (let ((tr-org-todo-line-regexp org-todo-line-regexp) ; keep despite compiler
+	    (tr-org-todo-keywords-1 org-todo-keywords-1)
+	    (tr-org-todo-kwd-alist org-todo-kwd-alist)
+	    (tr-org-done-keywords org-done-keywords)
+	    (tr-org-todo-regexp org-todo-regexp)
+	    (tr-org-todo-line-regexp org-todo-line-regexp)
+	    (tr-org-odd-levels-only org-odd-levels-only)
+	    (this-buffer (current-buffer))
+	    ;; start of variables that will be used for saving context
+	    ;; The compiler complains about them - keep them anyway!
+	    (file (abbreviate-file-name
+		   (or (buffer-file-name (buffer-base-buffer))
+		       (error "No file associated to buffer"))))
+	    (olpath (mapconcat 'identity (org-get-outline-path) "/"))
+	    (time (format-time-string
+		   (substring (cdr org-time-stamp-formats) 1 -1)
+		   (current-time)))
+	    category todo priority ltags itags atags
+	    ;; end of variables that will be used for saving context
+	    location afile heading buffer level newfile-p infile-p visiting)
+
+	;; Find the local archive location
+	(setq location (org-get-local-archive-location)
+	      afile (org-extract-archive-file location)
+	      heading (org-extract-archive-heading location)
+	      infile-p (equal file (abbreviate-file-name afile)))
+	(unless afile
+	  (error "Invalid `org-archive-location'"))
+
+	(if (> (length afile) 0)
+	    (setq newfile-p (not (file-exists-p afile))
+		  visiting (find-buffer-visiting afile)
+		  buffer (or visiting (find-file-noselect afile)))
+	  (setq buffer (current-buffer)))
+	(unless buffer
+	  (error "Cannot access file \"%s\"" afile))
+	(if (and (> (length heading) 0)
+		 (string-match "^\\*+" heading))
+	    (setq level (match-end 0))
+	  (setq heading nil level 0))
+	(save-excursion
+	  (org-back-to-heading t)
+	  ;; Get context information that will be lost by moving the tree
+	  (setq category (org-get-category nil 'force-refresh)
+		todo (and (looking-at org-todo-line-regexp)
+			  (match-string 2))
+		priority (org-get-priority
+			  (if (match-end 3) (match-string 3) ""))
+		ltags (org-get-tags)
+		itags (org-delete-all ltags (org-get-tags-at))
+		atags (org-get-tags-at))
+	  (setq ltags (mapconcat 'identity ltags " ")
+		itags (mapconcat 'identity itags " "))
+	  ;; We first only copy, in case something goes wrong
+	  ;; we need to protect `this-command', to avoid kill-region sets it,
+	  ;; which would lead to duplication of subtrees
+	  (let (this-command) (org-copy-subtree 1 nil t))
+	  (set-buffer buffer)
+	  ;; Enforce org-mode for the archive buffer
+	  (if (not (eq major-mode 'org-mode))
+	      ;; Force the mode for future visits.
+	      (let ((org-insert-mode-line-in-empty-file t)
+		    (org-inhibit-startup t))
+		(call-interactively 'org-mode)))
+	  (when newfile-p
+	    (goto-char (point-max))
+	    (insert (format "\nArchived entries from file %s\n\n"
+			    (buffer-file-name this-buffer))))
+	  ;; Force the TODO keywords of the original buffer
+	  (let ((org-todo-line-regexp tr-org-todo-line-regexp)
+		(org-todo-keywords-1 tr-org-todo-keywords-1)
+		(org-todo-kwd-alist tr-org-todo-kwd-alist)
+		(org-done-keywords tr-org-done-keywords)
+		(org-todo-regexp tr-org-todo-regexp)
+		(org-todo-line-regexp tr-org-todo-line-regexp)
+		(org-odd-levels-only
+		 (if (local-variable-p 'org-odd-levels-only (current-buffer))
+		     org-odd-levels-only
+		   tr-org-odd-levels-only)))
+	    (goto-char (point-min))
+	    (show-all)
+	    (if heading
+		(progn
+		  (if (re-search-forward
+		       (concat "^" (regexp-quote heading)
+			       (org-re "[ \t]*\\(:[[:alnum:]_@#%:]+:\\)?[ \t]*\\($\\|\r\\)"))
+		       nil t)
+		      (goto-char (match-end 0))
+		    ;; Heading not found, just insert it at the end
+		    (goto-char (point-max))
+		    (or (bolp) (insert "\n"))
+		    (insert "\n" heading "\n")
+		    (end-of-line 0))
+		  ;; Make the subtree visible
+		  (show-subtree)
+		  (if org-archive-reversed-order
+		      (progn
+			(org-back-to-heading t)
+			(outline-next-heading))
+		    (org-end-of-subtree t))
+		  (skip-chars-backward " \t\r\n")
+		  (and (looking-at "[ \t\r\n]*")
+		       (replace-match "\n\n")))
+	      ;; No specific heading, just go to end of file.
+	      (goto-char (point-max)) (insert "\n"))
+	    ;; Paste
+	    (org-paste-subtree (org-get-valid-level level (and heading 1)))
+	    ;; Shall we append inherited tags?
+	    (and itags
+		 (or (and (eq org-archive-subtree-add-inherited-tags 'infile)
+			  infile-p)
+		     (eq org-archive-subtree-add-inherited-tags t))
+		 (org-set-tags-to atags))
+	    ;; Mark the entry as done
+	    (when (and org-archive-mark-done
+		       (looking-at org-todo-line-regexp)
+		       (or (not (match-end 2))
+			   (not (member (match-string 2) org-done-keywords))))
+	      (let (org-log-done org-todo-log-states)
+		(org-todo
+		 (car (or (member org-archive-mark-done org-done-keywords)
+			  org-done-keywords)))))
+
+	    ;; Add the context info
+	    (when org-archive-save-context-info
+	      (let ((l org-archive-save-context-info) e n v)
+		(while (setq e (pop l))
+		  (when (and (setq v (symbol-value e))
+			     (stringp v) (string-match "\\S-" v))
+		    (setq n (concat "ARCHIVE_" (upcase (symbol-name e))))
+		    (org-entry-put (point) n v)))))
+
+	    ;; Save and kill the buffer, if it is not the same buffer.
+	    (when (not (eq this-buffer buffer))
+	      (save-buffer))))
+	;; Here we are back in the original buffer.  Everything seems to have
+	;; worked.  So now cut the tree and finish up.
+	(let (this-command) (org-cut-subtree))
+	(when (featurep 'org-inlinetask)
+	  (org-inlinetask-remove-END-maybe))
+	(setq org-markers-to-move nil)
+	(message "Subtree archived %s"
+		 (if (eq this-buffer buffer)
+		     (concat "under heading: " heading)
+		   (concat "in file: " (abbreviate-file-name afile))))))
+    (org-reveal)
+    (if (looking-at "^[ \t]*$")
+	(outline-next-visible-heading 1))))
 
 (defun org-archive-to-archive-sibling ()
   "Archive the current heading by moving it under the archive sibling.
@@ -349,55 +357,69 @@ The archive sibling is a sibling of the heading with the heading name
 `org-archive-sibling-heading' and an `org-archive-tag' tag.  If this
 sibling does not exist, it will be created at the end of the subtree."
   (interactive)
-  (save-restriction
-    (widen)
-    (let (b e pos leader level)
-      (org-back-to-heading t)
-      (looking-at org-outline-regexp)
-      (setq leader (match-string 0)
-	    level (funcall outline-level))
-      (setq pos (point))
-      (condition-case nil
-	  (outline-up-heading 1 t)
-	(error (setq e (point-max)) (goto-char (point-min))))
-      (setq b (point))
-      (unless e
+  (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
+      (let ((cl (when (eq org-loop-over-headlines-in-active-region 'start-level)
+		  'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
+	(org-map-entries
+	 '(progn (setq org-map-continue-from
+		       (progn (org-back-to-heading)
+			      (if (looking-at (concat "^.*:" org-archive-tag ":.*$"))
+			      	  (org-end-of-subtree t)
+				(point))))
+		 (when (org-at-heading-p)
+		   (org-archive-to-archive-sibling)))
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
+    (save-restriction
+      (widen)
+      (let (b e pos leader level)
+	(org-back-to-heading t)
+	(looking-at org-outline-regexp)
+	(setq leader (match-string 0)
+	      level (funcall outline-level))
+	(setq pos (point))
 	(condition-case nil
-	    (org-end-of-subtree t t)
-	  (error (goto-char (point-max))))
-	(setq e (point)))
-      (goto-char b)
-      (unless (re-search-forward
-	       (concat "^" (regexp-quote leader)
-		       "[ \t]*"
-		       org-archive-sibling-heading
-		       "[ \t]*:"
-		       org-archive-tag ":") e t)
-	(goto-char e)
-	(or (bolp) (newline))
-	(insert leader org-archive-sibling-heading "\n")
-	(beginning-of-line 0)
-	(org-toggle-tag org-archive-tag 'on))
-      (beginning-of-line 1)
-      (if org-archive-reversed-order
-	  (outline-next-heading)
-	(org-end-of-subtree t t))
-      (save-excursion
-	(goto-char pos)
-	(let ((this-command this-command)) (org-cut-subtree)))
-      (org-paste-subtree (org-get-valid-level level 1))
-      (org-set-property
-       "ARCHIVE_TIME"
-       (format-time-string
-	(substring (cdr org-time-stamp-formats) 1 -1)
-	(current-time)))
-      (outline-up-heading 1 t)
-      (hide-subtree)
-      (org-cycle-show-empty-lines 'folded)
-      (goto-char pos)))
-  (org-reveal)
-  (if (looking-at "^[ \t]*$")
-      (outline-next-visible-heading 1)))
+	    (outline-up-heading 1 t)
+	  (error (setq e (point-max)) (goto-char (point-min))))
+	(setq b (point))
+	(unless e
+	  (condition-case nil
+	      (org-end-of-subtree t t)
+	    (error (goto-char (point-max))))
+	  (setq e (point)))
+	(goto-char b)
+	(unless (re-search-forward
+		 (concat "^" (regexp-quote leader)
+			 "[ \t]*"
+			 org-archive-sibling-heading
+			 "[ \t]*:"
+			 org-archive-tag ":") e t)
+	  (goto-char e)
+	  (or (bolp) (newline))
+	  (insert leader org-archive-sibling-heading "\n")
+	  (beginning-of-line 0)
+	  (org-toggle-tag org-archive-tag 'on))
+	(beginning-of-line 1)
+	(if org-archive-reversed-order
+	    (outline-next-heading)
+	  (org-end-of-subtree t t))
+	(save-excursion
+	  (goto-char pos)
+	  (let ((this-command this-command)) (org-cut-subtree)))
+	(org-paste-subtree (org-get-valid-level level 1))
+	(org-set-property
+	 "ARCHIVE_TIME"
+	 (format-time-string
+	  (substring (cdr org-time-stamp-formats) 1 -1)
+	  (current-time)))
+	(outline-up-heading 1 t)
+	(hide-subtree)
+	(org-cycle-show-empty-lines 'folded)
+	(goto-char pos)))
+    (org-reveal)
+    (if (looking-at "^[ \t]*$")
+	(outline-next-visible-heading 1))))
 
 (defun org-archive-all-done (&optional tag)
   "Archive sublevels of the current tree without open TODO items.
@@ -448,20 +470,36 @@ When TAG is non-nil, don't move trees, but mark them with the ARCHIVE tag."
 With prefix ARG, check all children of current headline and offer tagging
 the children that do not contain any open TODO items."
   (interactive "P")
-  (if find-done
-      (org-archive-all-done 'tag)
-    (let (set)
-      (save-excursion
-	(org-back-to-heading t)
-	(setq set (org-toggle-tag org-archive-tag))
-	(when set (hide-subtree)))
-      (and set (beginning-of-line 1))
-      (message "Subtree %s" (if set "archived" "unarchived")))))
+  (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
+      (let ((cl (if (eq org-loop-over-headlines-in-active-region 'start-level)
+		    'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
+	(org-map-entries
+	 `(org-toggle-archive-tag ,find-done)
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
+    (if find-done
+	(org-archive-all-done 'tag)
+      (let (set)
+	(save-excursion
+	  (org-back-to-heading t)
+	  (setq set (org-toggle-tag org-archive-tag))
+	  (when set (hide-subtree)))
+	(and set (beginning-of-line 1))
+	(message "Subtree %s" (if set "archived" "unarchived"))))))
 
 (defun org-archive-set-tag ()
   "Set the ARCHIVE tag."
   (interactive)
-  (org-toggle-tag org-archive-tag 'on))
+  (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
+      (let ((cl (if (eq org-loop-over-headlines-in-active-region 'start-level)
+		    'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
+	(org-map-entries
+	 'org-archive-set-tag
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
+    (org-toggle-tag org-archive-tag 'on)))
 
 ;;;###autoload
 (defun org-archive-subtree-default ()
diff --git a/lisp/org-exp.el b/lisp/org-exp.el
index 2f1bccc..2df1d2d 100644
--- a/lisp/org-exp.el
+++ b/lisp/org-exp.el
@@ -217,6 +217,11 @@ and in `org-clock-clocktable-language-setup'."
   :group 'org-export-general
   :type 'string)
 
+(defcustom org-export-date-timestamp-format "%Y-%m-%d"
+  "Time string format for Org timestamps in the #+DATE option."
+  :group 'org-export-general
+  :type 'string)
+
 (defvar org-export-page-description ""
   "The page description, for the XHTML meta tag.
 This is best set with the #+DESCRIPTION line in a file, it does not make
@@ -726,6 +731,7 @@ must accept the property list as an argument, and must return the (possibly
 modified) list.")
 
 ;; FIXME: should we fold case here?
+
 (defun org-infile-export-plist ()
   "Return the property list with file-local settings for export."
   (save-excursion
@@ -759,7 +765,15 @@ modified) list.")
 	   ((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 "DATE") (setq p (plist-put p :date val)))
+	   ((string-equal key "DATE")
+	    ;; If date is an Org timestamp, convert it to a time
+	    ;; string using `org-export-date-timestamp-format'
+	    (when (string-match org-ts-regexp3 val)
+	      (setq val (format-time-string
+			 org-export-date-timestamp-format
+			 (apply 'encode-time (org-parse-time-string
+					      (match-string 0 val))))))
+	    (setq p (plist-put p :date val)))
 	   ((string-equal key "KEYWORDS") (setq p (plist-put p :keywords val)))
 	   ((string-equal key "DESCRIPTION")
 	    (setq p (plist-put p :description val)))
diff --git a/lisp/org.el b/lisp/org.el
index 2f6fb0b..1170932 100644
--- a/lisp/org.el
+++ b/lisp/org.el
@@ -410,15 +410,21 @@ XEmacs user should have this variable set to nil, because
 When set to `t', some commands will be performed in all headlines
 within the active region.
 
+When set to `start-level', some commands will be performed in all
+headlines within the active region, provided that these headlines
+are of the same level than the first one.
+
 When set to a string, those commands will be performed on the
 matching headlines within the active region.  Such string must be
 a tags/property/todo match as it is used in the agenda tags view.
 
-The list of commands is:
-- `org-schedule'
-- `org-deadline'"
+The list of commands is: `org-schedule', `org-deadline',
+`org-todo', `org-archive-subtree', `org-archive-set-tag' and
+`org-archive-to-archive-sibling'.  The archiving commands skip
+already archived entries."
   :type '(choice (const :tag "Don't loop" nil)
 		 (const :tag "All headlines in active region" t)
+		 (const :tag "In active region, headlines at the same level than the first one" 'start-level)
 		 (string :tag "Tags/Property/Todo matcher"))
   :group 'org-todo
   :group 'org-archive)
@@ -11186,194 +11192,202 @@ For calling through lisp, arg is also interpreted in the following way:
 \"WAITING\"         -> switch to the specified keyword, but only if it
                      really is a member of `org-todo-keywords'."
   (interactive "P")
-  (if (equal arg '(16)) (setq arg 'nextset))
-  (let ((org-blocker-hook org-blocker-hook)
-	(case-fold-search nil))
-    (when (equal arg '(64))
-      (setq arg nil org-blocker-hook nil))
-    (when (and org-blocker-hook
-	       (or org-inhibit-blocking
-		   (org-entry-get nil "NOBLOCKING")))
-      (setq org-blocker-hook nil))
-    (save-excursion
-      (catch 'exit
-	(org-back-to-heading t)
-	(if (looking-at org-outline-regexp) (goto-char (1- (match-end 0))))
-	(or (looking-at (concat " +" org-todo-regexp "\\( +\\|[ \t]*$\\)"))
-	    (looking-at "\\(?: *\\|[ \t]*$\\)"))
-	(let* ((match-data (match-data))
-	       (startpos (point-at-bol))
-	       (logging (save-match-data (org-entry-get nil "LOGGING" t t)))
-	       (org-log-done org-log-done)
-	       (org-log-repeat org-log-repeat)
-	       (org-todo-log-states org-todo-log-states)
-	       (org-inhibit-logging
-		(if (equal arg 0)
-		    (progn (setq arg nil) 'note) org-inhibit-logging))
-	       (this (match-string 1))
-	       (hl-pos (match-beginning 0))
-	       (head (org-get-todo-sequence-head this))
-	       (ass (assoc head org-todo-kwd-alist))
-	       (interpret (nth 1 ass))
-	       (done-word (nth 3 ass))
-	       (final-done-word (nth 4 ass))
-	       (last-state (or this ""))
-	       (completion-ignore-case t)
-	       (member (member this org-todo-keywords-1))
-	       (tail (cdr member))
-	       (state (cond
-		       ((and org-todo-key-trigger
-			     (or (and (equal arg '(4))
-				      (eq org-use-fast-todo-selection 'prefix))
-				 (and (not arg) org-use-fast-todo-selection
-				      (not (eq org-use-fast-todo-selection
-					       'prefix)))))
-			;; Use fast selection
-			(org-fast-todo-selection))
-		       ((and (equal arg '(4))
-			     (or (not org-use-fast-todo-selection)
-				 (not org-todo-key-trigger)))
-			;; Read a state with completion
-			(org-icompleting-read
-			 "State: " (mapcar (lambda(x) (list x))
-					   org-todo-keywords-1)
-			 nil t))
-		       ((eq arg 'right)
-			(if this
-			    (if tail (car tail) nil)
-			  (car org-todo-keywords-1)))
-		       ((eq arg 'left)
-			(if (equal member org-todo-keywords-1)
-			    nil
+  (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
+      (let ((cl (if (eq org-loop-over-headlines-in-active-region 'start-level)
+		    'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
+	(org-map-entries
+	 `(org-todo ,arg)
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
+    (if (equal arg '(16)) (setq arg 'nextset))
+    (let ((org-blocker-hook org-blocker-hook)
+	  (case-fold-search nil))
+      (when (equal arg '(64))
+	(setq arg nil org-blocker-hook nil))
+      (when (and org-blocker-hook
+		 (or org-inhibit-blocking
+		     (org-entry-get nil "NOBLOCKING")))
+	(setq org-blocker-hook nil))
+      (save-excursion
+	(catch 'exit
+	  (org-back-to-heading t)
+	  (if (looking-at org-outline-regexp) (goto-char (1- (match-end 0))))
+	  (or (looking-at (concat " +" org-todo-regexp "\\( +\\|[ \t]*$\\)"))
+	      (looking-at "\\(?: *\\|[ \t]*$\\)"))
+	  (let* ((match-data (match-data))
+		 (startpos (point-at-bol))
+		 (logging (save-match-data (org-entry-get nil "LOGGING" t t)))
+		 (org-log-done org-log-done)
+		 (org-log-repeat org-log-repeat)
+		 (org-todo-log-states org-todo-log-states)
+		 (org-inhibit-logging
+		  (if (equal arg 0)
+		      (progn (setq arg nil) 'note) org-inhibit-logging))
+		 (this (match-string 1))
+		 (hl-pos (match-beginning 0))
+		 (head (org-get-todo-sequence-head this))
+		 (ass (assoc head org-todo-kwd-alist))
+		 (interpret (nth 1 ass))
+		 (done-word (nth 3 ass))
+		 (final-done-word (nth 4 ass))
+		 (last-state (or this ""))
+		 (completion-ignore-case t)
+		 (member (member this org-todo-keywords-1))
+		 (tail (cdr member))
+		 (state (cond
+			 ((and org-todo-key-trigger
+			       (or (and (equal arg '(4))
+					(eq org-use-fast-todo-selection 'prefix))
+				   (and (not arg) org-use-fast-todo-selection
+					(not (eq org-use-fast-todo-selection
+						 'prefix)))))
+			  ;; Use fast selection
+			  (org-fast-todo-selection))
+			 ((and (equal arg '(4))
+			       (or (not org-use-fast-todo-selection)
+				   (not org-todo-key-trigger)))
+			  ;; Read a state with completion
+			  (org-icompleting-read
+			   "State: " (mapcar (lambda(x) (list x))
+					     org-todo-keywords-1)
+			   nil t))
+			 ((eq arg 'right)
 			  (if this
-			      (nth (- (length org-todo-keywords-1)
-				      (length tail) 2)
-				   org-todo-keywords-1)
-			    (org-last org-todo-keywords-1))))
-		       ((and (eq org-use-fast-todo-selection t) (equal arg '(4))
-			     (setq arg nil))) ; hack to fall back to cycling
-		       (arg
-			;; user or caller requests a specific state
-			(cond
-			 ((equal arg "") nil)
-			 ((eq arg 'none) nil)
-			 ((eq arg 'done) (or done-word (car org-done-keywords)))
-			 ((eq arg 'nextset)
-			  (or (car (cdr (member head org-todo-heads)))
-			      (car org-todo-heads)))
-			 ((eq arg 'previousset)
-			  (let ((org-todo-heads (reverse org-todo-heads)))
+			      (if tail (car tail) nil)
+			    (car org-todo-keywords-1)))
+			 ((eq arg 'left)
+			  (if (equal member org-todo-keywords-1)
+			      nil
+			    (if this
+				(nth (- (length org-todo-keywords-1)
+					(length tail) 2)
+				     org-todo-keywords-1)
+			      (org-last org-todo-keywords-1))))
+			 ((and (eq org-use-fast-todo-selection t) (equal arg '(4))
+			       (setq arg nil))) ; hack to fall back to cycling
+			 (arg
+			  ;; user or caller requests a specific state
+			  (cond
+			   ((equal arg "") nil)
+			   ((eq arg 'none) nil)
+			   ((eq arg 'done) (or done-word (car org-done-keywords)))
+			   ((eq arg 'nextset)
 			    (or (car (cdr (member head org-todo-heads)))
-				(car org-todo-heads))))
-			 ((car (member arg org-todo-keywords-1)))
-			 ((stringp arg)
-			  (error "State `%s' not valid in this file" arg))
-			 ((nth (1- (prefix-numeric-value arg))
-			       org-todo-keywords-1))))
-		       ((null member) (or head (car org-todo-keywords-1)))
-		       ((equal this final-done-word) nil) ;; -> make empty
-		       ((null tail) nil) ;; -> first entry
-		       ((memq interpret '(type priority))
-			(if (eq this-command last-command)
-			    (car tail)
-			  (if (> (length tail) 0)
-			      (or done-word (car org-done-keywords))
-			    nil)))
-		       (t
-			(car tail))))
-	       (state (or
- 		       (run-hook-with-args-until-success
-			'org-todo-get-default-hook state last-state)
- 		       state))
-	       (next (if state (concat " " state " ") " "))
-	       (change-plist (list :type 'todo-state-change :from this :to state
-				   :position startpos))
-	       dolog now-done-p)
-	  (when org-blocker-hook
+				(car org-todo-heads)))
+			   ((eq arg 'previousset)
+			    (let ((org-todo-heads (reverse org-todo-heads)))
+			      (or (car (cdr (member head org-todo-heads)))
+				  (car org-todo-heads))))
+			   ((car (member arg org-todo-keywords-1)))
+			   ((stringp arg)
+			    (error "State `%s' not valid in this file" arg))
+			   ((nth (1- (prefix-numeric-value arg))
+				 org-todo-keywords-1))))
+			 ((null member) (or head (car org-todo-keywords-1)))
+			 ((equal this final-done-word) nil) ;; -> make empty
+			 ((null tail) nil) ;; -> first entry
+			 ((memq interpret '(type priority))
+			  (if (eq this-command last-command)
+			      (car tail)
+			    (if (> (length tail) 0)
+				(or done-word (car org-done-keywords))
+			      nil)))
+			 (t
+			  (car tail))))
+		 (state (or
+			 (run-hook-with-args-until-success
+			  'org-todo-get-default-hook state last-state)
+			 state))
+		 (next (if state (concat " " state " ") " "))
+		 (change-plist (list :type 'todo-state-change :from this :to state
+				     :position startpos))
+		 dolog now-done-p)
+	    (when org-blocker-hook
+	      (setq org-last-todo-state-is-todo
+		    (not (member this org-done-keywords)))
+	      (unless (save-excursion
+			(save-match-data
+			  (org-with-wide-buffer
+			   (run-hook-with-args-until-failure
+			    'org-blocker-hook change-plist))))
+		(if (org-called-interactively-p 'interactive)
+		    (error "TODO state change from %s to %s blocked" this state)
+		  ;; fail silently
+		  (message "TODO state change from %s to %s blocked" this state)
+		  (throw 'exit nil))))
+	    (store-match-data match-data)
+	    (replace-match next t t)
+	    (unless (pos-visible-in-window-p hl-pos)
+	      (message "TODO state changed to %s" (org-trim next)))
+	    (unless head
+	      (setq head (org-get-todo-sequence-head state)
+		    ass (assoc head org-todo-kwd-alist)
+		    interpret (nth 1 ass)
+		    done-word (nth 3 ass)
+		    final-done-word (nth 4 ass)))
+	    (when (memq arg '(nextset previousset))
+	      (message "Keyword-Set %d/%d: %s"
+		       (- (length org-todo-sets) -1
+			  (length (memq (assoc state org-todo-sets) org-todo-sets)))
+		       (length org-todo-sets)
+		       (mapconcat 'identity (assoc state org-todo-sets) " ")))
 	    (setq org-last-todo-state-is-todo
-		  (not (member this org-done-keywords)))
-	    (unless (save-excursion
-		      (save-match-data
-			(org-with-wide-buffer
-			 (run-hook-with-args-until-failure
-			  'org-blocker-hook change-plist))))
-	      (if (org-called-interactively-p 'interactive)
-		  (error "TODO state change from %s to %s blocked" this state)
-		;; fail silently
-		(message "TODO state change from %s to %s blocked" this state)
-		(throw 'exit nil))))
-	  (store-match-data match-data)
-	  (replace-match next t t)
-	  (unless (pos-visible-in-window-p hl-pos)
-	    (message "TODO state changed to %s" (org-trim next)))
-	  (unless head
-	    (setq head (org-get-todo-sequence-head state)
-		  ass (assoc head org-todo-kwd-alist)
-		  interpret (nth 1 ass)
-		  done-word (nth 3 ass)
-		  final-done-word (nth 4 ass)))
-	  (when (memq arg '(nextset previousset))
-	    (message "Keyword-Set %d/%d: %s"
-		     (- (length org-todo-sets) -1
-			(length (memq (assoc state org-todo-sets) org-todo-sets)))
-		     (length org-todo-sets)
-		     (mapconcat 'identity (assoc state org-todo-sets) " ")))
-	  (setq org-last-todo-state-is-todo
-		(not (member state org-done-keywords)))
-	  (setq now-done-p (and (member state org-done-keywords)
-				(not (member this org-done-keywords))))
-	  (and logging (org-local-logging logging))
-	  (when (and (or org-todo-log-states org-log-done)
-		     (not (eq org-inhibit-logging t))
-		     (not (memq arg '(nextset previousset))))
-	    ;; we need to look at recording a time and note
-	    (setq dolog (or (nth 1 (assoc state org-todo-log-states))
-			    (nth 2 (assoc this org-todo-log-states))))
-	    (if (and (eq dolog 'note) (eq org-inhibit-logging 'note))
-		(setq dolog 'time))
-	    (when (and state
-		       (member state org-not-done-keywords)
-		       (not (member this org-not-done-keywords)))
-	      ;; This is now a todo state and was not one before
-	      ;; If there was a CLOSED time stamp, get rid of it.
-	      (org-add-planning-info nil nil 'closed))
-	    (when (and now-done-p org-log-done)
-	      ;; It is now done, and it was not done before
-	      (org-add-planning-info 'closed (org-current-effective-time))
-	      (if (and (not dolog) (eq 'note org-log-done))
-		  (org-add-log-setup 'done state this 'findpos 'note)))
-	    (when (and state dolog)
-	      ;; This is a non-nil state, and we need to log it
-	      (org-add-log-setup 'state state this 'findpos dolog)))
-	  ;; Fixup tag positioning
-	  (org-todo-trigger-tag-changes state)
-	  (and org-auto-align-tags (not org-setting-tags) (org-set-tags nil t))
-	  (when org-provide-todo-statistics
-	    (org-update-parent-todo-statistics))
-	  (run-hooks 'org-after-todo-state-change-hook)
-	  (if (and arg (not (member state org-done-keywords)))
-	      (setq head (org-get-todo-sequence-head state)))
-	  (put-text-property (point-at-bol) (point-at-eol) 'org-todo-head head)
-	  ;; Do we need to trigger a repeat?
-	  (when now-done-p
-	    (when (boundp 'org-agenda-headline-snapshot-before-repeat)
-	      ;; This is for the agenda, take a snapshot of the headline.
-	      (save-match-data
-		(setq org-agenda-headline-snapshot-before-repeat
-		      (org-get-heading))))
-	    (org-auto-repeat-maybe state))
-	  ;; Fixup cursor location if close to the keyword
-	  (if (and (outline-on-heading-p)
-		   (not (bolp))
-		   (save-excursion (beginning-of-line 1)
-				   (looking-at org-todo-line-regexp))
-		   (< (point) (+ 2 (or (match-end 2) (match-end 1)))))
-	      (progn
-		(goto-char (or (match-end 2) (match-end 1)))
-		(and (looking-at " ") (just-one-space))))
-	  (when org-trigger-hook
-	    (save-excursion
-	      (run-hook-with-args 'org-trigger-hook change-plist))))))))
+		  (not (member state org-done-keywords)))
+	    (setq now-done-p (and (member state org-done-keywords)
+				  (not (member this org-done-keywords))))
+	    (and logging (org-local-logging logging))
+	    (when (and (or org-todo-log-states org-log-done)
+		       (not (eq org-inhibit-logging t))
+		       (not (memq arg '(nextset previousset))))
+	      ;; we need to look at recording a time and note
+	      (setq dolog (or (nth 1 (assoc state org-todo-log-states))
+			      (nth 2 (assoc this org-todo-log-states))))
+	      (if (and (eq dolog 'note) (eq org-inhibit-logging 'note))
+		  (setq dolog 'time))
+	      (when (and state
+			 (member state org-not-done-keywords)
+			 (not (member this org-not-done-keywords)))
+		;; This is now a todo state and was not one before
+		;; If there was a CLOSED time stamp, get rid of it.
+		(org-add-planning-info nil nil 'closed))
+	      (when (and now-done-p org-log-done)
+		;; It is now done, and it was not done before
+		(org-add-planning-info 'closed (org-current-effective-time))
+		(if (and (not dolog) (eq 'note org-log-done))
+		    (org-add-log-setup 'done state this 'findpos 'note)))
+	      (when (and state dolog)
+		;; This is a non-nil state, and we need to log it
+		(org-add-log-setup 'state state this 'findpos dolog)))
+	    ;; Fixup tag positioning
+	    (org-todo-trigger-tag-changes state)
+	    (and org-auto-align-tags (not org-setting-tags) (org-set-tags nil t))
+	    (when org-provide-todo-statistics
+	      (org-update-parent-todo-statistics))
+	    (run-hooks 'org-after-todo-state-change-hook)
+	    (if (and arg (not (member state org-done-keywords)))
+		(setq head (org-get-todo-sequence-head state)))
+	    (put-text-property (point-at-bol) (point-at-eol) 'org-todo-head head)
+	    ;; Do we need to trigger a repeat?
+	    (when now-done-p
+	      (when (boundp 'org-agenda-headline-snapshot-before-repeat)
+		;; This is for the agenda, take a snapshot of the headline.
+		(save-match-data
+		  (setq org-agenda-headline-snapshot-before-repeat
+			(org-get-heading))))
+	      (org-auto-repeat-maybe state))
+	    ;; Fixup cursor location if close to the keyword
+	    (if (and (outline-on-heading-p)
+		     (not (bolp))
+		     (save-excursion (beginning-of-line 1)
+				     (looking-at org-todo-line-regexp))
+		     (< (point) (+ 2 (or (match-end 2) (match-end 1)))))
+		(progn
+		  (goto-char (or (match-end 2) (match-end 1)))
+		  (and (looking-at " ") (just-one-space))))
+	    (when org-trigger-hook
+	      (save-excursion
+		(run-hook-with-args 'org-trigger-hook change-plist)))))))))
 
 (defun org-block-todo-from-children-or-siblings-or-parent (change-plist)
   "Block turning an entry into a TODO, using the hierarchy.
@@ -11938,9 +11952,13 @@ With argument TIME, set the deadline at the corresponding date.  TIME
 can either be an Org date like \"2011-07-24\" or a delta like \"+2d\"."
   (interactive "P")
   (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
-      (let (org-loop-over-headlines-in-active-region)
+      (let ((cl (if (eq org-loop-over-headlines-in-active-region 'start-level)
+		    'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
 	(org-map-entries
-	 `(org-deadline ',remove ,time) org-loop-over-headlines-in-active-region 'region (if (outline-invisible-p) (org-end-of-subtree nil t))))
+	 `(org-deadline ',remove ,time)
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
     (let* ((old-date (org-entry-get nil "DEADLINE"))
 	   (repeater (and old-date
 			  (string-match
@@ -11982,9 +12000,13 @@ With argument TIME, scheduled at the corresponding date.  TIME can
 either be an Org date like \"2011-07-24\" or a delta like \"+2d\"."
   (interactive "P")
   (if (and (org-region-active-p) org-loop-over-headlines-in-active-region)
-      (let (org-loop-over-headlines-in-active-region)
+      (let ((cl (if (eq org-loop-over-headlines-in-active-region 'start-level)
+		    'region-start-level 'region))
+	    org-loop-over-headlines-in-active-region)
 	(org-map-entries
-	 `(org-schedule ',remove ,time) org-loop-over-headlines-in-active-region 'region (if (outline-invisible-p) (org-end-of-subtree nil t))))
+	 `(org-schedule ',remove ,time)
+	 org-loop-over-headlines-in-active-region
+	 cl (if (outline-invisible-p) (org-end-of-subtree nil t))))
     (let* ((old-date (org-entry-get nil "SCHEDULED"))
 	   (repeater (and old-date
 			  (string-match
@@ -12402,7 +12424,7 @@ b      Show deadlines and scheduled items before a date.
 a      Show deadlines and scheduled items after a date."
   (interactive "P")
   (let (ans kwd value)
-    (message "Sparse tree: [r]egexp [/]regexp [t]odo [T]odo-kwd [m]atch [p]roperty\n             [d]eadlines [b]efore-date [a]fter-date")
+    (message "Sparse tree: [r]egexp [/]regexp [t]odo [T]odo-kwd [m]atch [p]roperty\n             [d]eadlines [b]efore-date [a]fter-date [D]ates range")
     (setq ans (read-char-exclusive))
     (cond
      ((equal ans ?d)
@@ -12411,6 +12433,8 @@ a      Show deadlines and scheduled items after a date."
       (call-interactively 'org-check-before-date))
      ((equal ans ?a)
       (call-interactively 'org-check-after-date))
+     ((equal ans ?D)
+      (call-interactively 'org-check-dates-range))
      ((equal ans ?t)
       (org-show-todo-tree nil))
      ((equal ans ?T)
@@ -12513,8 +12537,8 @@ starting point when no match is found."
 (defun org-show-context (&optional key)
   "Make sure point and context are visible.
 How much context is shown depends upon the variables
-`org-show-hierarchy-above', `org-show-following-heading'. and
-`org-show-siblings'."
+`org-show-hierarchy-above', `org-show-following-heading',
+`org-show-entry-below' and `org-show-siblings'."
   (let ((heading-p   (org-on-heading-p t))
 	(hierarchy-p (org-get-alist-option org-show-hierarchy-above key))
 	(following-p (org-get-alist-option org-show-following-heading key))
@@ -12718,7 +12742,7 @@ obtain a list of properties.  Building the tags list for each entry in such
 a file becomes an N^2 operation - but with this variable set, it scales
 as N.")
 
-(defun org-scan-tags (action matcher &optional todo-only)
+(defun org-scan-tags (action matcher &optional todo-only start-level)
   "Scan headline tags with inheritance and produce output ACTION.
 
 ACTION can be `sparse-tree' to produce a sparse tree in the current buffer,
@@ -12728,9 +12752,17 @@ this case the return value is a list of all return values from these calls.
 
 MATCHER is a Lisp form to be evaluated, testing if a given set of tags
 qualifies a headline for inclusion.  When TODO-ONLY is non-nil,
-only lines with a TODO keyword are included in the output."
+only lines with a TODO keyword are included in the output.
+
+START-LEVEL can be a string with asterisks, reducing the scope to
+headlines matching this string."
   (require 'org-agenda)
-  (let* ((re (concat "^" org-outline-regexp " *\\(\\<\\("
+  (let* ((re (concat "^"
+		     (if start-level
+			 ;; Get the correct level to match
+			 (concat "\\*\\{" (number-to-string start-level) "\\} ")
+		       org-outline-regexp)
+		     " *\\(\\<\\("
 		     (mapconcat 'regexp-quote org-todo-keywords-1 "\\|")
 		     (org-re
 		      "\\>\\)\\)? *\\(.*?\\)\\(:[[:alnum:]_@#%:]+:\\)?[ \t]*$")))
@@ -13725,6 +13757,9 @@ SCOPE determines the scope of this command.  It can be any of:
 nil     The current buffer, respecting the restriction if any
 tree    The subtree started with the entry at point
 region  The entries within the active region, if any
+region-start-level
+        The entries within the active region, but only those at
+        the same level than the first one.
 file    The current buffer, without restriction
 file-with-archives
         The current buffer, and any archives associated with it
@@ -13753,13 +13788,15 @@ with `org-get-tags-at'.  If your function gets properties with
 to t around the call to `org-entry-properties' to get the same speedup.
 Note that if your function moves around to retrieve tags and properties at
 a *different* entry, you cannot use these techniques."
-  (unless (and (eq scope 'region) (not (org-region-active-p)))
+  (unless (and (or (eq scope 'region) (eq scope 'region-start-level))
+	       (not (org-region-active-p)))
     (let* ((org-agenda-archives-mode nil) ; just to make sure
 	   (org-agenda-skip-archived-trees (memq 'archive skip))
 	   (org-agenda-skip-comment-trees (memq 'comment skip))
 	   (org-agenda-skip-function
 	    (car (org-delete-all '(comment archive) skip)))
 	   (org-tags-match-list-sublevels t)
+	   (start-level (eq scope 'region-start-level))
 	   matcher file res
 	   org-todo-keywords-for-agenda
 	   org-done-keywords-for-agenda
@@ -13778,7 +13815,14 @@ a *different* entry, you cannot use these techniques."
 		 (org-back-to-heading t)
 		 (org-narrow-to-subtree)
 		 (setq scope nil))
-		((and (eq scope 'region) (org-region-active-p))
+		((and (or (eq scope 'region) (eq scope 'region-start-level))
+		      (org-region-active-p))
+		 ;; If needed, set start-level to a string like "2"
+		 (when start-level
+		   (save-excursion
+		     (goto-char (region-beginning))
+		     (unless (org-at-heading-p) (outline-next-heading))
+		     (setq start-level (org-current-level))))
 		 (narrow-to-region (region-beginning)
 				   (save-excursion
 				     (goto-char (region-end))
@@ -13791,7 +13835,7 @@ a *different* entry, you cannot use these techniques."
 	      (progn
 		(org-prepare-agenda-buffers
 		 (list (buffer-file-name (current-buffer))))
-		(setq res (org-scan-tags func matcher)))
+		(setq res (org-scan-tags func matcher nil start-level)))
 	    ;; Get the right scope
 	    (cond
 	     ((and scope (listp scope) (symbolp (car scope)))
@@ -15504,6 +15548,27 @@ days.  If the prefix is a raw \\[universal-argument] prefix, all deadlines are s
     (message "%d entries after %s"
 	     (org-occur regexp nil callback) date)))
 
+(defun org-check-dates-range (start-date end-date)
+  "Check for deadlines/scheduled entries between START-DATE and END-DATE."
+  (interactive (list (org-read-date nil nil nil "Range starts")
+		     (org-read-date nil nil nil "Range end")))
+  (let ((case-fold-search nil)
+	(regexp (concat "\\<\\(" org-deadline-string
+			"\\|" org-scheduled-string
+			"\\) *<\\([^>]+\\)>"))
+	(callback
+	 (lambda ()
+	   (let ((match (match-string 2)))
+	     (and
+	      (not (time-less-p
+		    (org-time-string-to-time match)
+		    (org-time-string-to-time start-date)))
+	      (time-less-p
+	       (org-time-string-to-time match)
+	       (org-time-string-to-time end-date)))))))
+    (message "%d entries between %s and %s"
+	     (org-occur regexp nil callback) start-date end-date)))
+
 (defun org-evaluate-time-range (&optional to-buffer)
   "Evaluate a time range by computing the difference between start and end.
 Normally the result is just printed in the echo area, but with prefix arg