Remove OrgStruct mode

* lisp/org.el (org-overview): Use `org-outline-regexp-bol' instead of
  `outline-regexp'.
(org-heading-components): Ignore orgstruct-mode.
(orgstruct-heading-prefix-regexp):
(orgstruct-setup-hook):
(org-local-vars):
(orgstruct-mode):
(turn-on-orgstruct):
(orgstruct-is-++):
(org-fb-vars):
(orgstruct++-mode):
(turn-on-orgstruct++):
(orgstruct-error):
(orgstruct-setup):
(orgstruct-make-binding):
(org-run-like-in-org-mode):
(org-indent-line):
(org-fill-paragraph):
(org-show-children): Remove Orgstruct mode

* doc/org.texi (Orgstruct mode): Remove node.
This commit is contained in:
Nicolas Goaziou 2017-09-08 00:03:40 +02:00
parent d4d9e90d19
commit eeb4c22090
3 changed files with 39 additions and 430 deletions

View File

@ -1374,46 +1374,6 @@ The following command handles footnotes:
reference, and you can use the usual commands to follow these reference, and you can use the usual commands to follow these
links. links.
** The Orgstruct minor mode
:PROPERTIES:
:DESCRIPTION: Structure editing outside Org.
:ALT_TITLE: Orgstruct mode
:END:
#+cindex: Orgstruct mode
#+cindex: minor mode for structure editing
If you like the intuitive way the Org mode structure editing and list
formatting works, you might want to use these commands in other modes
like Text mode or Mail mode as well. The minor mode ~orgstruct-mode~
makes this possible. Toggle the mode with {{{kbd(M-x
orgstruct-mode)}}}, or turn it on by default, for example in Message
mode, with one of:
#+begin_src emacs-lisp
(add-hook 'message-mode-hook 'turn-on-orgstruct)
(add-hook 'message-mode-hook 'turn-on-orgstruct++)
#+end_src
When this mode is active and the cursor is on a line that looks to Org
like a headline or the first line of a list item, most structure
editing commands will work, even if the same keys normally have
different functionality in the major mode you are using. If the
cursor is not in one of those special lines, Orgstruct mode lurks
silently in the shadows.
When you use ~orgstruct++-mode~, Org will also export indentation and
Auto Fill settings into that mode, and detect item context after the
first line of an item.
#+vindex: orgstruct-heading-prefix-regexp
You can also use Org structure editing to fold and unfold headlines in
/any/ file, provided you defined ~orgstruct-heading-prefix-regexp~:
the regular expression must match the local prefix to use before Org's
headlines. For example, if you set this variable to ~";; "~ in Emacs
Lisp files, you will be able to fold and unfold headlines in Emacs
Lisp commented lines. Some commands like ~org-demote~ are disabled
when the prefix is set, but folding/unfolding will work correctly.
** Org syntax ** Org syntax
:PROPERTIES: :PROPERTIES:
:DESCRIPTION: Formal description of Org's syntax. :DESCRIPTION: Formal description of Org's syntax.
@ -19302,12 +19262,6 @@ functions. Also the burden of developing custom translate functions
for new table formats is in the hands of those who know those formats for new table formats is in the hands of those who know those formats
best. best.
For an example of how this strategy works, see Orgstruct mode. In
that mode, Bastien added the ability to use Org's facilities to edit
and re-structure lists. He did this by turning Orgstruct mode on, and
then exporting the list locally to another format, such as HTML, LaTeX
or Texinfo.
*** Radio tables *** Radio tables
:PROPERTIES: :PROPERTIES:
:DESCRIPTION: Sending and receiving radio tables. :DESCRIPTION: Sending and receiving radio tables.

View File

@ -355,7 +355,6 @@ Document structure
* Drawers:: Tucking stuff away * Drawers:: Tucking stuff away
* Blocks:: Folding blocks * Blocks:: Folding blocks
* Footnotes:: How footnotes are defined in Org's syntax * Footnotes:: How footnotes are defined in Org's syntax
* Orgstruct mode:: Structure editing outside Org
* Org syntax:: Formal description of Org's syntax * Org syntax:: Formal description of Org's syntax
Visibility cycling Visibility cycling
@ -1160,7 +1159,6 @@ edit the structure of the document.
* Drawers:: Tucking stuff away * Drawers:: Tucking stuff away
* Blocks:: Folding blocks * Blocks:: Folding blocks
* Footnotes:: How footnotes are defined in Org's syntax * Footnotes:: How footnotes are defined in Org's syntax
* Orgstruct mode:: Structure editing outside Org
* Org syntax:: Formal description of Org's syntax * Org syntax:: Formal description of Org's syntax
@end menu @end menu
@ -1990,41 +1988,6 @@ a separate window. The window can be closed by pressing @kbd{C-c '}.
@end table @end table
@node Orgstruct mode
@section The Orgstruct minor mode
@cindex Orgstruct mode
@cindex minor mode for structure editing
If you like the intuitive way the Org mode structure editing and list
formatting works, you might want to use these commands in other modes like
Text mode or Mail mode as well. The minor mode @code{orgstruct-mode} makes
this possible. Toggle the mode with @kbd{M-x orgstruct-mode RET}, or
turn it on by default, for example in Message mode, with one of:
@lisp
(add-hook 'message-mode-hook 'turn-on-orgstruct)
(add-hook 'message-mode-hook 'turn-on-orgstruct++)
@end lisp
When this mode is active and the cursor is on a line that looks to Org like a
headline or the first line of a list item, most structure editing commands
will work, even if the same keys normally have different functionality in the
major mode you are using. If the cursor is not in one of those special
lines, Orgstruct mode lurks silently in the shadows.
When you use @code{orgstruct++-mode}, Org will also export indentation and
autofill settings into that mode, and detect item context after the first
line of an item.
@vindex orgstruct-heading-prefix-regexp
You can also use Org structure editing to fold and unfold headlines in
@emph{any} file, provided you defined @code{orgstruct-heading-prefix-regexp}:
the regular expression must match the local prefix to use before Org's
headlines. For example, if you set this variable to @code{";; "} in Emacs
Lisp files, you will be able to fold and unfold headlines in Emacs Lisp
commented lines. Some commands like @code{org-demote} are disabled when the
prefix is set, but folding/unfolding will work correctly.
@node Org syntax @node Org syntax
@section Org syntax @section Org syntax
@cindex Org syntax @cindex Org syntax

View File

@ -93,11 +93,6 @@
;; `org-outline-regexp' ought to be a defconst but is let-bound in ;; `org-outline-regexp' ought to be a defconst but is let-bound in
;; some places -- e.g. see the macro `org-with-limited-levels'. ;; some places -- e.g. see the macro `org-with-limited-levels'.
;;
;; In Org buffers, the value of `outline-regexp' is that of
;; `org-outline-regexp'. The only function still directly relying on
;; `outline-regexp' is `org-overview' so that `org-cycle' can do its
;; job when `orgstruct-mode' is active.
(defvar org-outline-regexp "\\*+ " (defvar org-outline-regexp "\\*+ "
"Regexp to match Org headlines.") "Regexp to match Org headlines.")
@ -6977,9 +6972,6 @@ With a numeric prefix, show all headlines up to that level."
(org-cycle-hide-drawers 'all) (org-cycle-hide-drawers 'all)
(org-cycle-show-empty-lines 'all)))) (org-cycle-show-empty-lines 'all))))
;; This function uses outline-regexp instead of the more fundamental
;; org-outline-regexp so that org-cycle-global works outside of Org
;; buffers, where outline-regexp is needed.
(defun org-overview () (defun org-overview ()
"Switch to overview mode, showing only top-level headlines. "Switch to overview mode, showing only top-level headlines.
This shows all headlines with a level equal or greater than the level This shows all headlines with a level equal or greater than the level
@ -6991,7 +6983,7 @@ results."
(let ((level (let ((level
(save-excursion (save-excursion
(goto-char (point-min)) (goto-char (point-min))
(when (re-search-forward (concat "^" outline-regexp) nil t) (when (re-search-forward org-outline-regexp-bol nil t)
(goto-char (match-beginning 0)) (goto-char (match-beginning 0))
(funcall outline-level))))) (funcall outline-level)))))
(and level (outline-hide-sublevels level))))) (and level (outline-hide-sublevels level)))))
@ -7599,8 +7591,6 @@ When NO-COMMENT is non-nil, don't include COMMENT string."
(delq nil (list todo priority headline tags)) (delq nil (list todo priority headline tags))
" "))))) " ")))))
(defvar orgstruct-mode) ; defined below
(defun org-heading-components () (defun org-heading-components ()
"Return the components of the current heading. "Return the components of the current heading.
This is a list with the following elements: This is a list with the following elements:
@ -7612,24 +7602,13 @@ This is a list with the following elements:
- the tags string, or nil." - the tags string, or nil."
(save-excursion (save-excursion
(org-back-to-heading t) (org-back-to-heading t)
(when (let (case-fold-search) (when (let (case-fold-search) (looking-at org-complex-heading-regexp))
(looking-at (list (length (match-string 1))
(if orgstruct-mode (org-reduced-level (length (match-string 1)))
org-heading-regexp (match-string-no-properties 2)
org-complex-heading-regexp))) (and (match-end 3) (aref (match-string 3) 2))
(if orgstruct-mode (match-string-no-properties 4)
(list (length (match-string 1)) (match-string-no-properties 5)))))
(org-reduced-level (length (match-string 1)))
nil
nil
(match-string 2)
nil)
(list (length (match-string 1))
(org-reduced-level (length (match-string 1)))
(match-string-no-properties 2)
(and (match-end 3) (aref (match-string 3) 2))
(match-string-no-properties 4)
(match-string-no-properties 5))))))
(defun org-get-entry () (defun org-get-entry ()
"Get the entry text, after heading, entire subtree." "Get the entry text, after heading, entire subtree."
@ -8792,272 +8771,6 @@ function is being called interactively."
(run-hooks 'org-after-sorting-entries-or-items-hook) (run-hooks 'org-after-sorting-entries-or-items-hook)
(message "Sorting entries...done"))) (message "Sorting entries...done")))
;;; The orgstruct minor mode
;; Define a minor mode which can be used in other modes in order to
;; integrate the Org mode structure editing commands.
;; This is really a hack, because the Org mode structure commands use
;; keys which normally belong to the major mode. Here is how it
;; works: The minor mode defines all the keys necessary to operate the
;; structure commands, but wraps the commands into a function which
;; tests if the cursor is currently at a headline or a plain list
;; item. If that is the case, the structure command is used,
;; temporarily setting many Org mode variables like regular
;; expressions for filling etc. However, when any of those keys is
;; used at a different location, function uses `key-binding' to look
;; up if the key has an associated command in another currently active
;; keymap (minor modes, major mode, global), and executes that
;; command. There might be problems if any of the keys is otherwise
;; used as a prefix key.
(defcustom orgstruct-heading-prefix-regexp ""
"Regexp that matches the custom prefix of Org headlines in
orgstruct(++)-mode."
:group 'org
:version "26.1"
:package-version '(Org . "8.3")
:type 'regexp)
;;;###autoload(put 'orgstruct-heading-prefix-regexp 'safe-local-variable 'stringp)
(defcustom orgstruct-setup-hook nil
"Hook run after orgstruct-mode-map is filled."
:group 'org
:version "24.4"
:package-version '(Org . "8.0")
:type 'hook)
(defvar orgstruct-initialized nil)
(defvar org-local-vars nil
"List of local variables, for use by `orgstruct-mode'.")
;;;###autoload
(define-minor-mode orgstruct-mode
"Toggle the minor mode `orgstruct-mode'.
This mode is for using Org mode structure commands in other
modes. The following keys behave as if Org mode were active, if
the cursor is on a headline, or on a plain list item (both as
defined by Org mode)."
nil " OrgStruct" (make-sparse-keymap)
(funcall (if orgstruct-mode
'add-to-invisibility-spec
'remove-from-invisibility-spec)
'(outline . t))
(when orgstruct-mode
(org-load-modules-maybe)
(unless orgstruct-initialized
(orgstruct-setup)
(setq orgstruct-initialized t))))
;;;###autoload
(defun turn-on-orgstruct ()
"Unconditionally turn on `orgstruct-mode'."
(orgstruct-mode 1))
(defvar-local orgstruct-is-++ nil
"Is `orgstruct-mode' in ++ version in the current-buffer?")
(defvar-local org-fb-vars nil)
(defun orgstruct++-mode (&optional arg)
"Toggle `orgstruct-mode', the enhanced version of it.
In addition to setting orgstruct-mode, this also exports all
indentation and autofilling variables from Org mode into the
buffer. It will also recognize item context in multiline items."
(interactive "P")
(setq arg (prefix-numeric-value (or arg (if orgstruct-mode -1 1))))
(if (< arg 1)
(progn (orgstruct-mode -1)
(dolist (v org-fb-vars)
(set (make-local-variable (car v))
(if (eq (car-safe (cadr v)) 'quote)
(cl-cadadr v)
(nth 1 v)))))
(orgstruct-mode 1)
(setq org-fb-vars nil)
(unless org-local-vars
(setq org-local-vars (org-get-local-variables)))
(let (var val)
(dolist (x org-local-vars)
(when (string-match
"^\\(paragraph-\\|auto-fill\\|normal-auto-fill\\|fill-paragraph\
\\|fill-prefix\\|indent-\\)"
(symbol-name (car x)))
(setq var (car x) val (nth 1 x))
(push (list var `(quote ,(eval var))) org-fb-vars)
(set (make-local-variable var)
(if (eq (car-safe val) 'quote) (nth 1 val) val))))
(setq-local orgstruct-is-++ t))))
;;;###autoload
(defun turn-on-orgstruct++ ()
"Unconditionally turn on `orgstruct++-mode'."
(orgstruct++-mode 1))
(defun orgstruct-error ()
"Error when there is no default binding for a structure key."
(interactive)
(funcall (if (fboundp 'user-error)
'user-error
'error)
"This key has no function outside structure elements"))
(defun orgstruct-setup ()
"Setup orgstruct keymap."
(dolist (cell '((org-demote . t)
(org-metaleft . t)
(org-metaright . t)
(org-promote . t)
(org-shiftmetaleft . t)
(org-shiftmetaright . t)
org-backward-element
org-backward-heading-same-level
org-ctrl-c-ret
org-ctrl-c-minus
org-ctrl-c-star
org-cycle
org-force-cycle-archived
org-forward-heading-same-level
org-insert-heading
org-insert-heading-respect-content
org-kill-note-or-show-branches
org-mark-subtree
org-meta-return
org-metadown
org-metaup
org-narrow-to-subtree
org-promote-subtree
org-reveal
org-shiftdown
org-shiftleft
org-shiftmetadown
org-shiftmetaup
org-shiftright
org-shifttab
org-shifttab
org-shiftup
org-show-children
org-show-subtree
org-sort
org-up-element
outline-demote
outline-next-visible-heading
outline-previous-visible-heading
outline-promote
outline-up-heading))
(let ((f (or (car-safe cell) cell))
(disable-when-heading-prefix (cdr-safe cell)))
(when (fboundp f)
(let ((new-bindings))
(dolist (binding (nconc (where-is-internal f org-mode-map)
(where-is-internal f outline-mode-map)))
(push binding new-bindings)
;; TODO use local-function-key-map
(dolist (rep '(("<tab>" . "TAB")
("<return>" . "RET")
("<escape>" . "ESC")
("<delete>" . "DEL")))
(setq binding (read-kbd-macro
(let ((case-fold-search))
(replace-regexp-in-string
(regexp-quote (cdr rep))
(car rep)
(key-description binding)))))
(cl-pushnew binding new-bindings :test 'equal)))
(dolist (binding new-bindings)
(let ((key (lookup-key orgstruct-mode-map binding)))
(when (or (not key) (numberp key))
(ignore-errors
(org-defkey orgstruct-mode-map
binding
(orgstruct-make-binding
f binding disable-when-heading-prefix))))))))))
(run-hooks 'orgstruct-setup-hook))
(defun orgstruct-make-binding (fun key disable-when-heading-prefix)
"Create a function for binding in the structure minor mode.
FUN is the command to call inside a table. KEY is the key that
should be checked in for a command to execute outside of tables.
Non-nil `disable-when-heading-prefix' means to disable the command
if `orgstruct-heading-prefix-regexp' is not empty."
(let ((name (concat "orgstruct-hijacker-" (symbol-name fun))))
(let ((nname name)
(i 0))
(while (fboundp (intern nname))
(setq nname (format "%s-%d" name (setq i (1+ i)))))
(setq name (intern nname)))
(eval
(let ((bindings '((org-heading-regexp
(concat "^"
orgstruct-heading-prefix-regexp
"\\(\\*+\\)\\(?: +\\(.*?\\)\\)?[ ]*$"))
(org-outline-regexp
(concat orgstruct-heading-prefix-regexp "\\*+ "))
(org-outline-regexp-bol
(concat "^" org-outline-regexp))
(outline-regexp org-outline-regexp)
(outline-heading-end-regexp "\n")
(outline-level 'org-outline-level)
(outline-heading-alist))))
`(defun ,name (arg)
,(concat "In Structure, run `" (symbol-name fun) "'.\n"
"Outside of structure, run the binding of `"
(key-description key) "'."
(when disable-when-heading-prefix
(concat
"\nIf `orgstruct-heading-prefix-regexp' is not empty, this command will always fall\n"
"back to the default binding due to limitations of Org's implementation of\n"
"`" (symbol-name fun) "'.")))
(interactive "p")
(let* ((disable
,(and disable-when-heading-prefix
'(not (string= orgstruct-heading-prefix-regexp ""))))
(fallback
(or disable
(not
(let* ,bindings
(org-context-p 'headline 'item
,(when (memq fun
'(org-insert-heading
org-insert-heading-respect-content
org-meta-return))
'(when orgstruct-is-++
'item-body))))))))
(if fallback
(let* ((orgstruct-mode)
(binding
(let ((key ,key))
(catch 'exit
(dolist
(rep
'(nil
("<\\([^>]*\\)tab>" . "\\1TAB")
("<\\([^>]*\\)return>" . "\\1RET")
("<\\([^>]*\\)escape>" . "\\1ESC")
("<\\([^>]*\\)delete>" . "\\1DEL"))
nil)
(when rep
(setq key (read-kbd-macro
(let ((case-fold-search))
(replace-regexp-in-string
(car rep)
(cdr rep)
(key-description key))))))
(when (key-binding key)
(throw 'exit (key-binding key))))))))
(if (keymapp binding)
(org-set-transient-map binding)
(let ((func (or binding
(unless disable
'orgstruct-error))))
(when func
(call-interactively func)))))
(org-run-like-in-org-mode
(lambda ()
(interactive)
(let* ,bindings
(call-interactively ',fun)))))))))
name))
(defun org-contextualize-keys (alist contexts) (defun org-contextualize-keys (alist contexts)
"Return valid elements in ALIST depending on CONTEXTS. "Return valid elements in ALIST depending on CONTEXTS.
@ -9157,10 +8870,8 @@ This will temporarily bind local variables that are typically bound in
Org mode to the values they have in Org mode, and then interactively Org mode to the values they have in Org mode, and then interactively
call CMD." call CMD."
(org-load-modules-maybe) (org-load-modules-maybe)
(unless org-local-vars
(setq org-local-vars (org-get-local-variables)))
(let (binds) (let (binds)
(dolist (var org-local-vars) (dolist (var (org-get-local-variables))
(when (or (not (boundp (car var))) (when (or (not (boundp (car var)))
(eq (symbol-value (car var)) (eq (symbol-value (car var))
(default-value (car var)))) (default-value (car var))))
@ -22080,10 +21791,6 @@ list structure. Instead, use \\<org-mode-map>`\\[org-shiftmetaleft]' or \
Also align node properties according to `org-property-format'." Also align node properties according to `org-property-format'."
(interactive) (interactive)
(cond (cond
(orgstruct-is-++
(let ((indent-line-function
(cl-cadadr (assq 'indent-line-function org-fb-vars))))
(indent-according-to-mode)))
((org-at-heading-p) 'noindent) ((org-at-heading-p) 'noindent)
(t (t
(let* ((element (save-excursion (beginning-of-line) (org-element-at-point))) (let* ((element (save-excursion (beginning-of-line) (org-element-at-point)))
@ -22549,18 +22256,6 @@ filling the current element."
(barf-if-buffer-read-only) (barf-if-buffer-read-only)
(list (if current-prefix-arg 'full) t))) (list (if current-prefix-arg 'full) t)))
(cond (cond
((and (derived-mode-p 'message-mode)
(or (not (message-in-body-p))
(save-excursion (move-beginning-of-line 1)
(looking-at message-cite-prefix-regexp))))
;; First ensure filling is correct in message-mode.
(let ((fill-paragraph-function
(cl-cadadr (assq 'fill-paragraph-function org-fb-vars)))
(fill-prefix (cl-cadadr (assq 'fill-prefix org-fb-vars)))
(paragraph-start (cl-cadadr (assq 'paragraph-start org-fb-vars)))
(paragraph-separate
(cl-cadadr (assq 'paragraph-separate org-fb-vars))))
(fill-paragraph nil)))
((and region transient-mark-mode mark-active ((and region transient-mark-mode mark-active
(not (eq (region-beginning) (region-end)))) (not (eq (region-beginning) (region-end))))
(let ((origin (point-marker)) (let ((origin (point-marker))
@ -24021,39 +23716,36 @@ Prefix arg LEVEL is how many levels below the current level
should be shown. Default is enough to cause the following should be shown. Default is enough to cause the following
heading to appear." heading to appear."
(interactive "p") (interactive "p")
;; If `orgstruct-mode' is active, use the slower version. (save-excursion
(if orgstruct-mode (call-interactively #'outline-show-children) (org-back-to-heading t)
(save-excursion (let* ((current-level (funcall outline-level))
(org-back-to-heading t) (max-level (org-get-valid-level
(let* ((current-level (funcall outline-level)) current-level
(max-level (org-get-valid-level (if level (prefix-numeric-value level) 1)))
current-level (end (save-excursion (org-end-of-subtree t t)))
(if level (prefix-numeric-value level) 1))) (regexp-fmt "^\\*\\{%d,%s\\}\\(?: \\|$\\)")
(end (save-excursion (org-end-of-subtree t t))) (past-first-child nil)
(regexp-fmt "^\\*\\{%d,%s\\}\\(?: \\|$\\)") ;; Make sure to skip inlinetasks.
(past-first-child nil) (re (format regexp-fmt
;; Make sure to skip inlinetasks. current-level
(re (format regexp-fmt (cond
current-level ((not (featurep 'org-inlinetask)) "")
(cond (org-odd-levels-only (- (* 2 org-inlinetask-min-level)
((not (featurep 'org-inlinetask)) "") 3))
(org-odd-levels-only (- (* 2 org-inlinetask-min-level) (t (1- org-inlinetask-min-level))))))
3)) ;; Display parent heading.
(t (1- org-inlinetask-min-level)))))) (outline-flag-region (line-end-position 0) (line-end-position) nil)
;; Display parent heading. (forward-line)
(outline-flag-region (line-end-position 0) (line-end-position) nil) ;; Display children. First child may be deeper than expected
(forward-line) ;; MAX-LEVEL. Since we want to display it anyway, adjust
;; Display children. First child may be deeper than expected ;; MAX-LEVEL accordingly.
;; MAX-LEVEL. Since we want to display it anyway, adjust (while (re-search-forward re end t)
;; MAX-LEVEL accordingly. (unless past-first-child
(while (re-search-forward re end t) (setq re (format regexp-fmt
(unless past-first-child current-level
(setq re (format regexp-fmt (max (funcall outline-level) max-level)))
current-level (setq past-first-child t))
(max (funcall outline-level) max-level))) (outline-flag-region (line-end-position 0) (line-end-position) nil)))))
(setq past-first-child t))
(outline-flag-region
(line-end-position 0) (line-end-position) nil))))))
(defun org-show-subtree () (defun org-show-subtree ()
"Show everything after this heading at deeper levels." "Show everything after this heading at deeper levels."